keras函数式模型和序贯模型的使用

Keras适用的Python版本是：Python 2.7-3.6

Keras的核心数据结构是“模型”，模型是一种组织网络层的方式。

函数式模型和序贯模型

在 Keras 中有两类主要的模型：Sequential 顺序模型 和 使用函数式 API 的 Model 类模型。
序贯模型是多个网络层的线性堆叠，是函数式模型的简略版，为最简单的线性、从头到尾的结构顺序，不发生分叉。

函数式模型比序贯模型要复杂，更灵活，可以同时/分阶段输入变量，分阶段输出想要的模型。Keras函数式模型接口是用户定义多输出模型、非循环有向模型或具有共享层的模型等复杂模型的途径。一句话，只要你的模型不是类似VGG一样一条路走到黑的模型，或者你的模型需要多于一个的输出，那么你总应该选择函数式模型。函数式模型是最广泛的一类模型，序贯(Sequential)模型只是它的一种特殊情况。

model = Model(inputs=a, outputs=b)

序贯模型实例

序贯模型是多个网络层的线性堆叠，也就是“一条路走到黑”。可以通过向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'),
])

也可以通过.add()方法一个个的将layer加入模型中：

model = Sequential()
model.add(Dense(32, input_shape=(784,)))
model.add(Activation('relu'))

Sequential模型方法：

add、pop、compile、fit、evaluate、predict、train_on_batch、predict_on_batch

fit_generator、evaluate_on_batch、predict_on_batch

例：

4层cnn

dr = 0.5 # dropout rate (%)
model = models.Sequential()
model.add(Reshape(in_shp + [1], input_shape=in_shp))#在网络第一步做了变换,in_shp---in_shp+[1],也可以对输入数据reshape
model.add(Conv2D(160, (5, 5), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
model.add(Conv2D(160, (5, 5), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
model.add(Dropout(0.5))

model.add(Conv2D(64, (3, 3), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
model.add(Conv2D(64, (3, 3), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
model.add(Dropout(0.5))

model.add(Flatten())
model.add(Dense(128, kernel_initializer="glorot_normal", activation="relu", name="dense1"))
model.add(Dropout(dr))
# model.add(Dense(1, activation='sigmoid'))

model.add(Dense(len(classes), kernel_initializer="he_normal", name="dense2"))
model.add(Activation('softmax'))
model.add(Reshape([len(classes)]))


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

函数式模型实例

from keras.models import Model
from keras.layers import Input, Dense
 
a = Input(shape=(32,))
b = Dense(32)(a)
model = Model(inputs=a, outputs=b)

我们的模型以a为输入，以b为输出，同样我们可以构造拥有多输入和多输出的模型

model = Model(inputs=[a1, a2], outputs=[b1, b3, b3])

（2）模型属性：

model.layers：组成模型图的各个层
model.inputs：模型的输入张量列表
model.outputs：模型的输出张量列表
（3）函数式模型方法

compile、fit、evaluate、predict、train_on_batch、test_on_batch、predict_on_batch、

fit_generator、evaluate_on_batch、predict_on_batch

 

双通道cnn

######tcnn model####
model = models.Sequential()
model.add(Reshape(in_shp + [1], input_shape=in_shp))
input=Input(shape=in_shp + [1])

####up channel##
# with tf.variable_scope("y_pred",reuse=None):
cnnup=Conv2D(160, (5, 5), activation='relu')(input)
# BatchNormalization(epsilon=1e-6, weights=None)
cnnup=Conv2D(160, (5, 5), activation='relu')(cnnup)
cnnup = Dropout(dr)(cnnup)
# cnnup = BatchNormalization(epsilon=1e-6, weights=None)(cnnup)
cnnup=Conv2D(64, (3, 3), activation='relu')(cnnup)
cnnup = Dropout(dr)(cnnup)
# cnnup = BatchNormalization(epsilon=1e-6, weights=None)(cnnup)
cnnup=Conv2D(64, (3, 3), activation='relu')(cnnup)
# cnnup = BatchNormalization(epsilon=1e-6, weights=None)(cnnup)

print cnnup

####down channel##
cnndown=Conv2D(160, (7, 7), activation='relu')(input)
cnndown = Dropout(dr)(cnndown)
# cnndown = BatchNormalization(epsilon=1e-6, weights=None)(cnndown)
cnndown=Conv2D(64, (5, 5), activation='relu')(cnndown)
cnndown = Dropout(dr)(cnndown)
# cnndown = BatchNormalization(epsilon=1e-6, weights=None)(cnndown)
cnndown=Conv2D(32, (3, 3), activation='relu')(cnndown)
# cnndown = BatchNormalization(epsilon=1e-6, weights=None)(cnndown)

print cnndown

cnnout=concatenate([cnndown,cnnup])
fl=Flatten()(cnnout)
output=Dense(128,kernel_initializer="glorot_uniform", activation='relu',name="dense1")(fl)
output = Dropout(dr, name='dense_drp')(output)
output=Dense(len(classes),kernel_initializer="glorot_normal", activation='softmax',name="dense2")(output)

model1=Model(input,output)
model.add(model1)

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

混合模型实例

双通道cnn

dr = 0.5 # dropout rate (%)
######tcnn model###
input=Input(shape=in_shp)

####up channel##############################
up_model = Sequential()
up_model.add(Reshape(in_shp + [1], input_shape=in_shp))#网络第一层reshape
up_model.add(Conv2D(160, (5, 5), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
up_model.add(Conv2D(160, (5, 5), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
up_model.add(Dropout(0.5))

up_model.add(Conv2D(64, (3, 3), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
up_model.add(Conv2D(64, (3, 3), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
up_model.add(Dropout(0.5))
up_model.add(Flatten())
up_model.summary()
# plot_model(up_model, to_file='upmodel.png',show_shapes=True)

cnnup = up_model(input)

####down channel##################################
down_model = Sequential()
down_model.add(Reshape(in_shp + [1], input_shape=in_shp))
down_model.add(Conv2D(128, (7, 7), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
# down_model.add(Conv2D(160, (5, 5), activation='relu'))
# down_model.add(BatchNormalization(epsilon=1e-6, weights=None))
down_model.add(Dropout(0.5))

down_model.add(Conv2D(64, (5, 5), activation='relu'))
BatchNormalization(epsilon=1e-6, weights=None)
down_model.add(Dropout(0.5))

down_model.add(Flatten())
cnndown = down_model(input)
print cnndown
cnnout=concatenate([cnndown,cnnup])
print cnnout

output=Dense(128,kernel_initializer="glorot_uniform", activation='relu',name="dense1")(cnnout)
output = Dropout(dr, name='dense_drp')(output)
output=Dense(len(classes),kernel_initializer="glorot_normal", activation='softmax',name="dense2")(output)

model=Model(input,output)

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

官方实例

from keras.layers import Conv2D, MaxPooling2D, Flatten
from keras.layers import Input, LSTM, Embedding, Dense
from keras.models import Model, Sequential

# 首先，让我们用 Sequential 来定义一个视觉模型。
# 这个模型会把一张图像编码为向量。
vision_model = Sequential()
vision_model.add(Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(224, 224, 3)))
vision_model.add(Conv2D(64, (3, 3), activation='relu'))
vision_model.add(MaxPooling2D((2, 2)))
vision_model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))
vision_model.add(Conv2D(128, (3, 3), activation='relu'))
vision_model.add(MaxPooling2D((2, 2)))
vision_model.add(Conv2D(256, (3, 3), activation='relu', padding='same'))
vision_model.add(Conv2D(256, (3, 3), activation='relu'))
vision_model.add(Conv2D(256, (3, 3), activation='relu'))
vision_model.add(MaxPooling2D((2, 2)))
vision_model.add(Flatten())

# 现在让我们用视觉模型来得到一个输出张量：
image_input = Input(shape=(224, 224, 3))
encoded_image = vision_model(image_input)

# 接下来，定义一个语言模型来将问题编码成一个向量。
# 每个问题最长 100 个词，词的索引从 1 到 9999.
question_input = Input(shape=(100,), dtype='int32')
embedded_question = Embedding(input_dim=10000, output_dim=256, input_length=100)(question_input)
encoded_question = LSTM(256)(embedded_question)

# 连接问题向量和图像向量：
merged = keras.layers.concatenate([encoded_question, encoded_image])

# 然后在上面训练一个 1000 词的逻辑回归模型：
output = Dense(1000, activation='softmax')(merged)

# 最终模型：
vqa_model = Model(inputs=[image_input, question_input], outputs=output)

三、层

1、常用层Core

（1）全连接层

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)

（2）激活层

keras.layers.core.Activation(activation)

（3）Dropout层

keras.layers.core.Dropout(rate, noise_shape=None, seed=None)

（4）Flatten层

keras.layers.core.Flatten()

（5）Reshape层

keras.layers.core.Reshape(target_shape)

（6）Permute层：将维度交换

keras.layers.core.Permute(dims)

（7）RepeatVector层：将输入重复N次

keras.layers.core.RepeatVector(n)

（8）Lambda层：对上一层输出进行任何表达式

keras.layers.core.Lambda(function, output_shape=None, mask=None, arguments=None)

（9）ActivityRegularizer：更新损失函数

keras.layers.core.ActivityRegularization(l1=0.0, l2=0.0)

（10）Masking层：信号屏蔽

keras.layers.core.Masking(mask_value=0.0)

 

2、卷积层

keras.layers.convolutional.Conv1D(filters, kernel_size, strides=1, padding='valid', dilation_rate=1, 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)

 

3、池化层

keras.layers.pooling.MaxPooling1D(pool_size=2, strides=None, padding='valid')

keras.layers.pooling.GlobalAveragePooling1D()

 

4、局部连接层

keras.layers.local.LocallyConnected1D(filters, kernel_size, strides=1, padding='valid', data_format=None, 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)

 

5、循环层

keras.layers.recurrent.Recurrent(return_sequences=False, go_backwards=False, stateful=False, unroll=False, implementation=0)

 

6、嵌入层

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)

 

7、融合层

 

8、规范层

keras.layers.normalization.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None)

 

9、噪声层

keras.layers.noise.GaussianNoise(stddev)

 

四、数据预处理

1、序列预处理

（1）填充序列

keras.preprocessing.sequence.pad_sequences(sequences, maxlen=None, dtype='int32', padding='pre', truncating='pre', value=0.)

（2）跳字

keras.preprocessing.sequence.skipgrams(sequence, vocabulary_size, window_size=4, negative_samples=1., shuffle=True, categorical=False, sampling_table=None)

（3）获取采样表

keras.preprocessing.sequence.make_sampling_table(size, sampling_factor=1e-5)

 

2、文本预处理

（1）句子分割

keras.preprocessing.text.text_to_word_sequence(text, filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n', lower=True, split=" ")

（2）one-hot编码

keras.preprocessing.text.one_hot(text, n, filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n', lower=True, split=" ")

（3）特征哈希

keras.preprocessing.text.hashing_trick(text, n, hash_function=None, filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n', lower=True, split=' ')

（4）分词器

keras.preprocessing.text.Tokenizer(num_words=None, filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n', lower=True, split=" ", char_level=False)

 

3、图片预处理：图片生成器

 

 

五、图片

 

六、网络配置

1、目标函数：损失函数

model.compile(loss='mean_squared_error', optimizer='sgd')

可用的目标函数：

 

mean_squared_error或mse

mean_absolute_error或mae

mean_absolute_percentage_error或mape

mean_squared_logarithmic_error或msle

squared_hinge

hinge

categorical_hinge

binary_crossentropy（亦称作对数损失，logloss）

logcosh

categorical_crossentropy：亦称作多类的对数损失，注意使用该目标函数时，需要将标签转化为形如(nb_samples, nb_classes)的二值序列

sparse_categorical_crossentrop：如上，但接受稀疏标签。注意，使用该函数时仍然需要你的标签与输出值的维度相同，你可能需要在标签数据上增加一个维度：np.expand_dims(y,-1)

kullback_leibler_divergence:从预测值概率分布Q到真值概率分布P的信息增益,用以度量两个分布的差异.

poisson：即(predictions - targets * log(predictions))的均值

cosine_proximity：即预测值与真实标签的余弦距离平均值的相反数

 

2、优化器optimizer

model.compile(loss='mean_squared_error', optimizer='sgd')

可用的优化器有：SGD、RMSprop、Adagrad、Adadelta、Adam、Adamax、NAdam、TFOptimizer

 

3、激活函数Acitivation

激活函数可以通过设置单独的激活层实现，也可以在构造层对象时通过传递activation参数实现。

 

from keras.layers import Activation, Dense
 
model.add(Dense(64))
model.add(Activation('tanh'))
等价于

model.add(Dense(64, activation='tanh'))
（1）预定义激活函数

 

softmax：对输入数据的最后一维进行softmax，输入数据应形如(nb_samples, nb_timesteps, nb_dims)或(nb_samples,nb_dims)

elu

selu: 可伸缩的指数线性单元（Scaled Exponential Linear Unit），参考Self-Normalizing Neural Networks

softplus

softsign

relu

tanh

sigmoid

hard_sigmoid

linear

（2）高级激活函数

含有可学习参数的激活函数，可通过高级激活函数实现，如PReLU，LeakyReLU等

 

4、性能评估

性能评估函数类似与目标函数, 只不过该性能的评估结果讲不会用于训练.

model.compile(loss='mean_squared_error', optimizer='sgd', metrics=['mae', 'acc'])

可用的预定义张量：

 

binary_accuracy: 对二分类问题,计算在所有预测值上的平均正确率
categorical_accuracy:对多分类问题,计算再所有预测值上的平均正确率
sparse_categorical_accuracy:与categorical_accuracy相同,在对稀疏的目标值预测时有用
top_k_categorical_accracy: 计算top-k正确率,当预测值的前k个值中存在目标类别即认为预测正确
sparse_top_k_categorical_accuracy：与top_k_categorical_accracy作用相同，但适用于稀疏情况
 

5、初始化方法

 

不同的层可能使用不同的关键字来传递初始化方法，一般来说指定初始化方法的关键字是kernel_initializer 和 bias_initializer，例如：

model.add(Dense(64,
                kernel_initializer='random_uniform',
                bias_initializer='zeros'))
预定义初始化方法：

Zeros、Ones、Constant、RandomNormal、RandomUniform、TruncatedNormal、VarianceScaling

Orthogonal、Identity、lecun_normal、glorot_normal、glorot_uniform、he_normal、he_uniform

 

6、正则项

 

正则项在优化过程中层的参数或层的激活值添加惩罚项，这些惩罚项将与损失函数一起作为网络的最终优化目标

惩罚项基于层进行惩罚，目前惩罚项的接口与层有关，但Dense, Conv1D, Conv2D, Conv3D具有共同的接口。

这些层有三个关键字参数以施加正则项：

kernel_regularizer：施加在权重上的正则项，为keras.regularizer.Regularizer对象

bias_regularizer：施加在偏置向量上的正则项，为keras.regularizer.Regularizer对象

activity_regularizer：施加在输出上的正则项，为keras.regularizer.Regularizer对象

可用的正则项：

keras.regularizers.l1(0.)

keras.regularizers.l2(0.)

keras.regularizers.l1_l2(0.)

 

7、约束项

 

Dense, Conv1D, Conv2D, Conv3D这些层通过一下关键字施加约束项：

kernel_constraint：对主权重矩阵进行约束

bias_constraint：对偏置向量进行约束

from keras.constraints import maxnormmodel.add(Dense(64, kernel_constraint=max_norm(2.)))

 

 

 

8、回调函数keras.callbacks.*

回调函数是一组在训练的特定阶段被调用的函数集，你可以使用回调函数来观察训练过程中网络内部的状态和统计信息。

Callback、BaseLogger、ProgbarLogger、Histroy、ModelCheckPoint、EarlyStopping、RemoteMonitor

LearningRateScheduler、TensorBoard、ReduceLROnPlateau、CSVLogger、LambdaCallback

 

七、已有模型、数据库、可视化

1、已有模型

 

Kera的应用模块Application提供了带有预训练权重的Keras模型，这些模型可以用来进行预测、特征提取和finetune

模型的预训练权重将下载到~/.keras/models/并在载入模型时自动载入

Xception、VGG16、VGG19、ResNet50、InceptionV3、InceptionResNetV2、MobileNet

 

2、数据库

CIFAR10、CIFAR100、IMDB影评、路透社新闻主题分类、MNIST手写数字识别、Fashion-MNIST数据集

Boston房屋价格回归数据集

 

3、模型可视化

 

keras.utils.vis_utils模块提供了画出Keras模型的函数（利用graphviz）

该函数将画出模型结构图，并保存成图片：

from keras.utils import plot_model
plot_model(model, to_file='model.png')
 

八、工具

提供了一系列有用的utils工具

 

CustomObjectScope
 
HDF5Matrix
 
Sequence
 
to_categorical
 
normalize
convert_all_kernels_in_model
 

--------------------- 
https://blog.csdn.net/Adupanfei/article/details/84584547 

https://blog.csdn.net/weixin_41770169/article/details/80845972