keras构建神经网络_keras config

1、使用keras构建神经网络基本工作流程：
训练数据–创建模型–配置模型–训练模型–训练好的模型做预测、对模型效果进行评估。
(1)创建模型：
在 Keras 中有两类主要的模型：Sequential 顺序模型 和 使用函数式 API 的 Model 类模型。
这些模型有许多共同的方法和属性：
model.layers 是包含模型网络层的展平列表。
model.inputs 是模型输入张量的列表。
model.outputs 是模型输出张量的列表。
model.summary() 打印出模型概述信息。 它是 utils.print_summary 的简捷调用。
model.get_config() 返回包含模型配置信息的字典。
通过以下代码，就可以根据这些配置信息重新实例化模型：

config = model.get_config()
model = Model.from_config(config)
或者，对于 Sequential:
model = Sequential.from_config(config)
1
2
3
4

具体见keras中文文档：https://keras.io/zh/models/about-keras-models/

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

#1、定义模型 通过序贯模型
model=Sequential()#定义了一个序贯模型
#2、叠加网络层
#序贯模型的第一层网络需要定义网络的输入形状或尺寸input_shape 或input_dim  数据本身的维度即可  不用包含输入数据的批量大小batch
#input_shape要求是一个元组类型的数据，input_dim要求是 一个整数类型的数据  input_shape=(784,)等价于 input_dim=784
model.add(Dense(32,input_shape=(784,)))#通过add可以把需要的网络层按照顺序一层层的叠加到模型上
model.add(Activation('relu'))
model.add(Dense(10))#Dense和Activation都是keras的网络层
model.add(Activation('softmax'))
#注：Dense全连接层 /稠密层 要求制定神经元的个数 Dense(10)表示这一层有10个神经元输出数据的shape也是10，
#如果是第一层输入层还需要制定输入数据的shape 否则则不需要指定
#Activation激活层 是对该层的输出施加激活函数 常用的激活函数包括 sigmoid relu tanh等
#Dropout 随机失活层 是防止模型过拟合的一种方式 Dropout层会指定一个更新参数（0-1之间的概率值） Dropout将在训练过程中每次更新参数时按一定概率随即断开输入神经元
#model.add(Dropout(0.5))
#也可以省略add 直接将网络层传递给序贯模型  如下
# model=Sequential([
#     Dense(32,units=784),
#     Activation('relu'),
#     Dense(10),
#     Activation('softmax')
# ])

#3、模型的编译  :对模型的学习过程进行配置
#优化器optizmizer  损失函数loss 评价指标列表metrics
model.compile(
    optizmizer='rmsprop',
    loss='mse',
    metrics=['mse','mae']
)
'''
（1）优化器optizmizer 随机梯度下降算法 等优化方法
优化算法决定了神经网络参数以何种方式在训练中被更新 这是网络训练前需要知道的 需要在模型训练前配置好
常见的优化器 SGD Adam RMSprop AdaGrad AdaDelta 
指定优化器 把优化器的名字直接作为参数传给 optizmizer 即可
有时 需要对优化算法的参数做一定的设置 比如Clipnorm Clipvalue对梯度进行裁剪 或者设置学习率lr以及学习率的衰减率 decay 
这时需要先设置优化器 在传递给optizmizer
sgd=optimiizers.SGD(lr=0.01,decay=0.0001)
model.compile(loss='mean_squared_error',optimizer=sgd)
(2)损失函数loss
回归问题常用损失函数 mse/mean_squared_error 均方误差  mae/mean_absolute_error 平均绝对误差 
分类问题 categorical_crossentropy 交叉熵
（3）性能评估metrics
和损失函数差不多 
'''
#4、训练模型
model.fit(X,Y,nb_epoch=150,batch_size=16)
'''
X,Y用于训练的输入数据
nb_epoch训练的轮数 当所有的训练数据都被训练了一次之后 被称为一个opoch
batch_size每一批次的数据量 训练数据不是一次性被输入网络进行训练的，而是分批进入 每一个批量batch都会对网络进行一次参数更新 
'''
#5、使用训练好的模型进行预测
y_pred=model.predict(x_pred,batch_size=32)
#6、模型的评估  在训练数据上进行
model.evaluate(X,Y)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

（2）配置训练模型

compile(optimizer, loss=None, metrics=None, loss_weights=None, 
sample_weight_mode=None, weighted_metrics=None, target_tensors=None)
1
2

参数说明：
① optimizer: 字符串（优化器名）或者优化器对象。
② loss: 字符串（目标函数名）或目标函数。 如果模型具有多个输出，则可以通过传递损失函数的字典或列表，在每个输出上使用不同的损失。模型将最小化的损失值将是所有单个损失的总和。
③ metrics: 在训练和测试期间的模型评估标准。通常你会使用 metrics = [‘accuracy’]。 要为多输出模型的不同输出指定不同的评估标准，还可以传递一个字典，如 metrics = {‘output_a’：‘accuracy’}。
④ loss_weights: 指定标量系数（Python浮点数）的可选列表或字典，用于加权不同模型输出的损失贡献。 模型将要最小化的损失值将是所有单个损失的加权和，由 loss_weights 系数加权。 如果是列表，则期望与模型的输出具有 1:1 映射。 如果是张量，则期望将输出名称（字符串）映射到标量系数。
⑤ sample_weight_mode: 如果你需要执行按时间步采样权重（2D 权重），请将其设置为 temporal。 默认为 None，为采样权重（1D）。如果模型有多个输出，则可以通过传递 mode 的字典或列表，以在每个输出上使用不同的 sample_weight_mode。
⑥ weighted_metrics: 在训练和测试期间，由 sample_weight 或 class_weight 评估和加权的度量标准列表。
⑦ target_tensors: 默认情况下，Keras 将为模型的目标创建一个占位符，在训练过程中将使用目标数据。相反，如果你想使用自己的目标张量（反过来说，Keras 在训练期间不会载入这些目标张量的外部 Numpy 数据），您可以通过 target_tensors 参数指定它们。它应该是单个张量（对于单输出 Sequential 模型）。
（3）训练模型

fit(x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, 
validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, 
sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None)
1
2
3

参数说明具体见 keras中文文档
（4）评估模型

evaluate(x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None)
1

参数说明：
① x: 训练数据的 Numpy 数组。 如果模型中的输入层被命名，你也可以传递一个字典，将输入层名称映射到 Numpy 数组。 如果从本地框架张量馈送（例如 TensorFlow 数据张量）数据，x 可以是 None（默认）。
② y: 目标（标签）数据的 Numpy 数组。 如果模型中的输出层被命名，你也可以传递一个字典，将输出层名称映射到 Numpy 数组。 如果从本地框架张量馈送（例如 TensorFlow 数据张量）数据，y 可以是 None（默认）。
③ batch_size: 整数或 None。每次提度更新的样本数。如果未指定，默认为 32.
④ verbose: 0, 1。日志显示模式。0 = 安静模式, 1 = 进度条。
⑤ sample_weight: 训练样本的可选 Numpy 权重数组，用于对损失函数进行加权（仅在训练期间）。 您可以传递与输入样本长度相同的平坦（1D）Numpy 数组（权重和样本之间的 1：1 映射），或者在时序数据的情况下，可以传递尺寸为 (samples, sequence_length) 的 2D 数组，以对每个样本的每个时间步施加不同的权重。在这种情况下，你应该确保在 compile() 中指定 sample_weight_mode=“temporal”。
⑥steps: 整数或 None。 声明评估结束之前的总步数（批次样本）。默认值 None。
（5）预测模型

predict(x, batch_size=None, verbose=0, steps=None)
1

x: 输入数据，Numpy 数组（或者如果模型有多个输入，则为 Numpy 数组列表）。
batch_size: 整数。如未指定，默认为 32。
verbose: 日志显示模式，0 或 1。
steps: 声明预测结束之前的总步数（批次样本）。默认值 None。

2、手写数字识别

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense,Activation,Dropout
from keras.optimizers import RMSprop

#1、定义程序用到的参数 通常是与训练过程有关的参数
#每个训练批量的大小
batch_size=128
#模型的输出是多少个类别  回归问题一般只有一个输出
num_classes=10
#训练的轮数
epochs=20

#2、数据准备
(x_train,y_train),(x_test,y_test)=mnist.load_data()
print("train data shape",x_train.shape)
print("train label shape",y_train.shape)
print("test data shape",x_test.shape)
print("test label shape",y_test.shape)
#3、把训练集中的几个数据打印出来  灰度图像
import matplotlib.pyplot as plt
plt.subplot(221)
plt.imshow(x_train[0],cmap=plt.get_cmap('gray'))
plt.subplot(222)
plt.imshow(x_train[1],cmap=plt.get_cmap('gray'))
plt.subplot(223)
plt.imshow(x_train[2],cmap=plt.get_cmap('gray'))
plt.subplot(224)
plt.imshow(x_train[3],cmap=plt.get_cmap('gray'))
plt.show()
#4、数据预处理
x_train=x_train.reshape(60000,784)
x_test=x_test.reshape(10000,784)
x_train=x_train.astype('float32')
x_test=x_test.astype('float32')
x_train/=255
x_test/=255
y_train=keras.utils.to_categorical(y_train,num_classes)
y_test=keras.utils.to_categorical(y_test,num_classes)

#5、定义模型
model=Sequential()
model.add(Dense(512,activation='relu',input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(512,activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_classes,activation='softmax'))
#打印模型结构图
print(model.summary())
#6、编译模型
model.compile(loss='categorical_crossentropy',optimizer=RMSprop(),metrics=['accuracy'])
#7、训练模型
h=model.fit(x_train,y_train,batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(x_test,y_test))
print(h.history)
#8、评价模型
score=model.evaluate(x_test,y_test,verbose=0)
print('test loss:',score[0])
print('test accuracy:',score[1])
#9、预测模型
y_pred=model.predict(x_test)
print(y_pred)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

神经网络模型结构
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense (Dense)                (None, 512)               401920    
_________________________________________________________________
dropout (Dropout)            (None, 512)               0         
_________________________________________________________________
dense_1 (Dense)              (None, 512)               262656    
_________________________________________________________________
dropout_1 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_2 (Dense)              (None, 10)                5130      
=================================================================
Total params: 669,706
Trainable params: 669,706
Non-trainable params: 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3、使用生成器批量训练大量数据
keras中用于模型训练的函数有3个：

model.fit(x_train, y_train,
          epochs=20,
          batch_size=128)
'''
fit(x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, 
validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, 
sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None)
'''
1
2
3
4
5
6
7
8

history_object = model.fit_generator(train_generator, 
                                     steps_per_epoch=samples_per_epoch,
                                      validation_data=validation_generator,
                                      validation_steps=nb_val_samples, 
                                     epochs=nb_epoch, verbose=1,
                                     callbacks=callbacks_list)
1
2
3
4
5
6

train_on_batch(x, y, sample_weight=None, class_weight=None)
1

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense,Activation,Dropout
from keras.optimizers import RMSprop

num_classes=10
#使用fit_generator函数批量训练大量数据
#定义一个生成器用于批量生成数据
def data_generator_mnist(isTrain=True,batchSize=100):
    nb_classes=10
    (X_train,y_train),(X_test,y_test)=mnist.load_data()
    X_train=X_train.reshape(60000,784)
    X_test=X_test.reshape(10000,784)
    X_train=X_train.astype('float32')
    X_test=X_test.astype('float32')
    X_train/=255
    X_test/=255
    Y_train=keras.utils.to_categorical(y_train,num_classes)
    Y_test=keras.utils.to_categorical(y_test,num_classes)
    if(isTrain):
        dataset=(X_train,Y_train)
    else:
        dataset = (X_test, Y_test)
    dataset_size=dataset[0].shape[0]
    while(True):
        i=0
        yield dataset[0][i:i+batchSize],dataset[1][i:i+batchSize]
        i+=batchSize
        if (i+batchSize>dataset_size):
            i=0

model=Sequential()
model.add(Dense(512,activation='relu',input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(512,activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_classes,activation='softmax'))
model.compile(loss='categorical_crossentropy',optimizer=RMSprop(),metrics=['accuracy'])

history=model.fit_generator(data_generator_mnist(True,batchSize=100),steps_per_epoch=60000,epochs=1,validation_data=data_generator_mnist(False,batchSize=100),validation_steps=10000)
scores=model.evaluate_generator(data_generator_mnist(False),steps=10000)
print("baseline error:%.2f%%"%(100-scores[1]*100))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

60000/60000 [==============================] - 937s 16ms/step - loss: 1.6444e-04 - accuracy: 1.0000 - val_loss: 2.4502 - val_accuracy: 0.7400
baseline error:26.00%
1
2

python中yield的理解：见博客 https://blog.csdn.net/mieleizhi0522/article/details/82142856
4、在keras中重复使用模型
在定义好模型结构之后，可以保存模型，将来可以把这个保存好的模型加载出来，以便重复使用这个模型。
keras通常使用HDF5文件的格式来保存模型，文件包含的格式如下：模型的结构、模型的权值、训练配置、优化器的状态。
将模型的一切打包成HDF5文件：model.save(‘my_model.h5’)
加载模型：
from keras.models import load_model
model=load_model(‘my_model.h5’)