tf.keras模块——Input、Model

tf.keras.Input()

　　初始化一个keras张量

　　tf.keras.Input(
    　　shape=None,
    　　batch_size=None,
    　　name=None,
    　　dtype=None,
    　　sparse=False,
    　　tensor=None,
    　　**kwargs
　　)

 

    参数：
    shape：形状元组（整数），不包括批量大小。例如，shape=(32,)表示预期输入将是32维向量的批次。
    batch_size：可选的静态批处理大小（整数）。
    name：图层的可选名称字符串。在模型中应该是唯一的（不要重复使用相同的名称两次）。如果没有提供，它将自动生成。
    dtype：数据类型由输入预期的，作为字符串（float32，float64，int32...）
    sparse：一个布尔值，指定要创建的占位符是否稀疏。
    tensor：可选的现有张量以包装到Input图层中。如果设置，该图层将不会创建占位符张量。
    **kwargs：不推荐的参数支持。

 

　　案例：

    x = Input(shape=(32,))
    y = tf.square(x)

 

 

tf.keras.Model()

　　将layers分组为具有训练和推理特征的对象

　　两种实例化的方式：

　　1 - 使用“API”，从开始，链接层调用以指定模型的正向传递，最后从输入和输出创建模型：

 

    import tensorflow as tf

    inputs = tf.keras.Input(shape=(3,))
    x = tf.keras.layers.Dense(4, activation=tf.nn.relu)(inputs)
    outputs = tf.keras.layers.Dense(5, activation=tf.nn.softmax)(x)
    model = tf.keras.Model(inputs=inputs, outputs=outputs)

 

　　2 - 通过继承Model类：在这种情况下，您应该在__init__定义你的layers，并且应该在call函数里实现模型的正向传递。

 

　　import tensorflow as tf

　　class MyModel(tf.keras.Model):

　　  def __init__(self):
    　　super(MyModel, self).__init__()
    　　self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    　　self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)

  　　def call(self, inputs):
    　　x = self.dense1(inputs)
    　　return self.dense2(x)

　　model = MyModel()

　　tf.keras.Model.compile():模型编译

    compile(
        optimizer,---> ['Adadelta', 'Adagrad', 'Adam', 'Adamax', 'FTRL', 'NAdam', 'optimizer', 'RMSprop', 'SGD']
        loss=None,
        metrics=None,
        loss_weights=None,
        sample_weight_mode=None,
        weighted_metrics=None,
        target_tensors=None,
        distribute=None,
        **kwargs
    )

　　参数：

　　optimizer: 优化参数，选择范围我们已经在上面的代码块展示了。

　　loss: 

　　　　BinaryCrossentropy：计算真实标签和预测标签之间的交叉熵损失。
　　　　CategoricalCrossentropy：计算标签和预测之间的交叉熵损失。
　　　　CategoricalHinge：计算y_true和y_pred之间的分类铰链损失。
　　　　CosineSimilarity：计算y_true和y_pred之间的余弦相似度。
　　　　Hinge：计算y_true和y_pred之间的铰链损耗。
　　　　Huber：计算y_true和y_pred之间的Huber损失。
　　　　KLDivergence：计算y_true和y_pred之间的Kullback Leibler差异损失。
　　　　LogCosh：计算预测误差的双曲余弦的对数。
　　　　Loss：损失基类。
　　　　MeanAbsoluteError：计算标签和预测之间的绝对差异的平均值。
　　　　MeanAbsolutePercentageError：计算y_true和y_pred之间的平均绝对百分比误差。
　　　　MeanSquaredError：计算标签和预测之间的误差平方的平均值。
　　　　MeanSquaredLogarithmicError：计算y_true和y_pred之间的均方对数误差。
　　　　Poisson：计算y_true和y_pred之间的泊松损失。
　　　　Reduction：减少损失的类型。
　　　　SparseCategoricalCrossentropy：计算标签和预测之间的交叉熵损失。
　　　　SquaredHinge：计算y_true和y_pred之间的平方铰链损耗。

 

　　metrics: 训练和测试期间要使用的评估指标。

　　　　1、metrics=['accuracy']
　　　　2、多输出模型的不同输出指定不同的度量标准：
　　　　     metrics={'output_a': 'accuracy', 'output_b': ['accuracy', 'mse']}
　　　　     metrics=[['accuracy'], ['accuracy', 'mse']]
 　　　　    metrics=['accuracy', ['accuracy', 'mse']]

　　sample_weight_mode：如果您需要进行时间步长样本加权（2D权重），请将

　　　　其设置为"temporal"。 None默认为采样权重（1D）。如果模型具有多个

　　　　输出，则可以sample_weight_mode通过传递字典或模式列表在每个输出上

　　　　使用不同的输出。

　　weighted_metrics：在训练和测试期间由sample_weight或class_weight评估和加权的指标列表。

 

　　tf.keras.Model.evaluate():模型评估

 

　　evaluate(
　　    x=None,
　　    y=None,
　　    batch_size=None,
　　    verbose=1,
　　    sample_weight=None,
　　    steps=None,
　　    callbacks=None,
　　    max_queue_size=10,
　　    workers=1,
 　　   use_multiprocessing=False
　　)

　　参数：

　　　　x: 测试自变量，可以是Numpy数组或数组列表、TensorFlow张量或张量列表、如果模型

　　　　　　　　具有命名输入，则dict将输入名称映射到相应的数组/张量、tf.data数据集或数据

　　　　　　　　集的迭代、生成器或keras.utils.Sequence实例。

　　　　y: 目标数据，类型同x一样。

　　　　batch_size: 每个批量处理的数据量。整数。默认为32。如果你的数据是 symbolic

　　　　　　　　tensors, dataset, dataset iterators, generators, or keras.utils.

　　　　　　　　Sequence则不需要指定该参数，因为它会生成batchs.

　　　　verbose: 0, 1，默认为1。日志显示，批量输出，你可以控制输出的间隔。

　　　　steps: 整数或None，每轮迭代的步数。如果x是 tf.data dataset or a dataset iterator,

　　　　　　　　and steps is None，则数据将会耗尽为止。

　　　　max_queue_size: 默认为10，生成队列的最大size。

　　　　workers: 进程数。

 

　　tf.keras.Model.evaluate_generator():

　　　　在数据生成器上评估模型

    evaluate_generator(
        generator,
        steps=None,
        callbacks=None,
        max_queue_size=10,
        workers=1,
        use_multiprocessing=False,
        verbose=0
    )

　　

　　tf.keras.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,
        max_queue_size=10,
        workers=1,
        use_multiprocessing=False,
        **kwargs
    )

　　参数：
　　　　validation_split： 0，1之间的浮点数。分割部分数据用于验证，其余用于训练。当x

　　　　　　　　　　是dataset, dataset iterator, generator or keras.utils.Sequence时该

　　　　　　　　　　参数不可用。
　　　　validation_data：指定验证集数据：

　　　　　　　　　　　　　　(x_val, y_val)、（x_val, y_val, val_sample_weights)；
　　　　　　　　　　dataset or a dataset iterator两种数据对于上面两种情况要指定

　　　　　　　　　　validation_steps。
　　　　class_weight： 指定权值分配，可以突出重点关注的类别。（对损失函数加权）
　　　　sample_weight： 样本加权，对损失函数加权，以获得更好的结果。这里可以是numpy

　　　　　　　　　　数组，必须保障shape是和传入数据大小一致。应该确保在compile()中

　　　　　　　　　　指定sample_weight_mode=“temporal”，dataset, dataset iterator,

　　　　　　　　　　generator, or keras.utils.Sequence不支持该参数。
　　　　initial_epoch: 整数。开始训练的epoch（对于恢复以前的训练运行很有用）。
　　　　steps_per_epoch: 每个epoch的迭代步数。
　　　　validation_steps：
　　　　validation_freq: 指定验证的epoch，可以为整数或者列表：如：[1,2,10]。

　　tf.keras.Model.fit_generator():

　　在数据生成器上拟合模型，可以减少内存消耗

    fit_generator(
        generator,
        steps_per_epoch=None,
        epochs=1,
        verbose=1,
        callbacks=None,
        validation_data=None,
        validation_steps=None,
        validation_freq=1,
        class_weight=None,
        max_queue_size=10,
        workers=1,
        use_multiprocessing=False,
        shuffle=True,
        initial_epoch=0
    )

　　   这里传入的数据必须是生成器（yield），如：

    def generate_arrays_from_file(path):
        while 1:
            f = open(path)
            for line in f:
                # create numpy arrays of input data
                # and labels, from each line in the file
                x1, x2, y = process_line(line)
                yield ({'input_1': x1, 'input_2': x2}, {'output': y})
            f.close()

    model.fit_generator(generate_arrays_from_file('/my_file.txt'),
                        steps_per_epoch=10000, epochs=10)

　　tf.keras.Model.get_layer():

　　获取图层：根据其名称（唯一）或索引检索图层

    get_layer(
        name=None,
        index=None
    )

　　tf.keras.Model.load_weights():

　　从TensorFlow或HDF5文件加载所有图层权重

    load_weights(
        filepath,
        by_name=False
    )

　　tf.keras.Model.predict():预测

    predict(
        x,
        batch_size=None,
        verbose=0,
        steps=None,
        callbacks=None,
        max_queue_size=10,
        workers=1,
        use_multiprocessing=False
    )

　　　　参数：
　　　　　　x：Numpy数组（或类数组）或数组列表、TensorFlow张量或张量列表、
　　　　　　　  数据集或数据集的迭代、生成器或keras.utils.Sequence实例

　　tf.keras.Model.predict_generator():

　　以生成器传入数据进行预测

    predict_generator(
        generator,
        steps=None,
        callbacks=None,
        max_queue_size=10,
        workers=1,
        use_multiprocessing=False,
        verbose=0
    )

　　tf.keras.Model.predict_on_batch():

　　单批次样本进行预测

    predict_on_batch(x)

　　tf.keras.Model.test_on_batch():

　　单批次样本进行测试

    test_on_batch(
        x,
        y=None,
        sample_weight=None,
        reset_metrics=True
    )

　　tf.keras.Model.train_on_batch():

　　单批次样本进行训练

    train_on_batch(
        x,
        y=None,
        sample_weight=None,
        class_weight=None,
        reset_metrics=True
    )

　　tf.keras.Model.reset_metrics():重置指标的状态

　　　　如果True，返回的指标仅适用于此批次。如果False，指标将在批次之间有状态地累积。

　　tf.keras.Model.reset_states():

　　重置状态,需要连续调用的时候最好使用resets_states()

　　tf.keras.Model.save():保存模型

    save(
        filepath,
        overwrite=True,
        include_optimizer=True,
        save_format=None
    )

　　　将模型保存到Tensorflow SavedModel或单个HDF5文件。

　　　　保存文件包括：

　　　　1、模型体系结构，允许重新实例化模型。

　　　　2、模型权重。

　　　　3、优化器的状态，允许您从中断的位置恢复训练。

　　　

　　   参数：
　　　　filepath： 字符串，模型保存的位置
　　　　overwrite： 是否静默覆盖目标位置的现有文件，或者为用户提供手动提示
　　　　include_optimizer： 如果为True，则将优化器的状态保存在一起
　　　　save_format： 保存的类型，‘tf’，‘h5’，目前tf已经禁用了（tensorflow2.0中）

    from keras.models import load_model

    model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'
    del model  # deletes the existing model

    # returns a compiled model
    # identical to the previous one
    model = load_model('my_model.h5')

　　tf.keras.Model.save_weights():保存所有图层权重

    save_weights(
        filepath,
        overwrite=True,
        save_format=None
    )

　　tf.keras.Model.summary():打印网络的字符串摘要

    summary(
        line_length=None,
        positions=None,
        print_fn=None
    )

　　　参数：

　　　　line_length： 打印行的总长度（例如，将其设置为使显示适应不同的终端窗口大小）。

　　　　positions： 每行中日志元素的相对或绝对位置。如果未提供，则默认为[.33, .55, .67, 1.]。

　　　　print_fn： 打印功能。默认为print。它将在摘要的每一行上调用。您可以将其设置为自定义函

　　　　　　数以捕获字符串摘要。

 

　　tf.keras.Model.to_json():

　　返回包含网络配置的JSON字符串

　　　　要从保存文件JSON加载网络，请使用

　　　　　　 keras.models.model_from_json(json_string, custom_objects={})。

　　tf.keras.Model.to_yaml():

　　返回包含网络配置的yaml字符串

　　　　要从yaml保存文件加载网络，请使用

　　　　　　 keras.models.model_from_yaml(yaml_string, custom_objects={})。