本文正在参与「金石计划 . 分割6万现金大奖」

前言

图画分割在医学成像、自动驾驶汽车和卫星成像等方面有很多应用，实质其实便是图画像素分类任务，也便是运用深度学习模型为输入图画的每个像素分配一个标签（或类）。

预备

本文的预备如下，运用 pip 装置如下配置：

  • pip install git+github.com/tensorflow/…
  • pip install tensorflow == 2.10.1
  • pip install tensorflow_datasets == 4.7.8
  • pip install ipython == 8.6.0
  • pip install matplotlib == 3.6.2

纲要

  1. 获取数据
  2. 处理数据
  3. 搭建模型
  4. 编译、练习模型
  5. 猜测

完结

1. 获取数据

（1）本文运用的数据集是 Oxford-IIIT Pet Dataset ,该数据集由 37 类宠物的图画组成，每个种类有 200 个图画（练习集和测验集各有 100 个），每个像素都会被划入以下三个类别之一：

  • 属于宠物的像素
  • 宠物边缘的像素
  • 其他方位的像素

（2）能够运用 TensorFlow 的内置函数从网络上下载本次运用的数据 oxford_iiit_pet ，一般会下载到本地目录 ：C:\Users\【用户目录】\tensorflow_datasets\oxford_iiit_pet 。

（3）dataset 中寄存是练习集和测验集这两个数据集，info 中寄存的是该数据的基本信息，如文件巨细，数据介绍等基本信息。

import tensorflow as tf
import tensorflow_datasets as tfds
from tensorflow_examples.models.pix2pix import pix2pix
from IPython.display import clear_output
import matplotlib.pyplot as plt
dataset, info = tfds.load('oxford_iiit_pet:3.*.*', with_info=True)

2. 处理数据

（1）normalize 函数主要是完结将图画色彩值被归一化到 [0,1] 规模，掩码像素的所属标签被标记为 {1, 2, 3}。为了方便后边的模型核算，将它们别离减去 1，得到的标签为：{0, 1, 2} 。

（2）load_image 函数主要是将每个图片的输入和掩码图片，运用指定的办法将其巨细调整为指定的 128×128 。

（3）从 dataset 中分理处练习集 train_images 和测验集 test_images 。

def normalize(input_image, input_mask):
    input_image = tf.cast(input_image, tf.float32) / 255.0
    input_mask -= 1
    return input_image, input_mask
def load_image(image):
    input_image = tf.image.resize(image['image'], (128, 128))
    input_mask = tf.image.resize(image['segmentation_mask'], (128, 128))
    input_image, input_mask = normalize(input_image, input_mask)
    return input_image, input_mask
train_images = dataset['train'].map(load_image, num_parallel_calls=tf.data.AUTOTUNE)
test_images = dataset['test'].map(load_image, num_parallel_calls=tf.data.AUTOTUNE)

（4）为了保证在加载数据的时候不会呈现 I/O 不会阻塞，咱们在从磁盘加载完数据之后，运用 cache 会将数据保存在内存中，保证在练习模型过程中数据的获取不会成为练习速度的瓶颈。假如说要保存的数据量太大，能够运用 cache 创建磁盘缓存提高数据的读取效率。另外咱们还运用 prefetch 在练习过程中能够并行执行数据的预获取。

TRAIN_LENGTH = info.splits['train'].num_examples
BATCH_SIZE = 32
BUFFER_SIZE = 1000
train_batches = (train_images.cache().shuffle(BUFFER_SIZE).batch(BATCH_SIZE).repeat().prefetch(buffer_size=tf.data.AUTOTUNE))
test_batches = test_images.batch(BATCH_SIZE)

（5）这儿的 display 函数主要是将每个样本的宠物图画、对应的掩码图画、猜测的掩码图画制作出来，在这儿咱们只随机挑选了一个样本进行显示。由于这儿还没有猜测的掩码图画，所以没有将其制作出来。

（6）咱们能够看到左边是一张宠物的生活照，右边是一张该宠物在照片中的轮廓线图，宠物的姿态所处的像素为紫色，宠物的轮廓边缘线的像素是黄色，背景的像素是墨绿色，这其实对应了图片中的像素会分红三个类别。

def display(display_list):
    plt.figure(figsize=(15, 15))
    title = ['Input Image', 'True Mask', 'Predicted Mask']
    for i in range(len(display_list)):
        plt.subplot(1, len(display_list), i+1)
        plt.title(title[i])
        plt.imshow(tf.keras.utils.array_to_img(display_list[i]))
        plt.axis('off')
    plt.show()
for images, masks in train_batches.take(1):
    sample_image, sample_mask = images[0], masks[0]
    display([sample_image, sample_mask])

Tensorflow2.10 完成图像分割任务

3. 搭建模型

（1）这儿运用的模型是修改后的 U-Net ，具体内容可看链接。U-Net 由编码器（下采样器）和解码器（上采样器）组成。为了学习稳健的特征并削减可练习参数的数量，请运用预练习模型 MobileNetV2 作为编码器。对于解码器，您将运用上采样块，该块已在 TensorFlow Examples 仓库的 pix2pix 示例中完结。

（2）如前所述，编码器是一个预练习的 MobileNetV2 模型。您将运用来自 tf.keras.applications 的模型。编码器由模型中中间层的特定输出组成。请注意，在练习过程中不会练习编码器。

（3）咱们这儿运用模型由两部分组成， 一个是编码器 down_stack（也便是下采样器），另一个是解码器 up_stack （也便是上采样器）。咱们这儿运用预练习的模型 MobileNetV2 作为编码器， MobileNetV2 模型能够直接从网络上下载到本地运用，运用它来进行图片的特征抽取，需求注意的是咱们这儿选取了模型中的若干中间层，将其作为模型的输出，并且在练习过程中咱们设置了不会去练习编码器模型中的权重。对于解码器，咱们运用现已在仓库完结了的 pix2pix 。

（4）咱们的 U-Net 网络接收的每张图片巨细为 [128, 128, 3] ，先通过模型进行下采样，然后核算上采样和 skip 的特征衔接，最后通过一层 Conv2DTranspose 输出一个巨细为 [batch_size, 128, 128, 3] 的向量成果。

base_model = tf.keras.applications.MobileNetV2(input_shape=[128, 128, 3], include_top=False)
layer_names = [ 'block_1_expand_relu', 'block_3_expand_relu', 'block_6_expand_relu', 'block_13_expand_relu', 'block_16_project']
base_model_outputs = [base_model.get_layer(name).output for name in layer_names]
down_stack = tf.keras.Model(inputs=base_model.input, outputs=base_model_outputs)
down_stack.trainable = False
up_stack = [  pix2pix.upsample(512, 3),  pix2pix.upsample(256, 3),   pix2pix.upsample(128, 3),   pix2pix.upsample(64, 3)]
def unet_model(output_channels:int):
    inputs = tf.keras.layers.Input(shape=[128, 128, 3])
    skips = down_stack(inputs)
    x = skips[-1]
    skips = reversed(skips[:-1])
    for up, skip in zip(up_stack, skips):
        x = up(x)
        concat = tf.keras.layers.Concatenate()
        x = concat([x, skip])
    last = tf.keras.layers.Conv2DTranspose( filters=output_channels, kernel_size=3, strides=2, padding='same')   
    x = last(x)
    return tf.keras.Model(inputs=inputs, outputs=x)

4. 编译、练习模型

（1）由于每个像素面临的是一个多类分类问题，所以咱们运用 SparseCategoricalCrossentropy 作为丢失函数，核算多分类问题的交叉熵，并将 from_logits 参数设置为 True，由于标签是用 0、1、2 三个整数表明。SparseCategoricalCrossentropy 函数中当 from_logits=true 时，会先对猜测值进行 Softmax 概率化，就无须在模型最后添加 Softmax 层，咱们只需求运用通过 Softmax 输出的小数和实在整数标签来核算丢失即可。reduction 默认设置为 auto 时，会对一个 batch 的样本丢失值求平均。

举例：

y_true = [0,1,2]
y_pred = [[0.2,0.5,0.3],[0.6,0.1,0.3],[0.4,0.4,0.2]]
运用函数成果：
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False,name='sparse_categorical_crossentropy')
loss_val = loss_fn(y_true,y_pred).numpy()
loss_val
1.840487
手动核算 SparseCategoricalCrossentropy 成果：
(-np.log(0.2)-np.log(0.1)-np.log(0.2))/3
 1.8404869726207487

（2）运用 Adam 作为优化器，运用 accuracy 作为评估指标。

OUTPUT_CLASSES = 3
EPOCHS = 20
VAL_SUBSPLITS = 5
STEPS_PER_EPOCH = TRAIN_LENGTH // BATCH_SIZE
VALIDATION_STEPS = info.splits['test'].num_examples//BATCH_SIZE//VAL_SUBSPLITS
model = unet_model(output_channels=OUTPUT_CLASSES)
model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),  metrics=['accuracy'])
model_history = model.fit(train_batches, epochs=EPOCHS, steps_per_epoch=STEPS_PER_EPOCH, validation_steps=VALIDATION_STEPS, validation_data=test_batches)

练习成果输出：

115/115 [==============================] - 110s 961ms/step - loss: 0.1126 - accuracy: 0.9473 - val_loss: 0.3694 - val_accuracy: 0.8897

5. 猜测

（1）运用 create_mask 咱们会将对该批次的第一张图片的猜测掩码图画进行展现，成果是一个巨细为 (128, 128, 1) 的向量，其实便是给出了该图片每个像素点的猜测标签。

（2）在这儿咱们运用了上面的一个样本 sample_image ，运用练习好的模型进行猜测，由于这儿的样本 sample_image 是的巨细是 (128, 128, 3) ，咱们的模型需求参加 batch_size 维度，所以在第一维扩展了一个维度，巨细变为 (1, 128, 128, 3) 才能输入模型。

（3）从制作的猜测掩码图画成果看，猜测宠物边界线现已相当清晰了，假如进一步调整模型成果和练习的迭代次数，作用会更加好。

def create_mask(pred_mask):
    pred_mask = tf.math.argmax(pred_mask, axis=-1)
    pred_mask = pred_mask[..., tf.newaxis]
    return pred_mask[0]
display([sample_image, sample_mask,  create_mask(model.predict(sample_image[tf.newaxis, ...]))])

Tensorflow2.10 完成图像分割任务