TensorFlow 2.0 教程01: 图像分类基础

 

TensorFlow 2现已上线！本教程将引导您完成使用深度学习构建简单的CIFAR-10图像分类器的过程。在本教程中，我们将：

  • 定义模型
  • 建立数据管道
  • 训练模型
  • 多个GPU加快训练速度
  • 添加callback以监视进度/更新学习进度

本教程中的代码可在此处获得。

 

定义模型

TensorFlow 2使用Keras作为其高级API。Keras提供了两种定义模型的方法：顺序API和功能API。

使用Keras序列API定义模型

from tf.keras.models import Sequential
from tf.keras.layers import Conv2, MaxPooling2D, Flatten, Dense


model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    MaxPooling2D(pool_size=(2, 2)),
    Flatten(),
    Dense(10, activation='softmax')
])

 

使用Keras的功能性API定义相同的模型

from tf.keras.models import Model
from tf.keras.layers import Input, Conv2, MaxPooling2D, Flatten, Dense


inputs = Input(shape=(32, 32, 3))
x = Conv2D(32, (3, 3), activation='relu')(inputs)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Flatten()(x)
x = Dense(10, activation='softmax')(x)
model = Model(inputs=inputs, outputs=x)

 

顺序API与功能API

这些API之间的主要区别在于，顺序API要求为其提供第一层input_shape，而功能性API要求为其提供第一层，tf.keras.layers.Input并且需要tf.keras.models.Model在最后调用构造函数。

顺序API更简洁，而功能性API更灵活，因为它允许模型为非顺序模型。例如，在ResNet中具有跳过连接。本教程改编了TensorFlow的ResNet的官方Keras实现，该实现使用了功能性API。

input_shape = (32, 32, 3)
img_input = Input(shape=input_shape)
model = resnet_cifar_model.resnet56(img_input, classes=10)

 

 

建立数据管道

现在，我们定义了一个模型。要训​​练该模型，我们需要一个数据管道来为其提供标记的训练数据。数据管道执行以下任务：

  • 加载：将数据集（例如图像和标签）从存储设备复制到程序的内存中。
  • 预处理：转换数据集。例如，在图像分类中，我们可能会调整图像的大小，变白，混洗或批处理。
  • 馈送：将示例从数据集中铲入训练循环。

 

从存储中加载数据

首先，我们将CIFAR-10从存储加载到numpy ndarrays：

(x, y), (x_test, y_test) = keras.datasets.cifar10.load_data()

注意：

  • 首次引用时keras.datasets.cifar10.load_data，CIFAR-10将从互联网上下载到~/.keras/datasets/cifar-10-batches-py.tar.gz.后续引用不涉及网络。
  • x 代表50,000张图像，尺寸为32 x 32 x 3（宽度，高度和三个RGB通道）。
  • y 代表这50,000张图片的标签。
 print(type(x), type(y))
(<type 'numpy.ndarray'>, <type 'numpy.ndarray'>)

 

print(x.shape, y.shape)
((50000, 32, 32, 3), (50000, 1))

从理论上讲，我们可以简单地将这些原始numpy.ndarray对象馈送到训练循环中，并将其称为数据管道。但是，为了获得更高的模型精度，我们需要对数据进行预处理（即在使用前对其进行某些转换）。为此，我们利用Tensorflow的Dataset类。

 

tf.data.Dataset类

TensorFlow数据集类主要用于两个目的：

  • 它充当保存训练数据的容器。
  • 它可用于对训练数据的元素进行更改。

我们实例化一个tensorflow.data.Dataset表示CIFAR-10数据集的对象，如下所示：

# Load data from storage to memory.
(x, y), (x_test, y_test) = keras.datasets.cifar10.load_data()


# Instantiate the Dataset class.
train_dataset = tf.data.Dataset.from_tensor_slices((x, y))

在training期间，train_dataset将通过take()迭代器访问存储在其中的CIFAR-10训练示例：

for image, label in train_dataset.take(1):
    (image.shape, label.shape)

 

照原样，我们不执行任何数据预处理。调用take()只是发出原始的CIFAR-10图片；前20张图片如下：

TensorFlow 2.0 教程01: 图像分类基础

资料扩充

增强通常用于“膨胀”训练数据集，这可以提高泛化性能。

让我们通过对每个图像执行以下步骤来扩充CIFAR-10数据集：

  1. 用黑色的四像素边框填充图像。
  2. 从填充的图像中随机裁剪32 x 32区域。
  3. 翻转硬币以确定是否应水平翻转图像。

为此，我们首先定义一个给定图像的函数，该函数执行上述步骤1-3：

def augmentation(x, y):
    x = tf.image.resize_with_crop_or_pad(
        x, HEIGHT + 8, WIDTH + 8)
    x = tf.image.random_crop(x, [HEIGHT, WIDTH, NUM_CHANNELS])
    x = tf.image.random_flip_left_right(x)
    return x, y

接下来，我们调用方法map；此调用返回一个新Dataset 对象，该对象包含将CIFAR-10中的每个图像传递到的结果augmentation。这个新对象将以原始顺序发出变换后的图像：

train_dataset = train_dataset.map(augmentation)

这些是增强后的前20张图像：

TensorFlow 2.0 教程01: 图像分类基础

注意：扩充只能应用于训练集；在推理过程中应用增强将导致不确定的预测和验证分数。

Shuffling(改组)

我们随机地对数据集进行洗牌。TensorFlow数据集具有一种shuffle方法，可以将其链接到我们的扩充，如下所示：

train_dataset = (train_dataset
                 .map(augmentation)
                 .shuffle(buffer_size=50000))

为了进行完美的混洗，的值buffer_size应大于或等于数据集的大小（在这种情况下为50,000）；对于大型数据集，这是不可能的。

改组后，以下是来自数据集的20张图像：

TensorFlow 2.0 教程01: 图像分类基础

 

Normalization(正常化)

规范化数据是常见的做法。在这里，定义一个线性缩放每个图像以具有零均值和单位方差的函数：

def normalize(x, y):
   x = tf.image.per_image_standardization(x)
   return x, y

接下来，我们将其与我们的扩充和混排操作链接起来：

train_dataset = (train_dataset
                 .map(augmentation)
                 .shuffle(buffer_size=50000)
                 .map(normalize))

Batching(批处理)

最后，我们batch是数据集。我们设置drop_remainder为True删除足够的训练示例，以使训练集的大小可被整除batch_size。

train_dataset = (train_dataset.map(augmentation)
                 .map(normalize)
                 .shuffle(50000)
                 .batch(128, drop_remainder=True)

现在，我们有了完整的数据管道。现在我们可以开始训练了。

 

训练模型

训练之前需要先编译Keras模型。编译本质上定义了三件事：损失函数，优化器和评估指标

model.compile(
      loss='sparse_categorical_crossentropy',
      optimizer=keras.optimizers.SGD(learning_rate=0.1, momentum=0.9),
      metrics=['accuracy'])

请注意，我们在此处使用sparse_categorical_crossentropy和sparse_categorical_accuracy，因为每个标签都由单个整数（类的索引）表示。每个人都应该使用categorical_crossentropy和categorical_accuracy如果一个热矢量表示每个标签。

Keras使用fitAPI训练模型。可以选择在每个validation_freq训练时期在验证数据集上测试模型。

请注意，我们仅将测试数据集用于验证，因为CIFAR-10本身并不提供验证集。模型的验证应在与训练集分离的一组数据上进行。

model.fit(train_dataset,
          epochs=60,
          validation_data=test_dataset,
          validation_freq=1)

请注意，在此示例中，该fit函数采用TensorFlow Dataset对象（train_dataset和test_dataset）。如前所述，它也可以将numpy ndarrays作为输入。使用数组的缺点是缺乏将变换应用于数据集的灵活性。

model.fit(x, y,
          batch_size=128, epochs=5, shuffle=True,
          validation_data=(x_test, y_test))

要评估模型，请evaluate使用测试数据集调用该方法：

model.evaluate(test_loader)

 

多GPU

到目前为止，我们已经展示了如何使用TensorFlow的Dataset API创建数据管道，以及如何使用Keras API定义模型并进行训练和评估。下一步是使代码在多个GPU上运行。

实际上，Tensorflow 2使将单GPU实现转换为可与多个GPU一起运行变得非常容易。您需要做的就是定义一个分发策略并在该策略的范围内创建模型：

mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
    model = resnet.resnet56(classes=NUM_CLASSES)
    model.compile(
      optimizer=keras.optimizers.SGD(learning_rate=0.1, momentum=0.9),
      loss='sparse_categorical_crossentropy',
      metrics=['accuracy'])

我们MirroredStrategy在这里使用，它在一台机器上支持在多个GPU上进行同步分布式训练。默认情况下，它使用NVIDIA NCCL作为多GPU全缩减实现。

请注意，您将要batch根据使用的GPU数量，使用数据管道的方法来缩放批处理大小。

train_loader = train_loader.map(preprocess).shuffle(50000).batch(BS_PER_GPU*NUM_GPUS)
test_loader = test_loader.map(preprocess).batch(BS_PER_GPU*NUM_GPUS)

 

Adding callbacks

我们经常需要在训练期间执行自定义操作。例如，您可能希望在训练期间记录统计信息，以进行调试或优化。实施学习率表，以提高训练效率；或在过滤器汇聚时保存它们的可视快照。在TensorFlow 2中，您可以在训练期间使用callback功能来实现自定义事件。

Tensorboard

TensorBoard主要用于在训练期间记录和可视化信息。这对于检查模型的性能非常方便。通过tensorflow.keras.callbacks.TensorBoardcallback函数提供Tensorboard支持：

from tensorflow.keras.callbacks import TensorBoard
log_dir="logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = TensorBoard(
log_dir=log_dir, update_freq='batch', histogram_freq=1)

model.fit(...,
callbacks=[tensorboard_callback])

在上面的示例中，我们首先创建一个TensorBoardcallback，记录每个训练步骤的数据（通过update_freq=batch），然后将此callback附加到fit函数。TensorFlow将生成tfevents文件，可以使用TensorBoard可视化。例如，这是训练过程中分类准确性的可视化（蓝色是训练准确性，红色是验证准确性）：

TensorFlow 2.0 教程01: 图像分类基础

 

 

Learning Rate Schedule

通常，随着训练的进行，我们希望对学习率有很好的控制。可以将自定义学习率进度表实现为callback函数。在这里，我们创建了一个自定义schedule函数，该函数使用步进函数（第30个时期和第45个时期）来降低学习率。此计划将转换为keras.callbacks.LearningRateScheduler并附加到该fit函数。

from tensorflow.keras.callbacks import LearningRateScheduler


BASE_LEARNING_RATE = 0.1
LR_SCHEDULE = [(0.1, 30), (0.01, 45)]


def schedule(epoch):
initial_learning_rate = BASE_LEARNING_RATE * BS_PER_GPU / 128
learning_rate = initial_learning_rate
for mult, start_epoch in LR_SCHEDULE:
if epoch >= start_epoch:
learning_rate = initial_learning_rate * mult
else:
break
tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
return learning_rate

lr_schedule_callback = LearningRateScheduler(schedule)


model.fit(...,
callbacks=[..., lr_schedule_callback])

这些是在60周期训练中自定义学习率的统计信息：

TensorFlow 2.0 教程01: 图像分类基础

 

总结

本教程以图像分类为例说明TensorFlow 2.0的基础。我们介绍了：

  • 使用TensorFlow 2的数据集API的数据管道
  • 使用Keras训练，评估，保存和还原模型（TensorFlow 2的官方高级API）
  • 具有分布式策略的多GPU
  • 带有callback的定制训练

以下是本教程的完整代码。您还可以使用此Tensorflow 2.0教程存储库复制有关TensorFlow 2.0的教程。

import datetime


import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.callbacks import TensorBoard, LearningRateScheduler


import resnet




NUM_GPUS = 2
BS_PER_GPU = 128
NUM_EPOCHS = 60


HEIGHT = 32
WIDTH = 32
NUM_CHANNELS = 3
NUM_CLASSES = 10
NUM_TRAIN_SAMPLES = 50000


BASE_LEARNING_RATE = 0.1
LR_SCHEDULE = [(0.1, 30), (0.01, 45)]




def preprocess(x, y):
x = tf.image.per_image_standardization(x)
return x, y




def augmentation(x, y):
x = tf.image.resize_with_crop_or_pad(
x, HEIGHT + 8, WIDTH + 8)
x = tf.image.random_crop(x, [HEIGHT, WIDTH, NUM_CHANNELS])
x = tf.image.random_flip_left_right(x)
return x, y




def schedule(epoch):
initial_learning_rate = BASE_LEARNING_RATE * BS_PER_GPU / 128
learning_rate = initial_learning_rate
for mult, start_epoch in LR_SCHEDULE:
if epoch >= start_epoch:
learning_rate = initial_learning_rate * mult
else:
break
tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
return learning_rate




(x,y), (x_test, y_test) = keras.datasets.cifar10.load_data()


train_dataset = tf.data.Dataset.from_tensor_slices((x,y))
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))


tf.random.set_seed(22)
train_dataset = train_dataset.map(augmentation).map(preprocess).shuffle(NUM_TRAIN_SAMPLES).batch(BS_PER_GPU * NUM_GPUS, drop_remainder=True)
test_dataset = test_dataset.map(preprocess).batch(BS_PER_GPU * NUM_GPUS, drop_remainder=True)


input_shape = (32, 32, 3)
img_input = tf.keras.layers.Input(shape=input_shape)
opt = keras.optimizers.SGD(learning_rate=0.1, momentum=0.9)


if NUM_GPUS == 1:
model = resnet.resnet56(img_input=img_input, classes=NUM_CLASSES)
model.compile(
optimizer=opt,
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'])
else:
mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
model = resnet.resnet56(img_input=img_input, classes=NUM_CLASSES)
model.compile(
optimizer=opt,
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'])


log_dir="logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(log_dir + "/metrics")
file_writer.set_as_default()
tensorboard_callback = TensorBoard(
log_dir=log_dir,
update_freq='batch',
histogram_freq=1)


lr_schedule_callback = LearningRateScheduler(schedule)


model.fit(train_dataset,
epochs=NUM_EPOCHS,
validation_data=test_dataset,
validation_freq=1,
callbacks=[tensorboard_callback, lr_schedule_callback])
model.evaluate(test_dataset)


model.save('model.h5')


new_model = keras.models.load_model('model.h5')

new_model.evaluate(test_dataset)

 

给大家介绍一下租用GPU做实验的方法，我们是在智星云租用的GPU，使用体验很好。具体大家可以参考：智星云官网： http://www.ai-galaxy.cn/，淘宝店：https://shop36573300.taobao.com/公众号: 智星AI，

        TensorFlow 2.0 教程01: 图像分类基础

 

 

参考文献：

https://lambdalabs.com/blog/tensorflow-2-0-tutorial-01-image-classification-basics/

https://github.com/lambdal/TensorFlow2-tutorial/tree/master/01-basic-image-classification

https://www.cs.toronto.edu/~kriz/cifar.html

相关文章：

  • 2021-12-13
  • 2021-05-24
  • 2021-06-17
  • 2021-10-17
  • 2021-09-01
  • 2022-12-23
  • 2021-12-31
  • 2021-10-14
猜你喜欢
  • 2022-01-11
  • 2021-12-03
  • 2022-12-23
  • 2022-03-10
  • 2021-12-28
  • 2021-12-03
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode