基于Keras搭建MLP

Keras是一套基于Tensorflow、Theano及CNTK后端的高层神经网络API，可以非常友好地支持快速实验，本文从零开始介绍了如何使用Keras搭建MLP并给出两个示例。

基于Ubuntu安装Keras

具体安装过程在官方中英文文档中有详细说明

中文 https://keras-cn.readthedocs.io/en/latest/for_beginners/keras_linux/

英文 https://keras.io/#installation

Keras基础知识

Sequential models

可以认为Keras中的所谓模型(models)就是某个具体的网络结构，如MLP、CNN、LSTM等，在Keras中它们被分为两种：序贯模型(Sequential)和函数式模型(Model)。

Sequential模型就是一个直接由若干网络层线性堆叠起来的网络，使用如下代码创建一个Sequential对象：

from keras.models import Sequential

model = Sequential()

Sequential的构造函数可以接收一个由layer组成的list，用以初始化该model

model = Sequential([

    Dense(32, input_shape=(784,)),#一个Dense层

    Activation('relu'),#为上一个Dense层附加激活函数

    Dense(10),#再添加一个Dense层

    Activation('softmax'),#为上一个Dense层附加激活函数

])

也可以使用.add()方法对该model初始化：

model.add(Dense(32, input_shape=(784,)))

model.add(Activation('relu'))

Dense layer

Dense layer即全连接层，构造方法如下：

keras.layers.core.Dense(

  units,

  activation=None,

  use_bias=True,

  kernel_initializer='glorot_uniform',

  bias_initializer='zeros',

  kernel_regularizer=None,

  bias_regularizer=None,

  activity_regularizer=None,

  kernel_constraint=None,

  bias_constraint=None)

units：大于0的整数，表示该层输出维度。

activation：激活函数。

use_bias：是否使用偏置。

kernel_initializer：权值矩阵初始化方法。

bias_initializer：偏置的初始化方法。

regularizer与constraint：正则项与约束项。

我们可以使用前文提到的.add()方法为model添加全连接层，只有输入层需要指定输入数据维度，之后的层不需再指定前一层的维度。

compile & fit

model的结构设置好之后使用compile方法编译：

model.compile(

  self,

  optimizer,

  loss,

  metrics=None,

  sample_weight_mode=None)

optimizer：预定义的优化器名称或自定义的优化器对象。

loss：预定义的损失函数名称或自定义的目标函数。

编译后使用fit方法训练模型：

model.fit(

  self,

  x,

  y,

  batch_size=32,

  epochs=10,

  verbose=1,

  callbacks=None,

  validation_split=0.0,

  validation_data=None,

  shuffle=True,

  class_weight=None,

  sample_weight=None,

  initial_epoch=0)

x：作为输入数据的numpy array。

y：作为标签的numpy array。

batch_size：梯度下降时每个batch包含的样本数。

epochs：训练总轮数。

verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录。

训练一个线性回归模型

一个线性回归模型可以被认为是一个MLP的特例，即一个输入与输出只有1维且没有激活函数(或激活函数为线性函数a(x)=x)的MLP，我们首先生成一些离散的点，使这些点大致成线性关系，再构建一个Sequential model，最后在这些点上训练该model以得到它们的线性关系。

import numpy as np

from keras.models import Sequential

from keras.layers import Dense

from keras import optimizers

data_size = 50 # 生成的数据集大小

batch_size = 40

learning_rate = 0.01

epochs = 300

# 在正负1之间均匀产生data_size个点

x_train = np.linspace(-1, 1, data_size)

# 使得数据点呈y=3x+5的关系，添加小范围正态随机数以获得数据的随机波动效果

y_train = 3 * x_train + 5 + np.random.rand(*x_train.shape)*0.3

# 创建一个Sequential模型

model = Sequential()

# 添加一个全连接层，输入数据维度为1，含一个输出单元，RandomUniform表示权值在正负0.05间均匀随机初始化

model.add(Dense(units=1, input_dim=1, kernel_initializer='RandomUniform'))

# 打印查看当前的权重

print(model.layers[0].get_weights())

# 创建一个SGD对象以调整学习速率

sgd = optimizers.SGD(lr=learning_rate)

# 编译model，优化器使用刚创建的SGD对象，损失函数使用最小均方差mse

model.compile(optimizer=sgd, loss='mse')

# 使用之前生成的数据训练

history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1)

# 再次打印权重，可以看到其值在3与5附近

print(model.layers[0].get_weights())

结果：

...

Epoch 298/300

50/50 [==============================] - 0s 36us/step - loss: 0.0325

Epoch 299/300

50/50 [==============================] - 0s 45us/step - loss: 0.0264

Epoch 300/300

50/50 [==============================] - 0s 56us/step - loss: 0.0260

[array([[2.9937706]], dtype=float32), array([5.0084023], dtype=float32)]

有趣的是，当我们调整数据点的范围，将

x_train = np.linspace(-1, 1, data_size)

改为

x_train = np.linspace(-25, 25, data_size)

保持其他部分不变,再次运行程序训练，loss会振荡到无穷到导致训练失败，这是学习率过大造成的，将learning_rate由0.01改为0.003，再次训练，即可得到正确结果。

我们还可以加入一个隐层，调整学习率与epochs后也可以得到很好的训练结果：

import numpy as np

from keras.models import Sequential

from keras.layers import Dense

from keras import optimizers

data_size = 50

batch_size = 40

learning_rate = 0.0003

epochs = 500

x_train = np.linspace(-25, 25, data_size)

y_train = 3 * x_train + 5 + np.random.rand(*x_train.shape)*0.3

model = Sequential()

#这里的units为4，即隐层单元个数为4

model.add(Dense(units=4, input_dim=1, kernel_initializer='RandomUniform'))

#再添加输出层，维度为1

model.add(Dense(units=1, kernel_initializer='RandomUniform'))

print(model.layers[0].get_weights())

print(model.layers[1].get_weights())

sgd = optimizers.SGD(lr=learning_rate)

model.compile(optimizer=sgd, loss='mse')

history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1)

print(model.layers[0].get_weights())

print(model.layers[1].get_weights())

结果：

Epoch 498/500

50/50 [==============================] - 0s 119us/step - loss: 0.0169

Epoch 499/500

50/50 [==============================] - 0s 156us/step - loss: 0.0168

Epoch 500/500

50/50 [==============================] - 0s 85us/step - loss: 0.0182

[array([[ 0.8122992 , -0.08030439, -0.05526135, -1.0514123 ]],

      dtype=float32), array([ 1.110988  , -0.11047827, -0.07585457, -1.4386528 ], dtype=float32)]

[array([[ 1.3721825 ],

       [-0.13642032],

       [-0.09367472],

       [-1.7768502 ]], dtype=float32), array([0.968823], dtype=float32)]

结果中两个list中的第一个array是权值，第二个array是偏置。

训练一个用于识别MNIST的MLP

在Keras安装路径下的examples文件夹中可以找到mnist_mlp.py：

from __future__ import print_function

import keras

from keras.datasets import mnist

from keras.models import Sequential

from keras.layers import Dense, Dropout

from keras.optimizers import RMSprop

batch_size = 128

num_classes = 10

epochs = 20

#读取mnist的训练与测试数据

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

#归一到(0,1)区间内

x_train /= 255

x_test /= 255

print(x_train.shape[0], 'train samples')

print(x_test.shape[0], 'test samples')

# convert class vectors to binary class matrices

y_train = keras.utils.to_categorical(y_train, num_classes)

y_test = keras.utils.to_categorical(y_test, num_classes)

#使用了两个隐层，每个隐层512个单元，激活函数选用relu，添加了Dropout防止过拟合，最后通过softmax输出

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(num_classes, activation='softmax'))

model.summary()

#损失函数选用多分类对数损失函数，优化器选用RMSprop

model.compile(loss='categorical_crossentropy',

              optimizer=RMSprop(),

              metrics=['accuracy'])

history = model.fit(x_train, y_train,

                    batch_size=batch_size,

                    epochs=epochs,

                    verbose=1,

                    validation_data=(x_test, y_test))

score = model.evaluate(x_test, y_test, verbose=0)

print('Test loss:', score[0])

print('Test accuracy:', score[1])

结果：

...

59392/60000 [============================>.] - ETA: 0s - loss: 0.0183 - acc: 0.99

59776/60000 [============================>.] - ETA: 0s - loss: 0.0182 - acc: 0.99

60000/60000 [==============================] - 15s 253us/step - loss: 0.0182 - acc: 0.9953 - val_loss: 0.1072 - val_acc: 0.9842

Test loss: 0.10721807914278024

Test accuracy: 0.9842