Keras模型简介
Keras的初始构建块是一个模型，最简单的模型称为序列。Keras序列模型是一个神经网络层的线性管道(一个堆栈)。
from keras.models import Sequential
model = Sequential()
model.add(Dense(12, input_dim=8, kernel_initializer='random_uniform'，bias_initializer='zeros')))
上述代码定义了一个12个人工神经元单层网络，需要8个输入变量（特征值），每个神经元用具体的权重初始化。
构成模块的第二种方式是通过functional API，在那里可以定义复杂的模型，例如有向无环图、具有共享层的模型或多输出模型。
常规的全连接层
keras.layers.core.Dense(units, activation=None, use_bias=True, kernel_initializer='glorot_uniform'）
预先定义的RNN
keras.layers.recurrent.Recurrent(return_sequences=False, go_backwards=False, stateful=
keras.layers.recurrent.SimpleRNN(units, activation='tanh', use_bias=True, kernel_initializer=
keras.layers.recurrent.GRU(units, activation='tanh', recurrent_activation='hard_sigmoid'
keras.layers.recurrent.LSTM(units, activation='tanh', recurrent_activation='hard_sigmoid'
卷积和池化层
ConvNets是一种使用卷积和池化操作的神经网络，它基于抽象的渐进层次逐步学习相当复杂的模型。这种渐进抽象的学习类似于在人类大脑中进化了数百万年的视觉模型。几年前，人们把它叫做深度3-5层，现在已经上升到100-200。
keras.layers.convolutional.Conv1D(filters, kernel_size, strides=1, padding='valid', dilation_rate=
keras.layers.convolutional.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid'
keras.layers.pooling.MaxPooling1D(pool_size=2, strides=None, padding='valid')
keras.layers.pooling.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=
Keras的基本操作
根据以上的方法，设置模型参数：
import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.optimizers import SGD
from keras.utils import np_utils
np.random.seed(1671) # for reproducibility
# network and training
NB_EPOCH = 200
BATCH_SIZE = 128
VERBOSE = 1
NB_CLASSES = 10 # number of outputs = number of digits
OPTIMIZER = SGD() # SGD optimizer, explained later in this chapter
N_HIDDEN = 128
VALIDATION_SPLIT=0.2 # how much TRAIN is reserved for VALIDATION
# data: shuffled and split between train and test sets
# (
X_train, y_train), (X_test, y_test) =
mnist.load_data()
#X_train is 60000 rows of 28x28 values --> reshaped in 60000 x 784
RESHAPED = 784
# X_train =
X_train.reshape(60000, RESHAPED)
X_test = X_test.reshape(10000, RESHAPED)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# normalize
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 = np_utils.to_categorical(y_train, NB_CLASSES)
Y_test = np_utils.to_categorical(y_test, NB_CLASSES)
通常，设置完以上参数时，模型可以设置编译了，如下：
# 10 outputs
# final stage is softmax
model = Sequential()
model.add(Dense(NB_CLASSES, input_shape=(RESHAPED,)))
model.add(Activation('softmax'))
model.summary() # output the model constuct including the total params
model.compile(loss='categorical_crossentropy', optimizer=OPTIMIZER, metrics=['accuracy'])
一旦模型被编译完成，接着就可以用 fit 函数训练了，其中需要设置参数如下：
epochs
这是模型用于训练的次数。在每次迭代中，优化器尝试调整权重，使目标函数最小化。
batch_size
这是在优化器执行权重更新之前用到的训练实例的数量。
设置完以上参数，则可以对模型进行 fit 操作了：
history = model.fit(X_train, Y_train,
batch_size=BATCH_SIZE, epochs=NB_EPOCH,
verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
一旦训练了模型，我们就可以在测试集上进行评估。通过这种方法，我们可以得到目标函数所达到的最小值，以及评价指标达到的最佳值。
score = model.evaluate(X_test, Y_test, verbose=VERBOSE)
print("Test score:", score[0]) #loss
print('Test accuracy:', score[1]) #accuracy
基于以上层，再加入隐藏层和Drop out，代码如下：
import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.optimizers import SGD
from keras.utils import np_utils
np.random.seed(1671) # for reproducibility
# network and training
NB_EPOCH = 20
BATCH_SIZE = 128
VERBOSE = 1
NB_CLASSES = 10 # number of outputs = number of digits
OPTIMIZER = SGD() # optimizer, explained later in this chapter
N_HIDDEN = 128
VALIDATION_SPLIT=0.2 # how much TRAIN is reserved for VALIDATION
# data: shuffled and split between train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
#X_train is 60000 rows of 28x28 values --> reshaped in 60000 x 784
RESHAPED = 784
# X_train =
X_train.reshape(60000, RESHAPED)
X_test = X_test.reshape(10000, RESHAPED)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# normalize
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 = np_utils.to_categorical(y_train, NB_CLASSES)
Y_test = np_utils.to_categorical(y_test, NB_CLASSES)
# M_HIDDEN hidden layers
# 10 outputs
# final stage is softmax
model = Sequential()
model.add(Dense(N_HIDDEN, input_shape=(RESHAPED,)))
model.add(Activation('relu'))
model.add(Dropout(DROPOUT))
model.add(Dense(N_HIDDEN))
model.add(Activation('relu'))
model.add(Dropout(DROPOUT))
model.add(Dense(NB_CLASSES))
model.add(Activation('softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=OPTIMIZER,
metrics=['accuracy'])
history = model.fit(X_train, Y_train,
batch_size=BATCH_SIZE, epochs=NB_EPOCH,
verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
score = model.evaluate(X_test, Y_test, verbose=VERBOSE)
print("Test score:", score[0])
print('Test accuracy:', score[1])
预测输出
当一个网络被训练时，它可以被用来预测。在Keras这很简单，我们可以使用以下方法：
# calculate predictions
predictions = model.predict(X)
对于给定的输入，可以计算几种类型的输出，包括方法：
model.evaluate(): This is used to compute the loss values
model.predict_classes(): This is used to compute category outputs
model.predict_proba(): This is used to compute class probabilities