526互联

Keras Model 和 Sequential

发布时间 2023-10-08 09:30:36作者: emanlee

Keras Model

https://cloud.tencent.com/developer/article/2162930

===============================================================

Keras 模型

Keras提供的模型，其中分为两类：

  • Sequential 顺序模型
  • Model 类模型

我们可以通过 from keras.models import Sequential 或者 from keras.models import Model 来导入对应的模型。

 

Sequential 顺序模型

参考Keras文档： https://keras.io/models/sequential/

  • Sequential 模型结构： 层（layers）的线性堆栈。简单来说，它是一个简单的线性结构，没有多余分支，是多个网络层的堆叠。

Sequential使用方法

一个简单的Sequential示例

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

model = Sequential([
    Dense(32, input_shape=(784,)),
    Activation('relu'),
    Dense(10),
    Activation('softmax'),
])

 

从上述代码中可以看出：

  • from keras.models import Sequential 引入Sequential
  • model = Sequential([...]）则开始构建model
    • 其中，Dense是一个全连接层，它的激活函数默认为是linear线性函数
    • 激活函数可以通过 单独的激活层 实现，也可以通过 构建层时传递activation实现，这就是说：
  model.add(Dense(64))
  model.add(Activation('tanh'))

等价于

model.add(Dense(64, activation='tanh'))

构建方法

除了上面代码的：

model = Sequential([
    Dense(32, input_shape=(784,)),
    Activation('relu'),
    Dense(10),
    Activation('softmax'),
])

还可以简单的写为：

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

input shape 输入的形状（格式）

构建一个模型时，第一层需要给出期待的Input shape ，剩余的层次会自动判断。

  • input shape是一个tuple格式的数据，可以是整数的tuple，也可以是None
  • input shape中并没有batch dimension 批量维度
  • 2D层，例如Dense, 通过指定参数 input_dim （一个数字）来描述输入形状。
  • 3D层，通过参数 input_dim 和 input_length来描述输入型状。
  • 参数input_shape 通过tuple的形式，指定输入形状。
  • 参数batch_size可以指定固定批量大小。

batch_size=32 + input_shape=(6, 8) = (32, 6, 8)

示例：

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

## 上下相等，对于二维层Dense,可以通过如下所示的input_dim指定输入形状##

model = Sequential()
model.add(Dense(32, input_dim=784))

 

 

complication 编译

在训练模型之前，您需要配置学习过程，这是通过编译方法完成的。 形式是model.compile(...) 它收到三个参数：

  • 优化器（opyimizer）,可以是优化器的字符串标识符，也可以是Optimizer类的实例
  • 损失函数（loss function），模型要将其最小化，可以通过字符串标识符指定，可以通过目标函数指定
  • 指标（metricts）列表， 对于任何分类问题，需要将其设置为metrics = [‘accuracy’]。 度量可以是现有度量的字符串标识符或自定义度量函数。
# For a multi-class classification problem
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# For a binary classification problem
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

# For a mean squared error regression problem
model.compile(optimizer='rmsprop',
              loss='mse')
 

其实compile函数还可以接受其他参数，此处不以详述。

training 训练

使用fit函数进行训练,示例如下：

model = Sequential()
model.add(Dense(32, activation='relu', input_dim=100))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
     loss='binary_crossentropy',
     metrics=['accuracy'])
# Generate dummy data
import numpy as np
data = np.random.random((1000, 100))
labels = np.random.randint(2, size=(1000, 1))
# Train the model, iterating on the data in batches of 32 samples
model.fit(data, labels, epochs=10, batch_size=32)
 

fit函数官方定义如下：

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, validation_freq=1)

其中常用的参数：

  • x Numpy训练数据数组（如果模型有单个输入），或Numpy数组列表（如果模型有多个输入）。也可以是已经命名的输入图层的名称。 如果从框架原生张量（例如TensorFlow数据张量）进行馈送，则x可以是None（默认）。
  • y 与x相似，只不过y代表的是目标标签（target label）。可以是：Numpy目标（标签）数据数组（如果模型具有单个输出）或Numpy数组列表（如果模型具有多个输出）或 输入图层的名称 或None.
  • batch_size Integer 或 None，代表每个梯度更新的样本数，默认值为32.
  • epochs Integer，模型的训练的 时期数，每个epoch是对x，y的整个迭代。

 

Model 模型

参考Keras文档：https://keras.io/models/model/

Model 模型是带有函数API的，不是线性的，它是一个可以多输入、多输出的模型。

如下：

model = Model(inputs=a, outputs=b)
model = Model(inputs=[a1, a2], outputs=[b1, b2, b3])
  • 通过inputs 和 outputs 构造多输入（a1,a2）和多输出（b1,b2,b3）的Model

 

Model 使用方法

与Sequential类似，有compile fit等方法。大致和上述的compile和fit一致。

compile 编译

compile(optimizer, loss=None, metrics=None, loss_weights=None, sample_weight_mode=None, weighted_metrics=None, target_tensors=None)
  • optimizer:优化器
  • loss:损失函数。与Sequential的compile的loss有所不同的是，Model的多个输出可以有多个loss，可以用过一个dict来声明：{'output_a':loss_func_1, 'output_b':loss_func_2}
  • metrics:指标列表。在培训和测试期间由模型评估的度量列表。 通常，您将使用metrics = [‘accuracy’]。 要为多输出模型的不同输出指定不同的度量标准，您还可以传递dict，例如metrics = {‘output_a’：‘accuracy’}。

fit 进行训练

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, validation_freq=1)

x,y,batch_size,epoch都和之前说明的一样。 返回 一个History实例， 其History.history属性是连续时期的训练损失值和度量值的记录，以及验证损失值和验证度量值（如果适用）。

 

evaluate 函数进行评估

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

返回测试模式下模型的损失值（loss）和度量（metricts）值。

 

出处：https://javaforall.cn/234882.html

 

model = Sequential()
model.add(Dense(32, input_shape=(500,)))
model.add(Dense(10, activation='softmax'))
model.compile(optimizer='rmsprop',
      loss='categorical_crossentropy',
      metrics=['accuracy'])
model.fit( x, y, batch_size=32, nb_epoch=10, verbose=1, callbacks=[], validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None)
score = model.evaluate(x_test, y_test, batch_size=32)
model.predict(x, batch_size=32, verbose=0)
model.predict_classes( x, batch_size=32, verbose=1)
model.predict_proba(x, batch_size=32, verbose=1)

 

Sequential() 代表类的初始化；
Dense() 代表全连接层，参数32表示本层有32个神经元，然后接relu激活层，由于是第一层，计算机不知道应该是以多少维增加，因此，后面添加输入维度数100。这一层需要训练100*32+32个参数。
model.add() 相当于把模型一层层拼接起来。
model.compile() 函数中输入优化器，损失函数等信息
model.fit() 中传入需要训练的数据x,y以及训练的批次等信息，开始训练
model.evaluate() 用来评估模型的误差函数的返回值是预测值的numpy array
model.predict_classes：本函数按batch产生输入数据的类别预测结果；
model.predict_proba：本函数按batch产生输入数据属于各个类别的概率
https://blog.csdn.net/xyh_qianxiao/article/details/112296758

 

===============================================================

Model 训练


Model 训练有两种方式 fit 和 fit_generator.

Model fit

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, validation_freq=1)


    x: 训练数据的 Numpy 数组（如果模型只有一个输入）， 或者是 Numpy 数组的列表（如果模型有多个输入）。 如果模型中的输入层被命名，你也可以传递一个字典，将输入层名称映射到 Numpy 数组。 如果从本地框架张量馈送（例如 TensorFlow 数据张量）数据，x 可以是 None（默认）。
    y: 目标（标签）数据的 Numpy 数组（如果模型只有一个输出）， 或者是 Numpy 数组的列表（如果模型有多个输出）。 如果模型中的输出层被命名，你也可以传递一个字典，将输出层名称映射到 Numpy 数组。 如果从本地框架张量馈送（例如 TensorFlow 数据张量）数据，y 可以是 None（默认）。
    batch_size: 整数或 None。每次梯度更新的样本数。如果未指定，默认为 32。
    epochs: 整数。训练模型迭代轮次。一个轮次是在整个 x 和 y 上的一轮迭代。 请注意，与 initial_epoch 一起，epochs 被理解为 「最终轮次」。模型并不是训练了 epochs 轮，而是到第 epochs 轮停止训练。
    verbose: 0, 1 或 2。日志显示模式。 0 = 安静模式, 1 = 进度条, 2 = 每轮一行。
    callbacks: 一系列的 keras.callbacks.Callback 实例。一系列可以在训练时使用的回调函数。 详见 callbacks。
    validation_split: 0 和 1 之间的浮点数。用作验证集的训练数据的比例。 模型将分出一部分不会被训练的验证数据，并将在每一轮结束时评估这些验证数据的误差和任何其他模型指标。 验证数据是混洗之前 x 和y 数据的最后一部分样本中。
    validation_data: 元组 (x_val，y_val) 或元组 (x_val，y_val，val_sample_weights)， 用来评估损失，以及在每轮结束时的任何模型度量指标。 模型将不会在这个数据上进行训练。这个参数会覆盖 validation_split。
    shuffle: 布尔值（是否在每轮迭代之前混洗数据）或者 字符串 (batch)。 batch 是处理 HDF5 数据限制的特殊选项，它对一个 batch 内部的数据进行混洗。 当 steps_per_epoch 非 None 时，这个参数无效。


fit_generator



采用keras数据自动生成器(generator)，继承keras.utils.Sequence(即定义数据生成类class DataGenerator(keras.utils.Sequence))，结合fit_generator可以实现节约内存训练。参考
fit_generator(generator, steps_per_epoch=None, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, class_weight=None, max_queue_size=10, workers=1, use_multiprocessing=False, shuffle=True, initial_epoch=0)
参数

    generator: 一个生成器，或者一个 Sequence (keras.utils.Sequence) 对象的实例， 以在使用多进程时避免数据的重复。 生成器的输出应该为以下之一：
        一个 (inputs, targets) 元组
        一个 (inputs, targets, sample_weights) 元组。
        这个元组（生成器的单个输出）组成了单个的 batch。 因此，这个元组中的所有数组长度必须相同（与这一个 batch 的大小相等）。 不同的 batch 可能大小不同。 例如，一个 epoch 的最后一个 batch 往往比其他 batch 要小， 如果数据集的尺寸不能被 batch size 整除。 生成器将无限地在数据集上循环。当运行到第 steps_per_epoch 时，记一个 epoch 结束。

    steps_per_epoch: 在声明一个 epoch 完成并开始下一个 epoch 之前从 generator 产生的总步数（批次样本）。 它通常应该等于你的数据集的样本数量除以批量大小。 对于 Sequence，它是可选的：如果未指定，将使用len(generator) 作为步数。

    epochs: 整数。训练模型的迭代总轮数。一个 epoch 是对所提供的整个数据的一轮迭代，如 steps_per_epoch 所定义。注意，与 initial_epoch 一起使用，epoch 应被理解为「最后一轮」。模型没有经历由 epochs 给出的多次迭代的训练，而仅仅是直到达到索引 epoch 的轮次。

    verbose: 0, 1 或 2。日志显示模式。 0 = 安静模式, 1 = 进度条, 2 = 每轮一行。

    callbacks: keras.callbacks.Callback 实例的列表。在训练时调用的一系列回调函数。
    validation_data: 它可以是以下之一：
        验证数据的生成器或 Sequence 实例
        一个 (inputs, targets) 元组
        一个 (inputs, targets, sample_weights) 元组。
        在每个 epoch 结束时评估损失和任何模型指标。该模型不会对此数据进行训练。

    validation_steps: 仅当 validation_data 是一个生成器时才可用。 在停止前 generator 生成的总步数（样本批数）。 对于 Sequence，它是可选的：如果未指定，将使用 len(generator) 作为步数。

    class_weight: 可选的将类索引（整数）映射到权重（浮点）值的字典，用于加权损失函数（仅在训练期间）。 这可以用来告诉模型「更多地关注」来自代表性不足的类的样本。

    max_queue_size: 整数。生成器队列的最大尺寸。 如未指定，max_queue_size 将默认为 10。

    workers: 整数。使用的最大进程数量，如果使用基于进程的多线程。 如未指定，workers 将默认为 1。如果为 0，将在主线程上执行生成器。

    use_multiprocessing: 布尔值。如果 True，则使用基于进程的多线程。 如未指定，use_multiprocessing 将默认为 False。 请注意，由于此实现依赖于多进程，所以不应将不可传递的参数传递给生成器，因为它们不能被轻易地传递给子进程。

    shuffle: 是否在每轮迭代之前打乱 batch 的顺序。 只能与 Sequence (keras.utils.Sequence) 实例同用。

    initial_epoch: 开始训练的轮次（有助于恢复之前的训练）。


Model保存


keras.callbacks.ModelCheckpoint(filepath,monitor='val_loss',verbose=0,save_best_only=False, save_weights_only=False, mode='auto', period=1)

参数说明：

    filename：字符串，保存模型的路径
    monitor：需要监视的值，通常有"val_loss",“val_acc”
    verbose：信息展示模式，0或1(checkpoint的保存信息，类似Epoch 00001: saving model to …)
    save_best_only：当设置为True时，监测值有改进时才会保存当前的模型（ the latest best model according to the quantity monitored will not be overwritten）
    mode：‘auto’，‘min’，‘max’之一，在save_best_only=True时决定性能最佳模型的评判准则，例如，当监测值为val_acc时，模式应为max，当监测值为val_loss时，模式应为min。在auto模式下，评价准则由被监测值的名字自动推断。
    save_weights_only：若设置为True，则只保存模型权重，否则将保存整个模型（包括模型结构，配置信息等）
    period：CheckPoint之间的间隔的epoch数


————————————————
链接：https://blog.csdn.net/weixin_40548136/article/details/107402907

===============================================================