SegNet

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 2.8k | 阅读时长 ≈ 13
SegNet

SegNet

背景介绍

  SegNet:由剑桥大学提出，2015年被提交到CVPR，但是最后没有发表，反而在2017年发表在TPAMI上。是一种简单高效的语义分割模型。

SegNet

SegNet特点

  网络分为两个部分，**编码(Encoder)和解码(Decoder)，结构简单，网络易于实现
  使用了Maxpooling-Indices(最大池化索引)**来进行图像分辨率的提高，而不是采用上采样或者反卷积。

Maxpooling-Indices(最大池化索引)与Upsampling(上采样)和Deconvolution(反卷积)之间的区别

  Maxpooling-Indices(最大池化索引)：又称为Unpooling(反池化)，池化后记录最大值所在的位置，在反池化的过程中，给相应位置上写入值，其他位置为0。这个方法没有参数，但是这个方法并不常用，因为存在大量的稀疏数据，使模型收敛速度大大降低。
  Upsampling(上采样)：将输入resize到设置大小，然后利用指定的插值方法对周围的值进行插值，常用最近邻插值和双线性插值。因为相邻区域的像素和特征应该是相似的，因此这个方法特别常用，既没有参数，也不会存在稀疏数据。
  Deconvolution(反卷积)：本质是卷积，注意反卷积并不能从卷积的结果返回到卷积前的数据，只能返回到卷积前的尺寸。卷积通过设置kernel_size卷积核大小，strides步长和padding填充方式可以将图像的分辨率降低，相反的反卷积可以通过设置kernel_size卷积核大小，strides步长和padding填充方式先对数据进行填充，然后再进行卷积操作，可以将图像的分辨率增加。**这个方法不推荐经常使用，因为存在大量参数，而且可能会存在棋盘格效应，可以参考棋盘格可视化**。
SegNet

SegNet图像分析

SegNet

TensorFlow2.0实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
from functools import reduce
import tensorflow as tf
import tensorflow.keras as keras
import numpy as np


def compose(*funcs):
    if funcs:
        return reduce(lambda f, g: lambda *a, **kw: g(f(*a, **kw)), funcs)
    else:
        raise ValueError('Composition of empty sequence not supported.')


class Indices_Maxpool(keras.layers.Layer):
    def __init__(self, name):
        super(Indices_Maxpool, self).__init__(name=name)

    def call(self, inputs, **kwargs):

        val, index = inputs
        input_size = index.shape
        output_size = [x * 2 if i == 0 or i == 1 else x for i, x in enumerate(input_size[1:])]
        output = tf.reshape(tf.scatter_nd(tf.reshape(index, (-1, 1)), tf.reshape(val, (-1,)), (batch_size * np.prod(output_size),)), [-1] + output_size)

        return output


class Convs(keras.layers.Layer):
    def __init__(self, filters, name):
        super(Convs, self).__init__(name=name)
        self.blocks = keras.Sequential()
        self.blocks.add(keras.layers.Conv2D(filters, (3, 3), (1, 1), padding='same'))
        self.blocks.add(keras.layers.BatchNormalization())
        self.blocks.add(keras.layers.ReLU())

    def call(self, inputs, **kwargs):
        output = self.blocks(inputs)

        return output


def segnet(input_shape):

    input_tensor = keras.layers.Input(shape=input_shape, batch_size=batch_size, name='input')
    x = input_tensor

    x1 = compose(Convs(64, name='encoder_conv1_1'),
                 Convs(64, name='encoder_conv1_2'))(x)
    val_1, index_1 = tf.nn.max_pool_with_argmax(x1, (2, 2), (2, 2), 'VALID', name='maxpool1')
    x2 = compose(Convs(128, name='encoder_conv2_1'),
                 Convs(128, name='encoder_conv2_2'))(val_1)
    val_2, index_2 = tf.nn.max_pool_with_argmax(x2, (2, 2), (2, 2), 'VALID', name='maxpool2')
    x3 = compose(Convs(256, name='encoder_conv3_1'),
                 Convs(256, name='encoder_conv3_2'),
                 Convs(256, name='encoder_conv3_3'))(val_2)
    val_3, index_3 = tf.nn.max_pool_with_argmax(x3, (2, 2), (2, 2), 'VALID', name='maxpool3')
    x4 = compose(Convs(512, name='encoder_conv4_1'),
                 Convs(512, name='encoder_conv4_2'),
                 Convs(512, name='encoder_conv4_3'))(val_3)
    val_4, index_4 = tf.nn.max_pool_with_argmax(x4, (2, 2), (2, 2), 'VALID', name='maxpool4')
    x5 = compose(Convs(512, name='encoder_conv5_1'),
                 Convs(512, name='encoder_conv5_2'),
                 Convs(512, name='encoder_conv5_3'))(val_4)
    val_5, index_5 = tf.nn.max_pool_with_argmax(x5, (2, 2), (2, 2), 'VALID', name='maxpool5')

    indices_maxpool5 = Indices_Maxpool(name='indices_maxpool5')([val_5, index_5])
    y5 = compose(Convs(512, name='decoder_conv5_1'),
                 Convs(512, name='decoder_conv5_2'),
                 Convs(512, name='decoder_conv5_3'))(indices_maxpool5)
    indices_maxpool4 = Indices_Maxpool(name='indices_maxpool4')([y5, index_4])
    y4 = compose(Convs(512, name='decoder_conv4_1'),
                 Convs(512, name='decoder_conv4_2'),
                 Convs(256, name='decoder_conv4_3'))(indices_maxpool4)
    indices_maxpool3 = Indices_Maxpool(name='indices_maxpool3')([y4, index_3])
    y3 = compose(Convs(256, name='decoder_conv3_1'),
                 Convs(256, name='decoder_conv3_2'),
                 Convs(128, name='decoder_conv3_3'))(indices_maxpool3)
    indices_maxpool2 = Indices_Maxpool(name='indices_maxpool2')([y3, index_2])
    y2 = compose(Convs(128, name='decoder_conv2_1'),
                 Convs(64, name='decoder_conv2_2'))(indices_maxpool2)
    indices_maxpool1 = Indices_Maxpool(name='indices_maxpool1')([y2, index_1])
    y1 = compose(Convs(64, name='decoder_conv1_1'),
                 Convs(21, name='decoder_conv1_2'))(indices_maxpool1)

    output = keras.layers.Softmax(name='softmax')(y1)

    model = keras.Model(input_tensor, output, name='SegNet')

    return model


if __name__ == '__main__':

    batch_size = 16
    model = segnet(input_shape=(512, 512, 3))
    model.build(input_shape=(512, 512, 3))
    model.summary()

SegNet

Shape数据集完整实战

文件路径关系说明

  • project
    • shape
      • train_imgs(训练集图像文件夹)
      • train_mask(训练集掩模文件夹)
      • test_imgs(测试集图像文件夹)
    • SegNet_weight(模型权重文件夹)
    • SegNet_test_result(测试集结果文件夹)
    • SegNet.py

实战步骤说明

  1. 语义分割实战运行较为简单，因为它的输入的训练数据为图像，输入的标签数据也是图像，首先要对输入的标签数据进行编码，转换为类别信息，要和网络的输出维度相匹配，从(batch_size, height, width, 1)转换为(batch_size, height, width, num_class + 1)，某个像素点为哪一个类别，则在该通道上置1，其余通道置0。即神经网络的输入大小为(batch_size, height, width, 3)，输出大小为(batch_size, height, width, num_class + 1)。
  2. 设计损失函数，简单情况设置交叉熵损失函数即可达到较好效果。
  3. 搭建神经网络，设置合适参数，进行训练。
  4. 预测时，需要根据神经网络的输出进行逆向解码(编码的反过程)，寻找每一个像素点，哪一个通道上值最大则归为哪一个类别，即可完成实战的过程。

小技巧

  1. 设置的图像类别数为实际类别数+1，1代表背景类别，此数据集为3类，最后的通道数为4，每一个通道预测一类物体。在通道方向求Softmax，并且求出最大的索引，索引为0则代表背景，索引为1则代表圆形，索引为2则代表三角形，索引为3则代表正方形。
  2. 最大池化收敛速度较慢，因此换成上采样，不但可以使模型更加简单，而且可以加快网络的收敛速度。
  3. 设置了权重的保存方式，学习率的下降方式和早停方式。
  4. 使用yield关键字，产生可迭代对象，不用将所有的数据都保存下来，大大节约内存。
  5. 其中将1000个数据，分成800个训练集，100个验证集和100个测试集，小伙伴们可以自行修改。
  6. 注意其中的一些维度变换和numpy，tensorflow常用操作，否则在阅读代码时可能会产生一些困难。
  7. SegNet的特征提取网络(编码网络)类似于VGG，小伙伴们可以参考特征提取网络部分内容，选择其他的网络进行特征提取，比较不同网络参数量，运行速度，最终结果之间的差异。
  8. 图像输入可以先将其归一化到0-1之间或者-1-1之间，因为网络的参数一般都比较小，所以归一化后计算方便，收敛较快。
  9. 实际的工程应用中，常常还需要对数据集进行大小调整和增强，在这里为了简单起见，没有进行复杂的操作，小伙伴们应用中要记得根据自己的需要，对图像进行resize或者padding，然后旋转，对比度增强，仿射运算等等操作，增加模型的鲁棒性，并且实际中的图像不一定按照顺序命名的，因此应用中也要注意图像读取的文件名。

完整实战代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
import os
from functools import reduce
import numpy as np
import cv2 as cv
import tensorflow as tf
import tensorflow.keras as keras


def compose(*funcs):
    if funcs:
        return reduce(lambda f, g: lambda *a, **kw: g(f(*a, **kw)), funcs)
    else:
        raise ValueError('Composition of empty sequence not supported.')


class Convs(keras.layers.Layer):
    def __init__(self, filters, name):
        super(Convs, self).__init__(name=name)
        self.blocks = keras.Sequential()
        self.blocks.add(keras.layers.Conv2D(filters, (3, 3), (1, 1), padding='same'))
        self.blocks.add(keras.layers.BatchNormalization())
        self.blocks.add(keras.layers.ReLU())

    def call(self, inputs, **kwargs):
        output = self.blocks(inputs)

        return output


def small_segnet(input_shape):

    input_tensor = keras.layers.Input(shape=input_shape, name='input')
    x = input_tensor

    x1 = compose(Convs(32, name='encoder_conv1_1'),
                 Convs(32, name='encoder_conv1_2'),
                 keras.layers.MaxPool2D((2, 2), name='encoder_maxpool1'))(x)
    x2 = compose(Convs(64, name='encoder_conv2_1'),
                 Convs(64, name='encoder_conv2_2'),
                 keras.layers.MaxPool2D((2, 2), name='encoder_maxpool2'))(x1)
    x3 = compose(Convs(128, name='encoder_conv3_1'),
                 Convs(128, name='encoder_conv3_2'),
                 keras.layers.MaxPool2D((2, 2), name='encoder_maxpool3'))(x2)
    x4 = compose(Convs(256, name='encoder_conv4_1'),
                 Convs(256, name='encoder_conv4_2'),
                 keras.layers.MaxPool2D((2, 2), name='encoder_maxpool4'))(x3)

    y4 = compose(Convs(256, name='decoder_conv4_1'),
                 Convs(256, name='decoder_conv4_2'),
                 keras.layers.UpSampling2D((2, 2), name='decoder_upsampling4'))(x4)
    y3 = compose(Convs(128, name='decoder_conv3_1'),
                 Convs(128, name='decoder_conv3_2'),
                 keras.layers.UpSampling2D((2, 2), name='decoder_upsampling3'))(y4)
    y2 = compose(Convs(64, name='decoder_conv2_1'),
                 Convs(64, name='decoder_conv2_2'),
                 keras.layers.UpSampling2D((2, 2), name='decoder_upsampling2'))(y3)
    y1 = compose(Convs(32, name='decoder_conv1_1'),
                 Convs(32, name='decoder_conv1_2'),
                 keras.layers.UpSampling2D((2, 2), name='decoder_upsampling1'))(y2)

    output = keras.layers.Conv2D(num_class, (3, 3), (1, 1), 'same', activation='softmax', name='conv_softmax')(y1)

    model = keras.Model(input_tensor, output, name='Small_SegNet')

    return model


def generate_arrays_from_file(train_data, batch_size):
    # 获取总长度
    n = len(train_data)
    i = 0
    while 1:
        X_train = []
        Y_train = []
        # 获取一个batch_size大小的数据
        for _ in range(batch_size):
            if i == 0:
                np.random.shuffle(train_data)
            # 从文件中读取图像
            img = cv.imread(imgs_path + '\\' + str(train_data[i]) + '.jpg')
            img = img / 127.5 - 1
            X_train.append(img)

            # 从文件中读取图像
            img = cv.imread(mask_path + '\\' + str(train_data[i]) + '.png')
            seg_labels = np.zeros((img_size[0], img_size[1], num_class))
            for c in range(num_class):
                seg_labels[:, :, c] = (img[:, :, 0] == c).astype(int)
            Y_train.append(seg_labels)

            # 读完一个周期后重新开始
            i = (i + 1) % n
        yield tf.constant(X_train), tf.constant(Y_train)


if __name__ == '__main__':
    # 包括背景
    num_class = 4
    train_data = list(range(800))
    validation_data = list(range(800, 900))
    test_data = range(900, 1000)
    epochs = 50
    batch_size = 16
    tf.random.set_seed(22)
    img_size = (128, 128)
    colors = [[0, 0, 0], [0, 0, 128], [0, 128, 0], [128, 0, 0]]

    mask_path = r'.\shape\train_mask'
    imgs_path = r'.\shape\train_imgs'
    test_path = r'.\shape\test_imgs'
    save_path = r'.\SegNet_test_result'
    weight_path = r'.\SegNet_weight'

    try:
        os.mkdir(save_path)
    except FileExistsError:
        print(save_path + 'has been exist')

    try:
        os.mkdir(weight_path)
    except FileExistsError:
        print(weight_path + 'has been exist')

    model = small_segnet(input_shape=(img_size[0], img_size[1], 3))
    model.build(input_shape=(None, img_size[0], img_size[1], 3))
    model.summary()

    optimizor = keras.optimizers.Adam(lr=1e-3)
    lossor = keras.losses.BinaryCrossentropy()

    model.compile(optimizer=optimizor, loss=lossor, metrics=['accuracy'])

    # 保存的方式，3世代保存一次
    checkpoint_period = keras.callbacks.ModelCheckpoint(
        weight_path + '\\' + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5',
        monitor='val_loss',
        save_weights_only=True,
        save_best_only=True,
        period=3
    )

    # 学习率下降的方式，val_loss3次不下降就下降学习率继续训练
    reduce_lr = keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.5,
        patience=3,
        verbose=1
    )

    # 是否需要早停，当val_loss一直不下降的时候意味着模型基本训练完毕，可以停止
    early_stopping = keras.callbacks.EarlyStopping(
        monitor='val_loss',
        min_delta=0,
        patience=10,
        verbose=1
    )

    model.fit_generator(generate_arrays_from_file(train_data, batch_size),
                        steps_per_epoch=max(1, len(train_data) // batch_size),
                        validation_data=generate_arrays_from_file(validation_data, batch_size),
                        validation_steps=max(1, len(validation_data) // batch_size),
                        epochs=epochs,
                        callbacks=[checkpoint_period, reduce_lr, early_stopping])

    for name in test_data:
        test_img_path = test_path + '\\' + str(name) + '.jpg'
        save_img_path = save_path + '\\' + str(name) + '.png'
        test_img = cv.imread(test_img_path)
        test_img = tf.constant([test_img / 127.5 - 1])
        test_mask = model.predict(test_img)
        test_mask = np.reshape(test_mask, (img_size[0], img_size[1], num_class))
        test_mask = np.argmax(test_mask, axis=-1)
        seg_img = np.zeros((img_size[0], img_size[1], 3))
        for c in range(num_class):
            seg_img[:, :, 0] += ((test_mask == c) * (colors[c][0]))
            seg_img[:, :, 1] += ((test_mask == c) * (colors[c][1]))
            seg_img[:, :, 2] += ((test_mask == c) * (colors[c][2]))
        seg_img = seg_img.astype(np.uint8)
        cv.imwrite(save_img_path, seg_img)

模型运行结果

SegNet

SegNet小结

  SegNet是一种简单的语义分割网络，从上图可以看出SegNet模型的参数量只有29M，虽然现在SegNet网络不是最好的语义分割网络，但是其编码解码结构的思想，对后面的深度学习网络的发展有重要的影响。

-------------本文结束感谢您的阅读-------------
0%