顺序模型

https://keras.io/zh/

https://keras.io/zh/getting-started/sequential-model-guide/

https://github.com/keras-team/keras/tree/master/examples   keras实例

机器学习面试100题： https://blog.csdn.net/T7SFOKzorD1JAYMSFk4/article/details/78960039

顺序模型的API： https://keras.io/zh/models/sequential/ 

顺序模型是多个网络层的线性堆叠，可以使用 .add() 方法将各层添加到模型中。通过input_shape参数指定输入数据的尺寸，它是一个表示尺寸的元组 (一个整数或 None 的元组，其中 None 表示可能为任何正整数)，在 input_shape 中不包含数据的 batch 大小。

编译模型：通过 compile 方法完成的，它接收三个参数：

1、优化器 optimizer。它可以是现有优化器的字符串标识符，如 rmsprop 或 adagrad，也可以是 Optimizer 类的实例。详见optimizers

2、损失函数 loss，模型试图最小化的目标函数。它可以是现有损失函数的字符串标识符，如 categorical_crossentropy 或 mse，也可以是一个目标函数。详见losses

3、评估标准 metrics。对于任何分类问题，你都希望将其设置为 metrics = ['accuracy']。评估标准可以是现有的标准的字符串标识符，也可以是自定义的评估标准函数。

训练：fit函数，详见文档

代码详解：

基于多层感知器 (MLP) 的 softmax 多分类：

import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.optimizers import SGD

# 生成虚拟数据
import numpy as np
x_train = np.random.random((1000, 20))
y_train = keras.utils.to_categorical(np.random.randint(10, size=(1000, 1)), num_classes=10) # one-hot
x_test = np.random.random((100, 20))
y_test = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)

# 定义网络结构
model = Sequential()
# Dense(64) 是一个具有 64 个隐藏神经元的全连接层。
# 在第一层必须指定所期望的输入数据尺寸：
# 在这里，是一个 20 维的向量。
model.add(Dense(64, activation='relu', input_dim=20))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
              optimizer=sgd,
              metrics=['accuracy'])

model.fit(x_train, y_train,
          epochs=20,
          batch_size=128)
score = model.evaluate(x_test, y_test, batch_size=128)

类似vgg的卷积神经网络： 

import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import SGD 

x_train = np.random.random((100, 100, 100, 3)) 
y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)
x_test = np.random.random((20, 100, 100, 3)) 
y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)

'''
vgg网络:五组卷积操作，每两组之间做max-pooling空间降维
五组卷积操作中卷积核的数目由较浅组的64增多到最深组的512(feature map的数目)，同一组中的卷积核的数目相同
每组卷积操作由(若干组conv)->BN->ReLu->Dropout和一组pooling组成
五组卷积之后接两层全连接层，之后是分类层
'''

model = Sequential()
# 输出shape: 100 * 100 * 32
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
# 输出shape: 100 * 100 * 64
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

#将输入展平，变为一维数组
model.add(Flatten()) 
# Dense: 全连接层
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)

model.fit(x_train, y_train, batch_size=32, epochs=10)
score = model.evaluate(x_test, y_test, batch_size=32)

基于栈式LSTM的序列分类：

参考https://www.cnblogs.com/ljygoodgoodstudydaydayup/p/10272539.html

将 3 个 LSTM 层叠在一起，使模型能够学习更高层次的时间表示。前两个 LSTM 返回完整的输出序列，但最后一个只返回输出序列的最后一步，从而降低了时间维度（即将输入序列转换成单个向量）。

from keras.models import Sequential
from keras.layers import LSTM, Dense
import numpy as np

data_dim = 16
timesteps = 8 
num_classes = 10

# 期望输入数据尺寸: (batch_size, timesteps, data_dim)
# timesteps: 相当于一个句子中的单词数, data_dim: 单词embedding后的向量维度
model = Sequential()
model.add(LSTM(32, return_sequences=True,
               input_shape=(timesteps, data_dim)))  # 返回维度为 32 的向量序列
model.add(LSTM(32, return_sequences=True))  # 返回维度为 32 的向量序列
model.add(LSTM(32))  # 返回维度为 32 的单个向量
model.add(Dense(10, activation='softmax'))

model.compile(loss='categorical_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

# 生成虚拟训练数据
x_train = np.random.random((1000, timesteps, data_dim))
y_train = np.random.random((1000, num_classes)) # num_classes对应softmax输出的向量维度

# 生成虚拟验证数据
x_val = np.random.random((100, timesteps, data_dim))
y_val = np.random.random((100, num_classes))

model.fit(x_train, y_train,
          batch_size=64, epochs=5,
          validation_data=(x_val, y_val))