引用

官方中文文档地址

框架介绍

 &emsp:相当于封装后的神经网络框架，底层基于TensorFlow等其他神经网络框架运行（因此需要先安装对应的底层框架），使用该框架能够很简易的实现神经网络对应的代码、但相对的运行速度也会慢一些.

使用介绍

使用步骤

1.导入相关模块

from keras.models import Sequential
# 导入最简单的顺序模型（即按顺序一层一层的添加层的那种）
from keras.layers import Dense
# 导入全连接层

2.创建训练数据x_train、y_train以及测试数据x_test、y_test
3.构建模型：model = Sequential()
4.添加层：model.add(Dense(units=输出维度, input_dim=输入维度))
5.编译模型：model.compile(optimizer=优化器, loss=损失函数)
6.训练模型：model.fit(x_train, y_train, batch_size=批次大小, epochs=迭代次数)/model.train_on_batch(x_train, y_train)
7.评估模型：loss, accuracy = model.evaluate(x_test, y_test)
8.测试模型：y = model.predit(x_test)

简单示例

# 导入相关模块
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
# 导入sgd优化器

# 创建测试数据
x_train = np.linspace(-0.5, 0.5, 100)[:, np.newaxis]
# 生成-0.5到0.5的100个等差数列，并转成二维数据，即从1行200列转成100行1列
noise = np.random.normal(0, 0.02, x_train.shape)
# 生成和x_train格式相同的噪音数据
y_train = np.square(x_train) + noise
# 期望值为x_train的平方加上噪音
x_test = x_train

model = Sequential()
# 创建模型
model.add(Dense(units=10, input_dim=1, activation='tanh'))
# 添加一个全连接层，1个输入，10个输出，激活函数为tanh
model.add(Dense(units=1, activation='tanh'))
# 同上
sgd = SGD(lr=0.3)
# 定义sgd优化器，学习率为0.3
model.compile(optimizer=sgd, loss='mse')
# 编译模型，优化器为sgd（可以使用字符串的'sgd'，即默认的sgd，但是学习率为0.01），损失函数为mse
plt.scatter(x_train, y_train)
# 绘画训练数据散点图
for i in range(2000):
    loss = model.train_on_batch(x_train, y_train)
    # 训练模型
    if i % 500 == 0:
        print(loss)
# 上面的训练等效于：
# model.fit(x_train, y_train, epochs=2000)
y_test = model.predict(x_test)
# 预测测试数据结果
plt.plot(x_test, y_test, 'r')
# 绘画预测曲线
plt.show()

基本使用

模块内容
在keras的不同包里存放着各种对应封装好的api，部分如下：

keras.models       各种模型以及模型操作，如：Sequential、save_model、load_model
keras.layers       各种神经网络层，如：Dense、Activation、Dropout
keras.optimizers   各种优化器，如：SGD、Adam
keras.datasets     各种数据集，如：mnist
keras.regularizers 各种正则化方法，如：l1、l2、l1_l2
keras.preprocessing.image  各种图像操作，如：ImageDataGenerator、load_img、img_to_array
kears.utils        各种工具方法，如：to_categorical（one-hot编码）
keras.callbacks    各种训练过程中的回调方法，如：EarlyStopping、ModelCheckpoint

导入数据集
例如使用mnist数据集：

from keras.datasets import mnist
# 导入数据集
from keras.utils import np_utils
# 导入numpy工具包
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 载入数据
print(x_train.data.shape, y_train.data.shape)
# 输出数据形状
print(x_test.data.shape, y_test.data.shape)

构建模型
从keras.models当中导入对应的模型，然后初始化即可，举例：

model = Sequential()

添加层
有两种方式：
1.使用model.add()
  由于model可迭代，因此如果要再添加层数，可以再通过mode.add(...)添加，由于前一层设置后的输出维度默认为下一层的输入维度，因此下一层可以不用设置input_dim属性，举例：

model.add(Dense(units=10, input_dim=1))
model.add(Dense(units=1))
# 默认下一层的输入是上一层的输入，所以第二层此时等效于：input_dim=10

2.在构建模型的时候添加
通过一个列表传入，举例：

model = Sequential([
  Dense(units=1, input_dim=1, activation='tanh'),
  Dense(...),
  ...
])

全连接层
Dense()，属性介绍：

batch_size           一次训练批次大小（默认None）
input_dim            输入维度
units                输出维度
activation           激活函数（默认None）
use_bias             是否使用偏置值（默认True）
kernel_initializer   权值初始化方式
bias_initializer     偏置初始化方式，例如：'zeros'则为0、'ones'则为1
kernel_regularizer   权值正则化

编译模型
需要配置模型的优化器、损失函数以及以下返回的数据等，举例：

model.compile(optimizer='sgd', loss='mse', metrics=['accuracy'])
# optimizer：设置优化器sgd（Stochastic gradient descent）：随机梯度下降法
# loss：损失函数mse（mean squared error）：均方误差
# metrics返回的数据属性：accuracy为准确率

训练模型
主要有两种训练方式：
1.使用train_on_batch()按批次训练
按批次大小循环一次，因此迭代次数需要自己用循环来设置，举例：

for i in range(2000):
    loss = model.train_on_batch(x_train, y_train)
    # 训练模型，默认返回loss值，如果设置了metrics属性，则会多返回对应值
    if i % 500 == 0:
        print(loss)

2.使用fit()训练
  设置好批次大小和迭代次数后会自动进行训练，并且会输出每次的loss值、metrics属性里值的变化，举例：

model.fit(x_train, y_train, batch_size=200, epochs=10)

batch_size和epochs理解：比如有1000个数据，设置batch_size=100，那么训练一次就100个数据，训练10次为一个迭代周期，再设置epochs=10，则要再重复这种训练10次，总的就是100次）
注：fit()返回一个对象存储了迭代次数、loss值变化、模型、训练参数配置等内容，举例：

mf = model.fit(x_train, y_train, epochs=5)
print(mf.epoch, mf.history, mf.model, mf.params)
# 输出：迭代索引、loss值变化、模型、训练参数配置

训练回调
  在训练模型当中，可以设置一些回调函数用于进行训练过程当中的操作，下面介绍一些常用的回调
提前结束训练

from keras.callbacks import EarlyStopping
early_stop = EarlyStopping(monitor='val_loss',  # 以验证集的loss为基准判断
                           min_delta=0.001,
                           patience=15, # 如果连续15次loss不下降就直接结束训练
                           mode='min',
                           verbose=1)

自动保存模型

from keras.callbacks import ModelCheckpoint
checkpoint = ModelCheckpoint('best.h5', 
                             monitor='val_loss',  # 以验证集的loss为基准判断
                             verbose=1, 
                             save_best_only=True,   # 保存最好的一版模型
                             mode='min',   # loss最低的时候保存
                             period=1)

使用回调训练示例：

history = model.fit_generator(
                    generator = train_batch,   # 训练集数据
                    steps_per_epoch  = len(train_batch), 
                    epochs           = 200,
                    verbose          = 0,
                    validation_data  = valid_batch,  # 验证集数据
                    validation_steps = len(valid_batch),
                    callbacks        = [early_stop, checkpoint],   # 这里使用回调，传入一组配置好的回调方法
                    max_queue_size   = 3
)

评估模型
可以计算测试模型的loss值大小以及准确率，举例：

loss, accuracy = model.evaluate(x_test, y_test)

测试模型：
对于训练好的模型，可以使用测试数据去测试结果，举例：

y = model.predit(x_test)
# 根据x_test去预测y的值

其他
获取某一层权值和偏置值
可以索引到第i层并使用get_weights()方法获取对应权值和偏置值，举例：

W, b = model.layers[0].get_weights()
# 获取第一层权值和偏置值

模型保存
举例：

# 构建、训练模型等一系列步骤
...
model.save('xxx.h5')
# 保存的是hdf5文件，可以安装h5py模块（pip install h5py）来读取

模型载入
举例：

from keras.models import load_model
# 载入模型方法
model = load_model('xxx.h5')
# 载入模型，接下来就可以直接使用或者继续进行训练等一系列操作

参数保存和载入
举例：

model.save_weights('xxx.h5')
# 只保存了参数
model.load_weights('xxx.h5')
# 载入参数

打印网络结构

model.summary()

模型转成json格式（网络结构）、载入json
举例：

s_json = model.to_json()
# 转成json格式，包括各项配置
...
from keras.models import model_from_json
# 载入json方法
model = model_from_json(s_json)
# 将json字符串转成模型

绘制json数据（网络结构），即将json数据转成的模型以图形方式展示
使用前需要进行以下操作：
1.pip install pydot
2.下载安装graphviz软件
完成上述步骤即可进行模型网络结构绘制，举例：

from keras.utils.vis_utils import plot_model
# 导入绘图工具包

# 构建模型，只用构建层等就行了
...
plot_model(model, to_file="xxx.png", show_shapes=True, 
          show_layer_names=False, rankdir='TB')
# 绘制模型
# 传入参数：模型、图片名、图片内是否显示各层输入输出形状、
# 是否显示各层名、方向（TB代表top->bottom，左右就可以：LR）

基本配置
优化器
编译模型时可以通过引用优化器的字符串来使用优化器，也可以通过导入相关优化器后自定义修改这些优化器，举例：

from keras.optimizers import SGD
# 导入sgd优化器
sgd = SGD(lr=0.1)
# 设置优化器的学习率为0.1，默认0.01
model.compile(optimizer=sgd, loss='mse')
# 使用自定义的优化器

交叉熵
如若使用交叉熵，则在编译模型中配置loss如下：

model.compile(optimizer='sgd', loss='categorical_crossentropy')
# 使用交叉熵

激活函数
有两种添加方法
1.单独一层用来作为激活函数

from keras.layers import Activation
...
model.add(Dense(input_dim=1, units=1)
model.add(Activation('tanh'))

2.在某个层里定义运算后执行的激活函数

model.add(Dense(input_dim=1, units=1, activation='relu')

dropout
需要使用dropout时，则添加层如下：

from keras.layers import Dropout
...
model.add(Dropout(0.4))
# 随机选取40%的神经元工作

正则化
需要对数据使用正则化时，举例如下：

from keras.regularizers import l2
# 导入l2正则化
...
model.add(Dense(input_dim=1, units=1, activation='relu', kernel_regularizer=l2(0.0003))
# 权值正则化，使用l2正则化，正则化系数为0.0003

CNN

使用卷积神经网络，举例如下：

from keras.layers import Convolution2D, MaxPooling2D, Flatten
# 导入二维卷积、二维最大池化、扁平化（转成一维数据）模块
...
model.add(Convolution2D(  # 添加卷积层
  input_shape=(28, 28, 1),  # 数据格式：(行, 列, 通道数)
  filters=32,  # 滤波器个数
  kernel_size=5, # 卷积窗口大小，这里是5*5
  strides=2, # 步长
  padding='same', # padding方式：same/valid
  activation='adam' # 激活函数
))
model.add(MaxPooling2D(  # 添加池化层
  pool_size=2, # 池化窗口大小：2*2
  strides=2, # 步长
  padding='same'  # padding方式
))
...
# 重复几次卷积和池化
...
model.add(Flatten())
# 扁平化处理
...
# 循环几次(添加卷积层->添加池化层)->扁平化->全连接层输出

RNN

使用循环神经网络，举例如下：

from keras.layers.recurrent import SimpleRNN, LSTM, GRU
# 导入最普通的RNN、LSTM和GRU，三种RNN使用方法差不多
...
model.add(SimpleRNN(  # 添加RNN层
  units=50, # 隐藏层个数，也是输出个数
  input_size=(28, 28) # 行列数
))
...
model.add(Dense(10, activation='softmax'))