Keras是由纯python编写的基于theano/tensorflow的深度学习框架。Keras是一个高层神经网络API，支持快速实验，能够把你的idea迅速转换为结果，如果有如下需求，可以优先选择Keras：
 
a）简易和快速的原型设计（keras具有高度模块化，极简，和可扩充特性）
 
b）支持CNN和RNN，或二者的结合
 
c）无缝CPU和GPU切换
 
Keras模块结构：
 
 
使用Keras搭建一个神经网络：
 
 
【【【一些概念：
 
          （1）目前主要有两种方式来表示张量： a) th模式或channels_first模式，Theano和caffe使用此模式。b）tf模式或channels_last模式，TensorFlow使用此模式。
 
            例：对于100张RGB3通道的16×32（高为16宽为32）彩色图，th表示方式：（100,3,16,32）；tf表示方式：（100,16,32,3）。唯一的区别就是表示通道个数3的位置不一样。
 
          （2）Keras有两种类型的模型，序贯模型（Sequential）和函数式模型（Model），函数式模型应用更为广泛，序贯模型是函数式模型的一种特殊情况。 a）序贯模型（Sequential）:单输入单输出，一条路通到底，层与层之间只有相邻关系，没有跨层连接。这种模型编译速度快，操作也比较简单  b）函数式模型（Model）：多输入多输出，层与层之间任意连接。这种模型编译速度慢。
 
        （3）neural layers(神经层), cost functions(损失函数), optimizers(优化器), initialization schemes(初始化方案), activation functions(激活函数), regularization(正则化项)在keras中都是独立的模块，可以自由组合。】】】
 
            
 
以上内容来自：https://blog.csdn.net/zdy0_2004/article/details/74736656
 
模型快速教程，可以看：http://keras-cn.readthedocs.io/en/latest/getting_started/sequential_model/
 
一个keras model的例子（函数式模型）：
 
def model(input_shape):
    # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!
    X_input = Input(input_shape)

    # Zero-Padding: pads the border of X_input with zeroes
    X = ZeroPadding2D((3, 3))(X_input)

    # CONV -> BN -> RELU Block applied to X
    X = Conv2D(32, (7, 7), strides=(1, 1), name='conv0')(X)
    X = BatchNormalization(axis=3, name='bn0')(X)
    X = Activation('relu')(X)

    # MAXPOOL
    X = MaxPooling2D((2, 2), name='max_pool')(X)

    # FLATTEN X (means convert it to a vector) + FULLYCONNECTED
    X = Flatten()(X)
    X = Dense(1, activation='sigmoid', name='fc')(X)

    # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.
    model = Model(inputs=X_input, outputs=X, name='HappyModel')

    return model
 
一个keras model的实例：
 
# number of training examples = 600
# number of test examples = 150
# X_train shape: (600, 64, 64, 3)
# Y_train shape: (600, 1)
# X_test shape: (150, 64, 64, 3)
# Y_test shape: (150, 1)
X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()

# Normalize image vectors,像素值为最大255
X_train = X_train_orig / 255.
X_test = X_test_orig / 255.

# Reshape, transfer row to column
Y_train = Y_train_orig.T
Y_test = Y_test_orig.T

def HappyModel(input_shape):
    """
    Implementation of the HappyModel.

    Arguments:
    input_shape -- shape of the images of the dataset

    Returns:
    model -- a Model() instance in Keras
    """

    ### START CODE HERE ###
    # Feel free to use the suggested outline in the text above to get started, and run through the whole
    # exercise (including the later portions of this notebook) once. The come back also try out other
    # network architectures as well.

    # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!
    X_input = Input(input_shape)

    # Zero-Padding: pads the border of X_input with zeroes
    # 一种函数嵌套的形式
    X = ZeroPadding2D((3, 3))(X_input)

    # CONV -> BN -> RELU Block applied to X
    # 第一个参数为filters个数
    X = Conv2D(32, (7, 7), strides=(1, 1), name='conv0')(X)

    # axis: 整数，指定要规范化的轴，通常为特征轴。例如在进行data_format="channels_first的2D卷积后，一般会设axis=1

    X = BatchNormalization(axis=3, name='bn0')(X)
    X = Activation('relu')(X)

    # MAXPOOL
    X = MaxPooling2D((2, 2), name='max_pool')(X)

    # FLATTEN X (means convert it to a vector) + FULLYCONNECTED
    X = Flatten()(X)
    # Dense为全连接层
    X = Dense(1, activation='sigmoid', name='fc')(X)

    # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.
    model = Model(inputs=X_input, outputs=X, name='HappyModel')

    ### END CODE HERE ###

    return model


# mini-batch
happyModel = HappyModel(X_train.shape[1:])
happyModel.compile(optimizer="Adam", loss="binary_crossentropy", metrics=['accuracy'])
happyModel.fit(x=X_train, y=Y_train, epochs=10, batch_size=32)

preds = happyModel.evaluate(X_test, Y_test)
print()
print("Loss = " + str(preds[0]))
print("Test Accuracy = " + str(preds[1]))
 
1、类Dense，
 
 
 
Keras.layers.core.Dense(output_dim, init='glorot_uniform', activation='linear', weights=None, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, input_dim=None)
 
ouput_dim：int > 0，输出结果的维度
 
init：初始化权值的函数名称或Theano function。可以使用Keras内置的，也可以传递自己编写的Theano function。如果不给weights传递参数时，则该参数必须指明。
 
activation：激活函数名称或者Theano function。可以使用Keras内置的，也可以是传递自己编写的Theano function。如果不明确指定，那么将没有激活函数会被应用。
 
weights：用于初始化权值的numpy arrays组成的list。这个List至少有1个元素，其shape为（input_dim, output_dim）。（如果指定init了，那么weights可以赋值None）
2、
 
 
3、为什么有的Keras函数后两个()？？
 
Dense等类都是基于Layer类的，参考class Dense(Layer)，因此我们可以看看Layer这个类怎么写的。在Layer这个类里面，有这样一个函数：def __call__(self, inputs, **kwargs)；这个函数可以在python的文档中查到，通过定义这个函数，我们可以让一个对象当作函数使用。因此我们可以把下面代码拆分成这样：
 
X = Dense(64, activation='relu')(X)
# 拆分
fc = Dense(64, activation='relu')
X = fc(X)
 
或者说：Dense(64, avtivation='relu')执行__init__函数用于初始化得到一个类，然后调用对执行类的__call__函数，X=Dense(64, activation='relu')(inputs)，然后得到输出。
4、BatchNormalization（）:https://keras-cn.readthedocs.io/en/latest/layers/normalization_layer/
 
该层在每个batch上将前一层的激活值重新规范化，即使得其输出数据的均值接近0，其标准差接近1
 
（1）、在什么地方来进行BN：BN可以应用于网络中任意的activation set。特别指出在CNN中，BN应作用在非线性映射前，即对做规范化。
 
（2）、为什么用BN？克服深度神经网络难以训练的弊病，为了防止“梯度弥散”。关于梯度弥散，大家都知道一个简单的栗子：，在BN中，是通过将activation规范为均值和方差一致的手段使得原本会减小的activation的scale变大。总结起来就是BN解决了反向传播过程中的梯度问题（梯度消失和爆炸），同时使得不同scale的  整体更新步调更一致
 
（4）、什么时候使用BN？OK，说完BN的优势，自然可以知道什么时候用BN比较好。例如，在神经网络训练时遇到收敛速度很慢，或梯度爆炸等无法训练的状况时可以尝试BN来解决。另外，在一般使用情况下也可以加入BN来加快训练速度，提高模型精度。
 
 
 
 
 
 
 
 
 
 
 
 

大神笔记，转载自http://blog.csdn.net/u012162613/article/details/45397033
 
Keras简介
 
Keras是基于Theano的一个深度学习框架，它的设计参考了Torch，用Python语言编写，是一个高度模块化的神经网络库，支持GPU和CPU。使用文档在这：http://keras.io/，这个框架貌似是刚刚火起来的，使用上的问题可以到github提issue:https://github.com/fchollet/keras　
 
下面简单介绍一下怎么使用Keras，以Mnist数据库为例,编写一个CNN网络结构，你将会发现特别简单。
 
Keras里的模块介绍
 
Optimizers
 
顾名思义，Optimizers包含了一些优化的方法，比如最基本的随机梯度下降SGD,另外还有Adagrad、Adadelta、RMSprop、Adam，一些新的方法以后也会被不断添加进来
 
上面的代码是SGD的使用方法，lr表示学习速率,momentum表示动量项，decay是学习速率的衰减系数(每个epoch衰减一次),Nesterov的值是False或者True，表示使不使用Nesterov momentum。其他的请参考文档。
 
Objectives
 
这是目标函数模块，keras提供了mean_squared_error，mean_absolute_error 
 ，squared_hinge，hinge，binary_crossentropy，categorical_crossentropy这几种目标函数。
 
这里binary_crossentropy 和 categorical_crossentropy也就是常说的logloss.
 
Activations
 
这是激活函数模块，keras提供了linear、sigmoid、hard_sigmoid、tanh、softplus、relu、softplus，另外softmax也放在Activations模块里(我觉得放在layers模块里更合理些）。此外，像LeakyReLU和PReLU这种比较新的激活函数，keras在keras.layers.advanced_activations模块里提供。
 
Initializations
 
这是参数初始化模块，在添加layer的时候调用init进行初始化。keras提供了uniform、lecun_uniform、normal、orthogonal、zero、glorot_normal、he_normal这几种。
 
layers
 
layers模块包含了core、convolutional、recurrent、advanced_activations、normalization、embeddings这几种layer。
 
其中core里面包含了flatten(CNN的全连接层之前需要把二维特征图flatten成为一维的)、reshape（CNN输入时将一维的向量弄成二维的）、dense(就是隐藏层，dense是稠密的意思),还有其他的就不介绍了。convolutional层基本就是Theano的Convolution2D的封装。
 
Preprocessing
 
这是预处理模块，包括序列数据的处理，文本数据的处理，图像数据的处理。重点看一下图像数据的处理，keras提供了ImageDataGenerator函数,实现data augmentation，数据集扩增，对图像做一些弹性变换，比如水平翻转，垂直翻转，旋转等。
 
Models
 
这是最主要的模块，模型。上面定义了各种基本组件，model是将它们组合起来，下面通过一个实例来说明。
 
3.一个实例：用CNN分类Mnist
 
数据下载
 
Mnist数据在其官网上有提供，但是不是图像格式的，因为我们通常都是直接处理图像，为了以后程序能复用，我把它弄成图像格式的，这里可以下载：http://pan.baidu.com/s/1qCdS6，共有42000张图片。
 
读取图片数据
 
keras要求输入的数据格式是numpy.array类型（numpy是一个python的数值计算的库），所以需要写一个脚本来读入mnist图像，保存为一个四维的data，还有一个一维的label，代码：
 
#coding:utf-8

import os
from PIL import Image
import numpy as np

#读取文件夹mnist下的42000张图片，图片为灰度图，所以为1通道，
#如果是将彩色图作为输入,则将1替换为3，并且data[i,:,:,:] = arr改为data[i,:,:,:] = [arr[:,:,0],arr[:,:,1],arr[:,:,2]]
def load_data():
    data = np.empty((42000,1,28,28),dtype="float32")
    label = np.empty((42000,),dtype="uint8")

    imgs = os.listdir("./mnist")
    num = len(imgs)
    for i in range(num):
        img = Image.open("./mnist/"+imgs[i])
        arr = np.asarray(img,dtype="float32")
        data[i,:,:,:] = arr
        label[i] = int(imgs[i].split('.')[0])
    return data,label
 
构建CNN，训练
 
短短二十多行代码，构建一个三个卷积层的CNN，直接读下面的代码吧，有注释，很容易读懂：
 
#导入各种用到的模块组件
from __future__ import absolute_import
from __future__ import print_function
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.layers.advanced_activations import PReLU
from keras.layers.convolutional import Convolution2D, MaxPooling2D
from keras.optimizers import SGD, Adadelta, Adagrad
from keras.utils import np_utils, generic_utils
from six.moves import range
from data import load_data

#加载数据
data, label = load_data()
print(data.shape[0], ' samples')

#label为0~9共10个类别，keras要求格式为binary class matrices,转化一下，直接调用keras提供的这个函数
label = np_utils.to_categorical(label, 10)

###############
#开始建立CNN模型
###############

#生成一个model
model = Sequential()

#第一个卷积层，4个卷积核，每个卷积核大小5*5。1表示输入的图片的通道,灰度图为1通道。
#border_mode可以是valid或者full，具体看这里说明：http://deeplearning.net/software/theano/library/tensor/nnet/conv.html#theano.tensor.nnet.conv.conv2d
#激活函数用tanh
#你还可以在model.add(Activation('tanh'))后加上dropout的技巧: model.add(Dropout(0.5))
model.add(Convolution2D(4, 1, 5, 5, border_mode='valid')) 
model.add(Activation('tanh'))

#第二个卷积层，8个卷积核，每个卷积核大小3*3。4表示输入的特征图个数，等于上一层的卷积核个数
#激活函数用tanh
#采用maxpooling，poolsize为(2,2)
model.add(Convolution2D(8,4, 3, 3, border_mode='valid'))
model.add(Activation('tanh'))
model.add(MaxPooling2D(poolsize=(2, 2)))

#第三个卷积层，16个卷积核，每个卷积核大小3*3
#激活函数用tanh
#采用maxpooling，poolsize为(2,2)
model.add(Convolution2D(16, 8, 3, 3, border_mode='valid')) 
model.add(Activation('tanh'))
model.add(MaxPooling2D(poolsize=(2, 2)))

#全连接层，先将前一层输出的二维特征图flatten为一维的。
#Dense就是隐藏层。16就是上一层输出的特征图个数。4是根据每个卷积层计算出来的：(28-5+1)得到24,(24-3+1)/2得到11，(11-3+1)/2得到4
#全连接有128个神经元节点,初始化方式为normal
model.add(Flatten())
model.add(Dense(16*4*4, 128, init='normal'))
model.add(Activation('tanh'))

#Softmax分类，输出是10类别
model.add(Dense(128, 10, init='normal'))
model.add(Activation('softmax'))

#############
#开始训练模型
##############
#使用SGD + momentum
#model.compile里的参数loss就是损失函数(目标函数)
sgd = SGD(l2=0.0,lr=0.05, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd,class_mode="categorical")

#调用fit方法，就是一个训练过程. 训练的epoch数设为10，batch_size为100．
#数据经过随机打乱shuffle=True。verbose=1，训练过程中输出的信息，0、1、2三种方式都可以，无关紧要。show_accuracy=True，训练时每一个epoch都输出accuracy。
#validation_split=0.2，将20%的数据作为验证集。
model.fit(data, label, batch_size=100,nb_epoch=10,shuffle=True,verbose=1,show_accuracy=True,validation_split=0.2)
 
代码使用与结果
 
结果如下所示，在Epoch 9达到了0.98的训练集识别率和0.97的验证集识别率：
 

Embedding层
 
keras.layers.embeddings.Embedding(input_dim, output_dim, embeddings_initializer='uniform', embeddings_regularizer=None, activity_regularizer=None, embeddings_constraint=None, mask_zero=False, input_length=None)
 
嵌入层将正整数（下标）转换为具有固定大小的向量，如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]]
 
Embedding层只能作为模型的第一层
 
参数
 
input_dim：大或等于0的整数，字典长度，即输入数据最大下标+1
 output_dim：大于0的整数，代表全连接嵌入的维度
 embeddings_initializer: 嵌入矩阵的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
 embeddings_regularizer: 嵌入矩阵的正则项，为Regularizer对象
 embeddings_constraint: 嵌入矩阵的约束项，为Constraints对象
 mask_zero：布尔值，确定是否将输入中的‘0’看作是应该被忽略的‘填充’（padding）值，该参数在使用递归层处理变长输入时有用。设置为True的话，模型中后续的层必须都支持masking，否则会抛出异常。如果该值为True，则下标0在字典中不可用，input_dim应设置为|vocabulary| + 2。
 input_length：当输入序列的长度固定时，该值为其长度。如果要在该层后接Flatten层，然后接Dense层，则必须指定该参数，否则Dense层的输出维度无法自动推断。
 输入shape
 形如（samples，sequence_length）的2D张量
 输出shape
 形如(samples, sequence_length, output_dim)的3D张量
 
较为费劲的就是第一句话：
 嵌入层将正整数（下标）转换为具有固定大小的向量，如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]]
 
哪到底咋转换啊 ？
 这涉及到词向量，具体看可以参考这篇文章：Word2vec 之 Skip-Gram 模型，下面只进行简单描述
 
 
上图的流程是把文章的单词使用词向量来表示。
 (1)提取文章所有的单词，按其出现的次数降序(这里只取前50000个)，比如单词‘network’出现次数最多，编号ID为0，依次类推。
 
(2)每个编号ID都可以使用50000维的二进制(one-hot)表示
 
(3)最后会生产一个矩阵M，行大小为词的数目50,000，列大小为词向量的维度(通常取128或300)，比如矩阵的第一行就是编号ID=0，即单词‘network’对应的词向量。
 
那这个矩阵M怎么获得呢？在Skip-Gram 模型中，通常会随机初始化它，然后使用神经网络来训练这个权重矩阵
 
 
那我们的输入数据和标签是什么？如下图所示，输入数据为中间的哪个蓝色的词对应的one-hot编码，标签就是它附近词的one-hot编码 (此处windown_size=2,左右各取2个)
 
 
就上述Word2Vec的例子而言，它的单词表大小为50,000，词向量的维度为300，所以Embedding的参数 input_dim=50,000，output_dim=300
 
回到最初的问题：嵌入层将正整数（下标）转换为具有固定大小的向量，如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]]
 
举个栗子：假如单词表的大小为50,000，词向量维度为2，经单词频数统计后，tom对应的id=4，而jerry对应的id=20，经上述的转换后，我们会得到一个$M_{50,000\times 2}$的矩阵，而tom对应的是该矩阵的第4行，取出该行的数据就是[0.25,0.1]
 
如果输入数据不需要词的语义特征语义，简单使用Embedding层就可以得到一个对应的词向量矩阵，但如果需要语义特征，我们大可把训练好的词向量权重直接扔到Embedding层中即可，具体看参考keras提供的栗子:在Keras模型中使用预训练的词向量

DL框架之Keras：深度学习框架Keras框架的简介、安装(Python库)、相关概念、Keras模型使用、使用方法之详细攻略
 
 
 
 
 
 
 
 
 
目录
 
Keras的简介
 
1、Keras的特点
 
2、Keras四大特性
 
3、Keras的用户体验
 
4、如果你有如下需求，请选择Keras
 
5、Keras支持多后端和多平台
 
Keras的安装
 
Keras的使用方法
 
1、The Sequential Model 序列模型
 
2、The functional API 函数式API
 
3、Model subclassing 模型子类化
 
其他概念
 
1、shape
 
2、回调
 
3、保存和恢复
 
4、动态图机制：Eager Execution
 
Keras的中的模型使用
 
1、查找使用方法
 
2、Keras的 6 种预训练模型 
 
3、Keras深度学习框架的注意事项(自动下载存放路径等)、使用方法之详细攻略
 

 
 
 
 
 
 
相关文章
DL框架之Keras：Python库之Keras库的简介、安装、使用方法详细攻略
keras-yolo3：python库之keras-yolo3的简介、安装、使用方法详细攻略
 
Keras的简介
 
 
     Keras是TensorFlow官方的高层API。Keras是一个高层神经网络API，并对TensorFlow等有较好的优化。，Keras由纯Python编写而成并基Tensorflow、Theano以及CNTK后端，也就是Keras基于什么东西来做运算。Keras 为支持快速实验而生，能够把你的idea迅速转换为结果。
 
1、Keras的特点
 
tensorflow.keras(tf.keras) module
Part of core TensorFlow since v1.4
Full Keras API
针对TF更好的优化
与TF特别功能更好的整合，Estimator API、Eager execution
2、Keras四大特性
 
1、用户友好：Keras是为人类而非机器设计的API。用户的使用体验始终是我们考虑的首要和中心内容。Keras遵循减少认知困难的最佳实践：Keras提供一致而简洁的API， 能够极大减少一般应用下用户的工作量，同时，Keras提供清晰和具有实践意义的bug反馈。 
2、模块性：模型可理解为一个层的序列或数据的运算图，完全可配置的模块可以用最少的代价自由组合在一起。具体而言，网络层、损失函数、优化器、初始化策略、激活函数、正则化方法都是独立的模块，你可以使用它们来构建自己的模型。 
3、易扩展性：添加新模块超级容易，只需要仿照现有的模块编写新的类或函数即可。创建新模块的便利性使得Keras更适合于先进的研究工作。 
4、与Python协作：Keras没有单独的模型配置文件类型（作为对比，caffe有），模型由python代码描述，使其更紧凑和更易debug，并提供了扩展的便利性。
 
 
3、Keras的用户体验
 
(1)、Keras是专为人而非机器设计的API
 
它把用户体验放在首要和中心位置。
Keras遵循减少认知困难的最佳实践：它提供一致且简单的API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
(2)、Keras易于学习且易于使用
 
作为Keras用户，可以更高效地工作，让你比竞争对手更快地尝试更多创意和帮助你赢得机器学习竞赛。
(3)、这种易用性不是以降低灵活性为代价
 
Keras与低级深度学习语言（特别是TensorFlow）集成，能够实现可以用基本语言构建的任何东西。特别是，作为tf.keras，Keras API与TensorFlow工作流程无缝集成。
 
 
4、如果你有如下需求，请选择Keras
 
简易和快速的原型设计（keras具有高度模块化，极简，和可扩充特性）
支持CNN和RNN，或二者的结合
无缝CPU和GPU切换。
 
 
5、Keras支持多后端和多平台
 
(1)、支持多种语言：Develop in Python, R   On Unix, Windows, OSX
 (2)、支持多个后端：Keras与TensorFlow&Theano
 
 
     TensorFlow和theano以及Keras都是深度学习框架，TensorFlow和theano比较灵活，也比较难学，它们其实就是一个微分器  Keras其实就是TensorFlow和Keras的接口（Keras作为前端，TensorFlow或theano作为后端），它也很灵活，且比较容易学。可以把keras看作为tensorflow封装后的一个API。Keras 是一个用于快速构建深度学习原型的高级库。我们在实践中发现，它是数据科学家应用深度学习的好帮手。Keras 目前支持两种后端框架：TensorFlow 与 Theano，而且 Keras 再过不久就会成为 TensorFlow 的默认 API。
 
Run the same code with…
 
-TensorFlow
-CNTK
-Theano
-MXNet
-PlaidML
(3)、支持多运算平台：CPU, NVIDIA GPU, AMD GPU, TPU
 
 
 
Keras: 基于 Python 的深度学习库
Keras中文文档
tensorflow.org/guide/keras
 
 
 
 
 
 
 
Keras的安装
 
pip install Keras
 python -m pip install keras
 
 
 
哈哈，大功告成！继续学习去啦！
 pip install --upgrade Kera
 
 
190827更新到2.2.5
 
 
190827再次还原到2.2.4
 
 
相关文章
Py之keras-resnet：keras-resnet的简介、安装、使用方法之详细攻略
 
 
 
 
 
Keras的使用方法
 
0、三种API方式：The Sequential Model （序列模型）、The functional API （函数式API）、Model subclassing（模型子类化）
 
from keras.models import Model
from keras.callbacks import ModelCheckpoint
from keras.layers import Conv2D, MaxPool2D, Flatten, Dropout, Dense, Input
from keras.optimizers import Adam
from keras.backend.tensorflow_backend import set_session
from keras.utils.vis_utils import model_to_dot


import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
 
np.random.seed(5)
config = tf.ConfigProto()
config.gpu_options.allow_growth=True
set_session(tf.Session(config=config))
 
 
 
1、The Sequential Model 序列模型
 
-非常简单
 -仅适用于单输入，单输出，顺序的层堆叠
 -适用于70％以上的用例
 
Sequential 序列模型如所示
可以简单地使用.add() 来堆叠模型
在完成了模型的构建后, 可以使用.compile() 来配置学习过程：
如果需要，还可以进一步地配置优化器：
批量地在训练数据上进行迭代：
# x_train 和y_train 是Numpy 数组--就像在Scikit-Learn API 中一样

 或者，可以手动地将批次的数据提供给模型：
一行代码就能评估模型性能：
对新的数据生成预测

1、快速开始序贯（Sequential）模型  
 序贯模型是多个网络层的线性堆叠，也就是“一条路走到黑”。  
 (1)、可以通过向Sequential模型传递一个layer的list来构造该模型：  
 from keras.models import Sequential 
 from keras.layers import Dense, Activation  
 model = Sequential([ Dense(32, units=784), Activation('relu'), Dense(10), Activation('softmax'), ]) 
 (2)、也可以通过.add()方法一个个的将layer加入模型中：  
 model = Sequential() model.add(Dense(32, input_shape=(784,))) 
 model.add(Activation('relu')) 
 
#引入Sequential，Dense，Activation
from keras.models import Sequential
from keras.layers import Dense, Activation
#向layer添加list方式
model = Sequential([Dense(32, input_dim=784),Activation('relu'),Dense(10),Activation('softmax'),])

#通过.add()方式
model = Sequential()
model.add(Dense(32, input_dim=784))
model.add(Activation('relu'))
 
 
 
 
 
 
 
2、The functional API 函数式API
 
-象玩乐高积木
 -多输入，多输出，任意静态图拓扑
 -适用于95％的用例
 
Keras 函数式API 是定义复杂模型（如多输出模型、有向无环图，或具有共享层的模型）的方法。
 
例一：全连接网络

 
 
3、Model subclassing 模型子类化
 
-最大的灵活性
 -更大的可能错误面
 
(1)、通过对tf.keras.Model 进行子类化并定义你自己的前向传播来构建完全可自定义的模型。在__init__ 方法中创建层并将它们设置为类实例的属性。在call 方法中定义前向传播。
 (2)、在启用Eager Execution 时，模型子类化特别有用，因为可以命令式地编写前向传播。
 (3)、以下示例展示了使用自定义前向传播进行子类化的tf.keras.Model
 
class MyModel(tf.keras.Model):
    def __init__(self, num_classes=10):
        super(MyModel, self).__init__(name='my_model')
        self.num_classes = num_classes  
        # Define your layers here.
        self.dense_1 = layers.Dense(32, activation='relu')
        self.dense_2 = layers.Dense(num_classes, activation='sigmoid')
        
    def call(self, inputs): 
        # Define your forward pass here,
        # using layers you previously defined (in `__init__`).
        x = self.dense_1(inputs)
        return self.dense_2(x)
    def compute_output_shape(self, input_shape):
        # You need to override this function if you want to use the subclassed model
        # as part of a functional-style model.# Otherwise, this method is optional.
        shape = tf.TensorShape(input_shape).as_list()
        shape[-1] = self.num_classes
        return tf.TensorShape(shape)

实例化新模型类
model = MyModel(num_classes=10) # The compile step specifies the training configuration.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])
# Trains for 5 epochs.
model.fit(data, labels, batch_size=32, epochs=5)

 
 
 
其他概念
 
1、shape
 
(1)、指定输入数据的shape  
 
模型需要知道输入数据的shape，因此，Sequential的第一层需要接受一个关于输入数据shape的参数，后面的各个层则可以自动的推导出中间数据的shape，因此不需要为每个层都指定这个参数。
 
(2)、关于张量shape  更多详细内容参考这个博客https://blog.csdn.net/u013378306/article/details/56281549
    在Keras和Tensorflow中,数据是以张量的形式表示的，张量的形状就是shape。TensorFlow用张量这种数据结构来表示所有的数据.你可以把一个张量想象成一个n维的数组或列表.一个张量有一个静态类型和动态类型的维数.张量可以在图中的节点之间流通即Flow。
 
   你可以认为一个二阶张量就是我们平常所说的矩阵，一阶张量可以认为是一个向量.对于一个二阶张量你可以用语句t[i, j]来访问其中的任何元素.而对于三阶张量你可以用't[i, j, k]'来访问其中的任何元素.
 
(1)input_shape就是指输入张量的shape。例如 input_dim=784，说明输入是一个784维的向量，这相当于一个一阶的张量，它的shape就是(784,)
 
 
2、回调
 
1、回调是传递给模型的对象，用于在训练期间自定义该模型并扩展其行为。你可以编写自定义回调，也可以使用包含以下方法的内置tf.keras.callbacks：
 
tf.keras.callbacks.ModelCheckpoint        '定期保存模型的检查点。'
tf.keras.callbacks.LearningRateScheduler  '动态更改学习速率。'
tf.keras.callbacks.EarlyStopping          '在验证效果不再改进时中断训练。'
tf.keras.callbacks.TensorBoard            '使用TensorBoard 监控模型的行为。'
 
2、要使用tf.keras.callbacks.Callback，请将其传递给模型的fit 方法：
 
callbacks = [
    # Interrupt training if `val_loss` stops improving for over 2 epochs
    tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
    # Write TensorBoard logs to `./logs` directory
    tf.keras.callbacks.TensorBoard(log_dir='./logs')
    ]
model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks,
          validation_data=(val_data, val_labels))
 
3、保存和恢复
 
（1）仅限权重：使用tf.keras.Model.save_weights 保存并加载模型的权重
 
model = tf.keras.Sequential([layers.Dense(64, activation='relu'),
                             layers.Dense(10, activation='softmax')])
model.compile(optimizer=tf.train.AdamOptimizer(0.001),
              loss='categorical_crossentropy',metrics=['accuracy'])

'默认情况下，会以TensorFlow 检查点文件格式保存模型的权重'
# Save weights to a TensorFlow Checkpoint file
model.save_weights('./weights/my_model')
# Restore the model's state,# this requires a model with the same architecture.
model.load_weights('./weights/my_model')

'权重也可以另存为KerasHDF5 格式（Keras多后端实现的默认格式）'
# Save weights to a HDF5 
filemodel.save_weights('my_model.h5', save_format='h5')
# Restore the model's statemodel.
load_weights('my_model.h5')
 
(2)、仅限配置：可以保存模型的配置，此操作会对模型架构（不含任何权重）进行序列化。即使没有定义原始模型的代码，保存的配置也可以重新创建并初始化相同的模型。Keras 支持JSON 和YAML 序列化格式：
 
# Serialize a model to JSON format
json_string = model.to_json()
json_string
import json 
import pprint
pprint.pprint(json.loads(json_string))

'从json重新创建模型'
fresh_model = tf.keras.models.model_from_json(json_string)
 
（3）整个模型：整个模型可以保存到一个文件中，其中包含权重值、模型配置乃至优化器配置。这样，您就可以对模型设置检查点并稍后从完全相同的状态继续训练，而无需访问原始代码。
 
# Create a trivial model
model = tf.keras.Sequential([layers.Dense(10, activation='softmax', input_shape=(32,)),
                             layers.Dense(10, activation='softmax')])
model.compile(optimizer='rmsprop',loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(data, labels, batch_size=32, epochs=5)
# Save entire model to a HDF5 file
model.save('my_model.h5')

# Recreate the exact same model, including weights and optimizer.
model = tf.keras.models.load_model('my_model.h5')
 
 
 
4、动态图机制：Eager Execution
 
      不同于TensorFlow的静态机制。
 
Eager Execution 是一种命令式编程环境，可立即评估操作。此环境对于Keras 并不是必需的，但是受tf.keras 的支持，并且可用于检查程序和调试。
所有tf.keras 模型构建API 都与Eager Execution 兼容。虽然可以使用Sequential 和函数式API，但Eager Execution 对模型子类化和构建自定义层特别有用。
与通过组合现有层来创建模型的API 不同，函数式API 要求你编写前向传播代码。
 
 
 
 
 
 
 
 
Keras的中的模型使用
 
1、查找使用方法
 
from keras.models import Sequential
 model = Sequential()
 help(model.compile)
 
 
(1)、model.compile()函数，用来配置训练模型参数，可以指定你设想的随机梯度下降中的网络的损失函数、优化方式等参数(2)、model.summary()函数，Prints a string summary of the network.
 (3)、model.fit_generator()函数，Fits the model on data generated batch-by-batch by a Python generator.The generator is run in parallel to the model, for efficiency.For instance, this allows you to do real-time data augmentation on images on CPU in parallel to training your model on GPU.
 (4)、K.placeholder()    #用于得到传递进来的真实的训练样本
 
 
 
2、Keras的 6 种预训练模型 
 
      目前可知，Keras 已经将这 6 种预训练模型集成到了库中： VGG16、VGG19、ResNet50、Inception v3、Xception、MobileNet。VGG 网络以及从 2012 年以来的 AlexNet 都遵循现在的基本卷积网络的原型布局：一系列卷积层、最大池化层和激活层，最后还有一些全连接的分类层。MobileNet 本质上是为移动应用优化后的 Xception 架构的流线型（streamline）版本。
 
 
 
3、Keras深度学习框架的注意事项(自动下载存放路径等)、使用方法之详细攻略
 
DL之Keras： Keras深度学习框架的注意事项(自动下载存放路径等)、使用方法之详细攻略