Keras是一套基于Tensorflow、Theano及CNTK后端的高层神经网络API，可以非常友好地支持快速实验，本文从零开始介绍了如何使用Keras搭建MLP并给出两个示例。
基于Ubuntu安装Keras
具体安装过程在官方中英文文档中有详细说明
中文 https://keras-cn.readthedocs.io/en/latest/for_beginners/keras_linux/
Keras基础知识
Sequential models
可以认为Keras中的所谓模型(models)就是某个具体的网络结构，如MLP、CNN、LSTM等，在Keras中它们被分为两种：序贯模型(Sequential)和函数式模型(Model)。
Sequential模型就是一个直接由若干网络层线性堆叠起来的网络，使用如下代码创建一个Sequential对象：
from keras.models import Sequentialmodel = 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 npfrom keras.models import Sequential
from keras.layers import Dense
from keras import optimizersdata_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 npfrom keras.models import Sequential
from keras.layers import Dense
from keras import optimizersdata_size = 50
batch_size = 40
learning_rate = 0.0003
epochs = 500x_train = np.linspace(-25, 25, data_size)
y_train = 3 * x_train + 5 + np.random.rand(*x_train.shape)*0.3model = 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_functionimport keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSpropbatch_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
