LYPvvvLYP

Python 和 Tensorflow 相关

文章目录

pip
Tensorflow 2.1.0
- tf.keras
- Keras框架中的epoch、bacth、batch size、iteration
- tf.keras.layers
- - tf.keras.layers.Dense 添加一个全连接层
  - tf.keras.layers.Conv2D 添加一个卷积层
- Tensorboard
- Object Localization
- - Othors
  - - 激活函数
    - model.evaluate 和 model.predict 的区别
TODO
TODO

pip

pip 镜像

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pandas

Tensorflow 2.1.0

tf.keras

Keras 简介
Keras是一个用于构建和训练深度学习模型的高级API。它用于快速原型设计，高级研究和生产，具有三个主要优点：

用户友好
Keras具有针对常见用例优化的简单，一致的界面。它为用户错误提供清晰且可操作的反馈。
模块化和可组合
Keras模型是通过将可配置的构建块连接在一起而制定的，几乎没有限制。
易于扩展
编写自定义构建块以表达研究的新想法。创建新图层，损失函数并开发最先进的模型。

导入 tf.keras

import tensorflow as tf
from tensorflow import keras

构建一个简单的模型
2.1 Sequential model
在Keras中，您可以组装图层来构建模型。模型（通常）是图层图。最常见的模型类型是一堆层：tf.keras.Sequential 模型。
构建一个简单的全连接网络（即多层感知器）：

model = keras.Sequential()
model.add(keras.layers.Dense(64, activation='relu'))
model.add(keras.layers.Dense(64, activation='relu'))
model.add(keras.layers.Dense(10, activation='softmax'))

2.2 Configure the layers
在 tf.keras.layers 中有很多层，下面是一些通用的构造函数的参数：

activation ：设置层的激活函数。此参数由内置函数的名称或可调用对象指定。默认情况下，不应用任何激活。
kernel_initializer 和 bias_initializer ：设置层创建时，权重和偏差的初始化方法。指定方法：名称或可调用对象。默认为"Glorot uniform" initializer。
kernel_regularizer 和 bias_regularizer ：设置层的权重、偏差的正则化方法。比如：L1 或 L2 正则。默认为空。
以下实例化tf.keras。 layers.Dense图层使用构造函数参数：

layers.Dense(64, activation='sigmoid')
layers.Dense(64, activation=tf.sigmoid)
layers.Dense(64, kernel_regularizer=keras.regularizers.l1(0.01))
layers.Dense(64, bias_regularizer=keras.regularizers.l2(0.01))
layers.Dense(64, kernel_initializer='orthogonal')
layers.Dense(64, bias_initializer=keras.initializers.constant(2.0))

Train and evaluate
3.1 Set up training
构建模型后，通过调用compile方法配置其训练过程：

model.compile(optimizer=tf.train.AdamOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])
tf.keras.Model.compile有三个重要参数：

optimizer ：训练过程的优化方法。此参数通过 tf.train 模块的优化方法的实例来指定，比如：AdamOptimizer， RMSPropOptimizer， GradientDescentOptimizer。
loss ：训练过程中使用的损失函数（通过最小化损失函数来训练模型）。常见的选择包括：均方误差（mse），categorical_crossentropy和binary_crossentropy。损失函数由名称或通过从tf.keras.losses模块传递可调用对象来指定。
metrics ：训练过程中，监测的指标（Used to monitor training）。
指定方法：名称或可调用对象 from the tf.keras.metrics 模块。
以下显示了配置培训模型的几个示例：

# Configure a model for mean-squared error regression.
model.compile(optimizer=tf.train.AdamOptimizer(0.01),
              loss='mse',       # mean squared error
              metrics=['mae'])  # mean absolute error

# Configure a model for categorical classification.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.01),
              loss=keras.losses.categorical_crossentropy,
              metrics=[keras.metrics.categorical_accuracy])

3.2 Input NumPy data
对于小的数据集，可以直接使用 NumPy 格式的数据进行训练、评估模型。模型使用 fit 方法训练数据：

import numpy as np

data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))

model.fit(data, labels, epochs=10, batch_size=32)
tf.keras.Model.fit 有三个重要的参数：

epochs ：训练多少轮。（小批量）
batch_size ：当传递NumPy数据时，模型将数据分成较小的批次，并在训练期间迭代这些批次。此整数指定每个批次的大小。请注意，如果样本总数不能被批量大小整除，则最后一批可能会更小。
validation_data ：在对模型进行原型设计时，您希望轻松监控其在某些验证数据上的性能。传递这个参数 - 输入和标签的元组 - 允许模型在每个epoch的末尾以传递数据的推理模式显示损失和度量。
这是使用validation_data的示例：

import numpy as np

data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))

val_data = np.random.random((100, 32))
val_labels = np.random.random((100, 10))

model.fit(data, labels, epochs=10, batch_size=32,
          validation_data=(val_data, val_labels))

3.3 Input tf.data datasets
使用数据集API可扩展到大型数据集或多设备培训。将tf.data.Dataset实例传递给fit方法：
使用 Datasets API 可扩展到大型数据集或多设备训练。给 fit 方法传递一个 tf.data.Dataset 实例：

# Instantiates a toy dataset instance:
dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32)
dataset = dataset.repeat()

# Don't forget to specify `steps_per_epoch` when calling `fit` on a dataset.
model.fit(dataset, epochs=10, steps_per_epoch=30)

这里，fit方法使用steps_per_epoch参数 - 这是模型在移动到下一个epoch之前运行的训练步数。由于数据集生成批量数据，因此此代码段不需要batch_size。
Dataset API 也可以用于验证：

dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32).repeat()

val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels))
val_dataset = val_dataset.batch(32).repeat()

model.fit(dataset, epochs=10, steps_per_epoch=30,
          validation_data=val_dataset,
          validation_steps=3)

3.4 Evaluate and predict
tf.keras.Model.evaluate 和 tf.keras.Model.predict 方法能够使用 NumPy 数据和 tf.data.Dataset 数据。
要评估所提供数据的推理模式损失和指标：

model.evaluate(x, y, batch_size=32)

model.evaluate(dataset, steps=30)

并且作为NumPy数组，预测所提供数据的推断中最后一层的输出：

model.predict(x, batch_size=32)

model.predict(dataset, steps=30)

Build advanced models
4.1 Functional API
tf.keras.Sequential 模型只适用于多层简单堆叠网络，不能表示复杂模型。使用 Keras functional API 可以构建有复杂拓扑结构的模型。比如：

多输入模型（Multi-input models）
多输出模型（Multi-output models）
有共享层的模型（Models with shared layers (the same layer called several times))
具有非顺序数据流的模型（Models with non-sequential data flows (e.g. residual connections))
使用函数式API构建模型的工作方式如下：
层实例可调用并返回张量。
输入 tensors 和输出 tensors 被用来定义一个 tf.keras.Model 实例
这个模型的训练就像Sequential模型一样。
以下示例使用函数式API构建一个简单，全连接的网络：

inputs = keras.Input(shape=(32,))  # Returns a placeholder tensor

# A layer instance is callable on a tensor, and returns a tensor.
x = keras.layers.Dense(64, activation='relu')(inputs)
x = keras.layers.Dense(64, activation='relu')(x)
predictions = keras.layers.Dense(10, activation='softmax')(x)

# Instantiate the model given inputs and outputs.
model = keras.Model(inputs=inputs, outputs=predictions)

# 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)

4.2 Model subclassing
通过继承tf.keras.Model并定义自己的前向传递来构建完全可自定义的模型。在init方法中创建图层并将它们设置为类实例的属性。在call方法中定义正向传递。

当启用eager执行时，模型子类化特别有用，因为可以强制写入正向传递。

提示：为工作使用正确的API。虽然模型子类化提供了灵活性，但其代价是更高的复杂性和更多的用户错误机会。如果可能，请选择功能API。

以下示例显示了使用自定义正向传递的子类tf.keras.Model：

class MyModel(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 = keras.layers.Dense(32, activation='relu')
        self.dense_2 = keras.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)


# Instantiates the subclassed model.
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)

4.3 自定义 layers
通过继承tf.keras.layers.Layer并实现以下方法来创建自定义层：

build ：创建图层的权重。使用add_weight方法添加权重。
call ：定义前向传播过程。
compute_output_shape ：指定在给定输入形状的情况下如何计算图层的输出形状。
或者，可以通过实现get_config方法和from_config类方法来序列化层。
这里有一个自定义 layer 的例子，该 layer 将输入和一个矩阵进行相乘：

class MyLayer(keras.layers.Layer):

    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim
        super(MyLayer, self).__init__(**kwargs)
    
    def build(self, input_shape):
        shape = tf.TensorShape((input_shape[1], self.output_dim))
        # Create a trainable weight variable for this layer.
       self.kernel = self.add_weight(name='kernel',
                                    shape=shape,
                                    initializer='uniform',
                                    trainable=True)
    # Be sure to call this at the end
    super(MyLayer, self).build(input_shape)
    
    def call(self, inputs):
        return tf.matmul(inputs, self.kernel)
    
    def compute_output_shape(self, input_shape):
        shape = tf.TensorShape(input_shape).as_list()
        shape[-1] = self.output_dim
        return tf.TensorShape(shape)
    
    def get_config(self):
        base_config = super(MyLayer, self).get_config()
        base_config['output_dim'] = self.output_dim
        return base_config
    
    @classmethod
    def from_config(cls, config):
        return cls(**config)

# Create a model using the custom layer
model = keras.Sequential([MyLayer(10),
                          keras.layers.Activation('softmax')])

# 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, targets, batch_size=32, epochs=5)

回调（Callbacks）
回调是传递给模型的对象，用于在训练期间自定义和扩展其行为。您可以编写自己的自定义回调，或使用包含以下内置的tf.keras.callbacks：

tf.keras.callbacks.ModelCheckpoint：定期保存checkpoints。
tf.keras.callbacks.LearningRateScheduler：动态改变学习速率。
tf.keras.callbacks.EarlyStopping：当验证集上的性能不再提高时，终止训练。
tf.keras.callbacks.TensorBoard：使用TensorBoard 监测模型的行为。
要使用tf.keras.callbacks.Callback，请将其传递给模型的fit方法：
callbacks = [
    # Interrupt training if `val_loss` stops improving for over 2 epochs
    keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
    # Write TensorBoard logs to `./logs` directory
    keras.callbacks.TensorBoard(log_dir='./logs')
]
model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks,
            validation_data=(val_data, val_targets))

Save and restore
6.1 Weights only
使用 tf.keras.Model.save_weights 来保存和加载模型的 weights：

# Save weights to a TensorFlow Checkpoint file
model.save_weights('./my_model')

# Restore the model's state,
# this requires a model with the same architecture.
model.load_weights('my_model')

默认情况下，这会以 TensorFlow checkpoint 格式保存模型的 weights。weights 也可以保存为 HDF5 格式（Keras 默认的保存格式）：

# Save weights to a HDF5 file
model.save_weights('my_model.h5', save_format='h5')

# Restore the model's state
model.load_weights('my_model.h5')

6.2 Configuration only
一个模型的 configuration 可以被保存，序列化过程中不包含任何 weights。保存的 configuration 可以用来重新创建、初始化出相同的模型，即使没有模型原始的定义代码。Keras 支持 JSON，YAML 序列化格式：

# Serialize a model to JSON format
json_string = model.to_json()

# Recreate the model (freshly initialized)
fresh_model = keras.models.model_from_json(json_string)

# Serializes a model to YAML format
yaml_string = model.to_yaml()

# Recreate the model
fresh_model = keras.models.model_from_yaml(yaml_string)

注意：子类模型不可序列化，因为它们的体系结构由调用方法体中的Python代码定义。

6.3 Entire model
整个模型可以保存到包含权重值，模型配置甚至优化器配置的文件中。这允许您检查模型并稍后从完全相同的状态恢复训练 - 无需访问原始代码。

# Create a trivial model
model = keras.Sequential([
    keras.layers.Dense(10, activation='softmax', input_shape=(32,)),
    keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='rmsprop',
                loss='categorical_crossentropy',
                metrics=['accuracy'])
model.fit(data, targets, 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 = keras.models.load_model('my_model.h5')

Eager execution
Eager execution是一个必要的编程环境，可以立即评估操作。这对于Keras不是必需的，但是由tf.keras支持，对于检查程序和调试很有用。
tf.keras 里所有的模型构建 API 兼容 eager execution。并且，在编写 model subclassing 和 custom layers 时使用 eager execution
虽然可以使用Sequential和函数式API，但是eager execution尤其有利于模型子类化和构建自定义层 - 需要您将正向传递作为代码编写的API（而不是通过组合现有层来创建模型的API）。

请看 eager execution guide 里的例子：使用 Keras models with custom training loops and tf.GradientTape。

Distribution
8.1 Estimators
Estimators API 被用来在分布时环境训练模型。Estimator API 旨在大型数据集的分布式训练，该 API 能够导出工业生产可用的模型。

一个 tf.keras.Model 可以用 tf.estimator API 来训练（通过 tf.keras.estimator.model_to_estimator 将模型转为一个 tf.estimator.Estimator 对象）。详情见 Creating Estimators from Keras models。

model = keras.Sequential([layers.Dense(10,activation='softmax'),
                          layers.Dense(10,activation='softmax')])

model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

estimator = keras.estimator.model_to_estimator(model)

注意：可以通过开启 eager execution 来调试 Estimator input functions、检查数据。

8.2 Multiple GPUs
tf.keras 模型可以使用 tf.contrib.distribute.DistributionStrategy 在多个 GPU 上运行。此API在多个GPU上提供分布式培训，几乎不对现有代码进行任何更改。

当前，tf.contrib.distribute.MirroredStrategy 是唯一支持的分布式策略。MirroredStrategy 对图进行复制，以同步的方式训练，并且梯度最后聚集在一个机器上。为了使用 DistributionStrategy with Keras，首先用 tf.keras.estimator.model_to_estimator 将 tf.keras.Model 转化为一个 tf.estimator.Estimator，然后训练转化来的estimator。
以下示例在单个计算机上的多个GPU之间分发tf.keras.Model。
首先，定义一个简单的模型：

model = keras.Sequential()
model.add(keras.layers.Dense(16, activation='relu', input_shape=(10,)))
model.add(keras.layers.Dense(1, activation='sigmoid'))

optimizer = tf.train.GradientDescentOptimizer(0.2)

model.compile(loss='binary_crossentropy', optimizer=optimizer)
model.summary()

定义输入pipeline。 input_fn返回一个tf.data.Dataset对象，用于在多个设备之间分配数据 - 每个设备处理输入批处理的一部分。

def input_fn():
    x = np.random.random((1024, 10))
    y = np.random.randint(2, size=(1024, 1))
    x = tf.cast(x, tf.float32)
    dataset = tf.data.Dataset.from_tensor_slices((x, y))
    dataset = dataset.repeat(10)
    dataset = dataset.batch(32)
    return dataset

接下来，创建一个 tf.estimator.RunConfig 并设置 train_distribute 参数为 tf.contrib.distribute.MirroredStrategy 实例。当创建 MirroredStrategy 时，你可以指定一个设备列表或通过 num_gpus 参数设置 GPU 的数量。默认使用所有的 GPU。如下所示：

strategy = tf.contrib.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(train_distribute=strategy)
将 Keras model 转为一个 tf.estimator.Estimator 实例。

keras_estimator = keras.estimator.model_to_estimator(
keras_model=model,
config=config,
model_dir=’/tmp/model_dir’)
最后，通过提供input_fn和steps参数来训练Estimator实例：

keras_estimator.train(input_fn=input_fn, steps=10)

Keras框架中的epoch、bacth、batch size、iteration

1、epoch

Keras官方文档中给出的解释是：“简单说，epochs指的就是训练过程接中数据将被“轮”多少次”

（1）释义：

训练过程中当一个完整的数据集通过了神经网络一次并且返回了一次，这个过程称为一个epoch，网络会在每个epoch结束时报告关于模型学习进度的调试信息。

（2）为什么要训练多个epoch，即数据要被“轮”多次

在神经网络中传递完整的数据集一次是不够的，对于有限的数据集（是在批梯度下降情况下），使用一个迭代过程，更新权重一次或者说使用一个epoch是不够的，需要将完整的数据集在同样的神经网络中传递多次，随着epoch次数增加，神经网络中的权重的更新次数也增加，模型从欠拟合变得过拟合。

2、batch

（1）keras官方文档中给出的解释：

深度学习的优化算法，说白了就是梯度下降。每次的参数更新有两种方式：

第一种，遍历全部数据集算一次损失函数，然后算函数对各个参数的梯度，更新梯度。这种方法每更新一次参数都要把数据集里的所有样本都看一遍，计算量开销大，计算速度慢，不支持在线学习，这种称为Batch gradient descent,批梯度下降

另一种，每看一个数据就算一下损失函数，然后求梯度更新参数，这个称为随机梯度下降，stochastic gradient descent.这个方法速度比较快，但是收敛性能不太好，可能在最优点附近晃来晃去，hit不到最优点，两次参数的更新也有可能互相抵消掉，造成目标函数震荡的比较剧烈。

为了克服两种方法的缺点，现在一般采用的是一种折中手段，mini-batch gradient decent，小批的梯度下降，这种方法把数据分为若干个批，按批来更新参数，这样，一个批中的一组数据共同决定了本次梯度的方向，下降起来就不容易跑偏，减少了随机性。另一方面因为批的样本数与整个数据集相比小了很多，计算量也不是很大。

（2）batch_size:

Keras中参数更新是按批进行的，就是小批梯度下降算法，把数据分为若干组，称为batch，按批更新参数，这样，一个批中的一组数据共同决定了本次梯度的方向，一批数据中包含的样本数量称为batch_size。

3、iteration

将数据分为几个batch而不是一次性通过神经网络时，iteration是batch需要完成一个epoch的次数，也就是number of batches (区别于 batch size) ，在一次epoch中 number of batches = iteration = 训练样本总数 / batch size

比如，对于一个有2000个训练样本的数据集，将2000个样本分成大小为500的batch，那么完成一个epoch需要4个iteration

4、batch size 和 epoch 的选取

（1）训练网络过程中，一个batch中的样本规模大小，即batch size 和epoch个数一起通过影响更新权重的频率定义了网络学习数据的速度。

对于固定的epoch：

（a）在合理范围内，随着batch size增大，跑完一次epoch所需的迭代数减少，对于相同数据量的处理速度进一步加快，确定的下降方向越准，引起的训练震荡越小。

（b）batch size 过大时，跑完一次epoch所需的迭代数减少，想要达到相同的精度，所花费的时间大大增加了，从而对参数的修正也变得缓慢，batch size增大到一定程度，其确定的下降方向已经基本不再变化

对于固定的batch size:

（a）在合理范围内随着epoch的增加，训练集和测试集的误差呈下降趋势，模型的训练有了效果

（b）随着epoch的继续增加，训练集的误差呈下降而测试集的误差呈上升趋势，模型过拟合训练集对测试集性能不好

（2）实验实验，通过实验+经验选取合适的batch size 和 epoch

tf.keras.layers

tf.keras.layers.Dense 添加一个全连接层

tf.keras.layers.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,
  **kwargs
)

Arguments:

units: Positive integer, dimensionality of the output space.
activation: Activation function to use. If you don’t specify anything, no activation is applied (ie. “linear” activation: a(x) = x).
use_bias: Boolean, whether the layer uses a bias vector.
kernel_initializer: Initializer for the kernel weights matrix.
bias_initializer: Initializer for the bias vector.
kernel_regularizer: Regularizer function applied to the kernel weights matrix.
bias_regularizer: Regularizer function applied to the bias vector.
activity_regularizer: Regularizer function applied to the output of the layer (its “activation”)…
kernel_constraint: Constraint function applied to the kernel weights matrix.
bias_constraint: Constraint function applied to the bias vector.

Input shape:

N-D tensor with shape: (batch_size, ..., input_dim). The most common situation would be a 2D input with shape (batch_size, input_dim).

Output shape:

N-D tensor with shape: (batch_size, ..., units). For instance, for a 2D input with shape (batch_size, input_dim), the output would have shape (batch_size, units).

tf.keras.layers.Conv2D 添加一个卷积层

注意这里的 data_format 要为 “channels_last” 看下面的 input shape

tf.keras.layers.Conv2D(
    filters, kernel_size, strides=(1, 1), padding='valid', data_format=None,
    dilation_rate=(1, 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, **kwargs
)

Arguments:

filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution).
kernel_size: An integer or tuple/list of 2 integers, specifying the height and width of the 2D convolution window. Can be a single integer to specify the same value for all spatial dimensions.
strides: An integer or tuple/list of 2 integers, specifying the strides of the convolution along the height and width. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any dilation_rate value != 1.
padding: one of "valid" or "same" (case-insensitive).
data_format: A string, one of channels_last (default) or channels_first. The ordering of the dimensions in the inputs. channels_last corresponds to inputs with shape (batch, height, width, channels) while channels_first corresponds to inputs with shape (batch, channels, height, width). It defaults to the image_data_format value found in your Keras config file at ~/.keras/keras.json. If you never set it, then it will be “channels_last”.
dilation_rate: an integer or tuple/list of 2 integers, specifying the dilation rate to use for dilated convolution. Can be a single integer to specify the same value for all spatial dimensions. Currently, specifying any dilation_rate value != 1 is incompatible with specifying any stride value != 1.
activation: Activation function to use. If you don’t specify anything, no activation is applied (ie. “linear” activation: a(x) = x).
use_bias: Boolean, whether the layer uses a bias vector.
kernel_initializer: Initializer for the kernel weights matrix.
bias_initializer: Initializer for the bias vector.
kernel_regularizer: Regularizer function applied to the kernel weights matrix.
bias_regularizer: Regularizer function applied to the bias vector.
activity_regularizer: Regularizer function applied to the output of the layer (its “activation”)…
kernel_constraint: Constraint function applied to the kernel matrix.
bias_constraint: Constraint function applied to the bias vector.

Input shape:

4D tensor with shape: (samples, channels, rows, cols) if data_format=‘channels_first’ or 4D tensor with shape: (samples, rows, cols, channels) if data_format=‘channels_last’.

Output shape:

4D tensor with shape: (samples, filters, new_rows, new_cols) if data_format=‘channels_first’ or 4D tensor with shape: (samples, new_rows, new_cols, filters) if data_format=‘channels_last’. rows and cols values might have changed due to padding.

Tensorboard

model = keras.models.Sequential([
    keras.layers.Dense(32, activation='relu'),
])

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

# Define the Keras TensorBoard callback.
logdir = "C:\\Users\\windows\\Desktop\\save\\"
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

# Train the model.
model.fit(
    train_images,
    train_labels, 
    batch_size=64,
    epochs=5, 
    callbacks=[tensorboard_callback])

然后在 cmd 中

tensorboard --logdir C:\\Users\\windows\\Desktop\\save

然后打开 http://localhost:6006/

Object Localization

目标：输出一个概率，一个预选框

Othors

激活函数

第一，采用sigmoid等函数，算激活函数是（指数运算），计算量大；反向传播求误差梯度时，求导涉及除法，计算量相对大。而采用Relu激活函数，整个过程的计算量节省很多。
第二，对于深层网络，sigmoid函数反向传播时，很容易就会出现梯度消失的情况（在sigmoid接近饱和区时，变换太缓慢，导数趋于0），这种情况会造成信息丢失，梯度消失在网络层数多的时候尤其明显，从而无法完成深层网络的训练。
第三，ReLU会使一部分神经元的输出为0，这样就造成了网络的稀疏性，并且减少了参数的相互依存关系，缓解了过拟合问题的发生。

model.evaluate 和 model.predict 的区别

model.evaluate
输入数据和标签,输出损失和精确度.

# 评估模型,不输出预测结果
loss,accuracy = model.evaluate(X_test,Y_test)
print('\ntest loss',loss)
print('accuracy',accuracy)

model.predict
输入测试数据,输出预测结果
(通常用在需要得到预测结果的时候)

#模型预测,输入测试集,输出预测结果
y_pred = model.predict(X_test,batch_size = 1)

TODO

checkpoint model.save() keras.models.load_model() ✔

卷积层激活函数池化层全连接层

batch

minibatch

SGD 优化器

目标检测的损失函数 YOLO目标检测中损失函数loss的理解及部分代码实现

dropout

softmax

predict 和 evaluate 函数

卷积的滑动窗口实现 YOLO 算法

tensorboard

steps_per_epoch 与 epochs 的关系

dataset ✔

Keras.metrics中的accuracy总结

Keras 层layers总结

Keras（七）Keras.layers各种层介绍

使用回调函数及tensorboard实现网络训练实时监控

详解keras的model.summary()输出参数Param计算过程

Tensorboard 直方图Summary使用指南

TensorBoard必知必会的入门了解 https://cloud.tencent.com/developer/article/1441562


model.predict
输入测试数据,输出预测结果
(通常用在需要得到预测结果的时候)

```python
#模型预测,输入测试集,输出预测结果
y_pred = model.predict(X_test,batch_size = 1)