即将开播：5月20日，基于kubernetes打造企业级私有云实践

TensorFlow2.x在构建模型和总体使用方面提供了很多便利。那么，在tf中有什么新功能？

• 使用Keras轻松进行模型构建；
• 在任何平台上的生产中都可以进行稳健的模型部署；
• 强大的研究实验；
• 通过清理不推荐使用的API来简化各个步骤

在本文中，我们将探索TF 2.0的10个功能，这些功能让TensorFlow的使用更加顺畅，减少了代码行并提高了效率，因为这些函数/类属于TensorFlow API。

1.用于构建输入管道的tf.data API

tf.data API提供了用于数据管道和相关操作的功能。 我们可以构建管道，映射预处理功能，洗牌或批量处理数据集等等。

利用张量构建管道

>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]) 
>>> iter(dataset).next().numpy() 

8 

洗牌和批量处理数据集

# Shuffle 
>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]).shuffle(6) 
>>> iter(dataset).next().numpy() 

0 
# Batch 
>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]).batch(2) 
>>> iter(dataset).next().numpy() 
array([8, 3], dtype=int32) 
# Shuffle and Batch 
>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]).shuffle(6).batch(2) 
>>> iter(dataset).next().numpy() 
array([3, 0], dtype=int32) 

压缩两个数据集

>>> dataset0 = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]) 
>>> dataset1 = tf.data.Dataset.from_tensor_slices([1, 2, 3, 4, 5, 6]) 
>>> dataset = tf.data.Dataset.zip((dataset0, dataset1)) 
>>> iter(dataset).next() 
(<tf.Tensor: shape=(), dtype=int32, numpy=8>, <tf.Tensor: shape=(), dtype=int32, numpy=1>) 

映射外部函数

def into_2(num): 
     return num * 2 
>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]).map(into_2) 
>>> iter(dataset).next().numpy() 

16 

2.图像数据生成器

这是tensorflow.keras API的最佳特性之一（在我看来）。图像数据生成器能够在批处理和预处理过程中生成数据集切片，并实时进行数据扩充。

生成器允许直接从目录或数据帧进行数据流。

对图像数据生成器中的数据扩充的一个误解是，它向现有的数据集中添加了更多的数据。虽然这是数据增强的实际定义，但在图像数据生成器中，数据集中的图像在训练过程中会在不同的步骤进行动态转换，这样模型就可以在没有看到的噪声数据上进行训练。

train_datagen = ImageDataGenerator( 
        rescale=1./255, 
        shear_range=0.2, 
        zoom_range=0.2, 
        horizontal_flip=True 
) 

在这里，对所有样本进行重新缩放（用于规格化），而其他参数则用于扩充。

train_generator = train_datagen.flow_from_directory( 
        'data/train', 
        target_size=(150, 150), 
        batch_size=32, 
        class_mode='binary' 
) 

我们为实时数据流指定目录，这也可以使用数据帧来完成。

train_generator = flow_from_dataframe( 
    dataframe, 
    x_col='filename', 
    y_col='class', 
    class_mode='categorical', 
    batch_size=32 
) 

x_col参数定义图像的完整路径，而y_col参数定义用于分类的标签列。

该模型可直接与生成器供电。尽管需要指定steps_per_epoch参数，实际上是采样数/批量大小。

model.fit( 
    train_generator, 
    validation_data=val_generator, 
    epochs=EPOCHS, 
    steps_per_epoch=(num_samples // batch_size), 
    validation_steps=(num_val_samples // batch_size) 
) 

3.使用tf.image进行数据扩充

数据扩充是必要的， 在数据不足的情况下，对数据进行更改并将其视为单独的数据点是在较少数据下进行训练的一种非常有效的方法。

tf.image API具有用于转换图像的工具，以后可以通过前面讨论的tf.data API将其用于数据增强。

flipped = tf.image.flip_left_right(image) 
visualise(image, flipped) 

4.TensorFlow数据集

pip install tensorflow-datasets 

这是一个非常有用的库，因为它是转储来自Tensorflow收集的来自各个域的非常知名的数据集的唯一起点。

import tensorflow_datasets as tfds 
mnist_data = tfds.load("mnist") 
mnist_train, mnist_test = mnist_data["train"], mnist_data["test"] 

assert isinstance(mnist_train, tf.data.Dataset) 

tensorflow数据集可在下方链接中找到：

https://www.tensorflow.org/datasets/catalog/overview

音频，图像，图像分类，对象检测，结构化，摘要，文本，翻译，视频是tfds提供的类型。

5.基于预训练模型的迁移学习

迁移学习是机器学习中的一个新热点。如果一个基准模型已经被其他人训练过，那对于我们来说这个模型就不再适用，也不切实际。迁移学习解决了这个问题，预先训练的模型可以为给定的用例重新使用，也可以为不同的用例进行扩展。

TensorFlow提供了基准的预训练模型，可以很容易地扩展到所需的用例。

base_model = tf.keras.applications.MobileNetV2( 
    input_shape=IMG_SHAPE, 
    include_top=False, 
    weights='imagenet' 
) 

这个base_model可以轻松地通过附加层或不同模型进行扩展， 例如：

model = tf.keras.Sequential([ 
    base_model, 
    global_average_layer, 
    prediction_layer 
]) 

6.估算器

估算器是TensorFlow完整模型的高级表示，其设计目的是易于缩放和异步训练--TensorFlow文档

预制的估算器提供了非常高级的模型抽象，因此你可以直接专注于训练模型，而不必担心较低级别的复杂性。 例如：

linear_est = tf.estimator.LinearClassifier( 
    feature_columns=feature_columns 
) 
linear_est.train(train_input_fn) 
result = linear_est.evaluate(eval_input_fn) 

这表明使用tf.estimator构建和训练估算器非常容易， 估算器也可以自定义。

TensorFlow有许多预制的估算器，包括LinearRegressor，BoostedTreesClassifier等。可以去Tensorflow文档了解完整内容。

7.自定义层

对于许多层深层网络而言，神经网络是众所周知的，其中层可以是不同类型的。 TensorFlow包含许多预定义的层（例如Dense，LSTM等）。 但是对于更复杂的体系结构，层的逻辑要比主层复杂得多。 对于此类实例，TensorFlow允许构建自定义层。 这可以通过对tf.keras.layers.Layer类进行子类化来完成。

class CustomDense(tf.keras.layers.Layer): 
    def __init__(self, num_outputs): 
        super(CustomDense, self).__init__() 
        self.num_outputs = num_outputs 
 
    def build(self, input_shape): 
        self.kernel = self.add_weight( 
            "kernel", 
            shape=[int(input_shape[-1]), 
            self.num_outputs] 
        ) 
 
    def call(self, input): 
        return tf.matmul(input, self.kernel) 

如文档中所述，实现自己的层的最佳方法是扩展tf.keras.Layer类并实现：

• __init__，您可以在其中进行所有与输入无关的初始化。
• 构建，您可以在其中知道输入张量的形状，并可以进行其余的初始化。
• 调用，您可以在其中进行前向计算。

尽管可以在__init__本身中完成内核初始化，但最好在build中进行初始化，否则，你将必须在新图层创建的每个实例上显示指定input_shape。

8.定制化训练

tf.keras序列和模型API使训练模型更容易。 但是，大多数时候在训练复杂模型时会使用自定义损失函数。 此外，模型训练也可以与默认训练不同（例如，将梯度分别应用于不同的模型组件）。

TensorFlow的自动微分有助于以有效的方式计算梯度，这些原语用于定义自定义训练循环。

def train(model, inputs, outputs, learning_rate): 
    with tf.GradientTape() as t: 
        # Computing Losses from Model Prediction 
        current_loss = loss(outputs, model(inputs)) 
    # Gradients for Trainable Variables with Obtained Losses 
    dW, db = t.gradient(current_loss, [model.W, model.b]) 
    # Applying Gradients to Weights 
    model.W.assign_sub(learning_rate * dW) 
    model.b.assign_sub(learning_rate * db) 

可以针对多个时期重复此循环，并根据用例使用更自定义的设置。

9.检查点

保存TensorFlow模型可以有两种类型：

• SavedModel：保存模型的完整状态以及所有参数。 这与源代码无关。

model.save_weights（'checkpoint'） 

• 检查点

检查点捕获模型使用的所有参数的精确值。 使用Sequential API或Model API构建的模型可以简单地以SavedModel格式保存。

但是，对于自定义模型，需要检查点。

检查点不包含对模型定义的计算的任何描述，因此通常仅在将使用保存的参数值的源代码可用时才有用。

保存检查点

checkpoint_path = “save_path” 
# Defining a Checkpoint 
ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer) 
# Creating a CheckpointManager Object 
ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5) 
# Saving a Model 
ckpt_manager.save() 

从检查点加载

TensorFlow通过遍历具有命名边的有向图，从加载的对象开始，将变量与检查点值匹配。

10. Keras Tuner

这是TensorFlow中的一个相当新的功能。

!pip install keras-tuner 

超参数调整（Hyper parameter tuning，Hypertuning）是对定义ML模型配置的参数进行筛选的过程。这些因素是特征工程和预处理后模型性能的决定因素。

# model_builder is a function that builds a model and returns it 
tuner = kt.Hyperband( 
    model_builder, 
    objective='val_accuracy',  
    max_epochs=10, 
    factor=3, 
    directory='my_dir', 
    project_name='intro_to_kt' 
) 

除了hyperand之外，bayesianomptimization和RandomSearch也可用于调整。

tuner.search( 
    img_train, label_train,  
    epochs = 10,  
    validation_data=(img_test,label_test),  
    callbacks=[ClearTrainingOutput()] 
) 
 
# Get the optimal hyperparameters 
best_hps = tuner.get_best_hyperparameters(num_trials=1)[0] 

此外，我们使用最佳超参数训练模型：

model = tuner.hypermodel.build(best_hps) 
model.fit( 
    img_train,  
    label_train,  
    epochs=10,  
    validation_data=(img_test, label_test) 
) 

11.分布式训练

如果你有多个GPU并且希望通过在多个GPU上分散训练循环来优化训练，TensorFlow的各种分布式训练策略能够优化GPU的使用并为你操纵GPU上的训练。

MirroredStrategy是最常用的策略，它到底是怎么工作的？

1. 所有变量和模型图都复制到副本上。
2. 输入在副本中均匀分布。
3. 每个副本计算它接收到的输入的损失和梯度。
4. 通过对所有副本进行求和，可以同步这些渐变。
5. 同步之后，对每个副本上的变量副本进行相同的更新。

strategy = tf.distribute.MirroredStrategy() 
with strategy.scope(): 
    model = tf.keras.Sequential([ 
        tf.keras.layers.Conv2D( 
            32, 3, activation='relu',  input_shape=(28, 28, 1) 
        ), 
        tf.keras.layers.MaxPooling2D(), 
        tf.keras.layers.Flatten(), 
        tf.keras.layers.Dense(64, activation='relu'), 
        tf.keras.layers.Dense(10) 
    ]) 
 
    model.compile( 
        loss="sparse_categorical_crossentropy", 
        optimizer="adam", 
        metrics=['accuracy'] 
    ) 

总结