InceptionNet网络搭建（tensorflow，keras）

牛+马=我

已于 2022-04-09 18:31:00 修改

阅读量938

点赞数 2

文章标签： python tensorflow keras 卷积神经网络神经网络

于 2022-04-08 17:58:17 首次发布

本文链接：https://blog.csdn.net/qq_57780419/article/details/124047666

版权

InceptionNet网络搭建

网络结构及分析：

在这里插入图片描述
如上图，InceptionNet是由一个卷积层+四个Inception结构块+所有通道进行平均池化的池化层+Dense层组成
四个Inception结构块的上面两个组成一个block，下面两个组成一个block
block中的第一个Inception结构块卷积步长是2
第二个Inception结构块卷积步长是1

Inception结构块的结构
在这里插入图片描述
输入经过四路进入卷积连接器（Filter concatenation)
上图中的Inception结构块的每一个卷积层都是执行的CBA操作，如

所以可将CBA操作封装到一个类ConvBNRelu中：

class ConvBNRelu(Model):
    def __init__(self, ch, kernelsz=3, strides=1, padding='same'):  # ch是卷积核个数，kernelsz是卷积核尺寸，strides是步长
        super(ConvBNRelu, self).__init__()
        # 将Conv2D，BatchNormalization，Activation封装到一个model里面
        self.model = tf.keras.models.Sequential([
            Conv2D(ch, kernelsz, strides=strides, padding=padding),
            BatchNormalization(),
            Activation('relu')
        ])

    def call(self, x):
        x = self.model(x, training=False) #在training=False时，BN通过整个训练集计算均值、方差去做批归一化，training=True时，通过当前batch的均值、方差去做批归一化。推理时 training=False效果好
        return x

有了ConvBNRelu，可以方便的搭建出Inception结构块：

class InceptionBlk(Model):
    def __init__(self, ch, strides=1):
        super(InceptionBlk, self).__init__()
        self.ch = ch
        self.strides = strides
        # c1是Inception结构块的第一个分支，使用一次ConvBNRelu
        self.c1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        # c2_1,c2_2是Inception结构块的第二个分支，使用两次ConvBNRelu
        self.c2_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        self.c2_2 = ConvBNRelu(ch, kernelsz=3, strides=1)
        self.c3_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        self.c3_2 = ConvBNRelu(ch, kernelsz=5, strides=1)
        # 第四个分支先池化，再卷积
        self.p4_1 = MaxPool2D(3, strides=1, padding='same')
        self.c4_2 = ConvBNRelu(ch, kernelsz=1, strides=strides)

    def call(self, x):
        x1 = self.c1(x)
        x2_1 = self.c2_1(x)
        x2_2 = self.c2_2(x2_1)
        x3_1 = self.c3_1(x)
        x3_2 = self.c3_2(x3_1)
        x4_1 = self.p4_1(x)
        x4_2 = self.c4_2(x4_1)
        # x1, x2_2, x3_2, x4_2是四个分支的输出，使用tf.concat函数将这四个沿深度方向堆叠在一起
        x = tf.concat([x1, x2_2, x3_2, x4_2], axis=3)
        return x

有了Inception结构块，便可以搭建出InceptionNet了：

class Inception10(Model):
    def __init__(self, num_blocks, num_classes, init_ch=16, **kwargs):
        super(Inception10, self).__init__(**kwargs)
        self.in_channels = init_ch
        self.out_channels = init_ch
        self.num_blocks = num_blocks
        self.init_ch = init_ch
        # 第一层是一个只有CBA操作的卷积层，可以直接调用ConvBNRelu
        self.c1 = ConvBNRelu(init_ch)
        self.blocks = tf.keras.models.Sequential()
        # 外层循环是循环两个block
        for block_id in range(num_blocks):
            # 内层循环是循环一个block里面的两个Incption结构块，第一个结构块的卷积步长是2，第二个结构块的卷积步长是1
            for layer_id in range(2):
                if layer_id == 0:
                    block = InceptionBlk(self.out_channels, strides=2)
                else:
                    block = InceptionBlk(self.out_channels, strides=1)
                self.blocks.add(block)
            # enlarger out_channels per block
            # 第一个结构块的卷积步长是2，这使得第一个Inception结构块输出特征图尺寸减半，因此把输出特征图深度加深，尽可能保证特征抽取中信息的承载量一致
            self.out_channels *= 2
        self.p1 = GlobalAveragePooling2D()
        self.f1 = Dense(num_classes, activation='softmax')

    def call(self, x):
        x = self.c1(x)
        x = self.blocks(x)
        x = self.p1(x)
        y = self.f1(x)
        return y


model = Inception10(num_blocks=2, num_classes=10)  # 实例化，指定block是2，这个问题是10分类的

将以上三块代码合起来即是InceptionNet的网络结构
如果GPU性能较好，可以把batch_size从32改为128，512，1024等，增加一次性喂入神经网络的数据，以增加运算速度

整体代码：

以下以cifar10数据集为例进行演示
（cifar10数据集有5万张32*32像素点的彩色图片，用于训练
有1万张32*32像素点的彩色图片，用于测试）

cifar10 = tf.keras.datasets.cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0


class ConvBNRelu(Model):
    def __init__(self, ch, kernelsz=3, strides=1, padding='same'):  # ch是卷积核个数，kernelsz是卷积核尺寸，strides是步长
        super(ConvBNRelu, self).__init__()
        # 将Conv2D，BatchNormalization，Activation封装到一个model里面
        self.model = tf.keras.models.Sequential([
            Conv2D(ch, kernelsz, strides=strides, padding=padding),
            BatchNormalization(),
            Activation('relu')
        ])

    def call(self, x):
        x = self.model(x, training=False) #在training=False时，BN通过整个训练集计算均值、方差去做批归一化，training=True时，通过当前batch的均值、方差去做批归一化。推理时 training=False效果好
        return x


class InceptionBlk(Model):
    def __init__(self, ch, strides=1):
        super(InceptionBlk, self).__init__()
        self.ch = ch
        self.strides = strides
        # c1是Inception结构块的第一个分支，使用一次ConvBNRelu
        self.c1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        # c2_1,c2_2是Inception结构块的第二个分支，使用两次ConvBNRelu
        self.c2_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        self.c2_2 = ConvBNRelu(ch, kernelsz=3, strides=1)
        self.c3_1 = ConvBNRelu(ch, kernelsz=1, strides=strides)
        self.c3_2 = ConvBNRelu(ch, kernelsz=5, strides=1)
        # 第四个分支先池化，再卷积
        self.p4_1 = MaxPool2D(3, strides=1, padding='same')
        self.c4_2 = ConvBNRelu(ch, kernelsz=1, strides=strides)

    def call(self, x):
        x1 = self.c1(x)
        x2_1 = self.c2_1(x)
        x2_2 = self.c2_2(x2_1)
        x3_1 = self.c3_1(x)
        x3_2 = self.c3_2(x3_1)
        x4_1 = self.p4_1(x)
        x4_2 = self.c4_2(x4_1)
        # x1, x2_2, x3_2, x4_2是四个分支的输出，使用tf.concat函数将这四个沿深度方向堆叠在一起
        x = tf.concat([x1, x2_2, x3_2, x4_2], axis=3)
        return x


class Inception10(Model):
    def __init__(self, num_blocks, num_classes, init_ch=16, **kwargs):
        super(Inception10, self).__init__(**kwargs)
        self.in_channels = init_ch
        self.out_channels = init_ch
        self.num_blocks = num_blocks
        self.init_ch = init_ch
        # 第一层是一个只有CBA操作的卷积层，可以直接调用ConvBNRelu
        self.c1 = ConvBNRelu(init_ch)
        self.blocks = tf.keras.models.Sequential()
        # 外层循环是循环两个block
        for block_id in range(num_blocks):
            # 内层循环是循环一个block里面的两个Incption结构块，第一个结构块的卷积步长是2，第二个结构块的卷积步长是1
            for layer_id in range(2):
                if layer_id == 0:
                    block = InceptionBlk(self.out_channels, strides=2)
                else:
                    block = InceptionBlk(self.out_channels, strides=1)
                self.blocks.add(block)
            # enlarger out_channels per block
            # 第一个结构块的卷积步长是2，这使得第一个Inception结构块输出特征图尺寸减半，因此把输出特征图深度加深，尽可能保证特征抽取中信息的承载量一致
            self.out_channels *= 2
        self.p1 = GlobalAveragePooling2D()
        self.f1 = Dense(num_classes, activation='softmax')

    def call(self, x):
        x = self.c1(x)
        x = self.blocks(x)
        x = self.p1(x)
        y = self.f1(x)
        return y


model = Inception10(num_blocks=2, num_classes=10)  # 实例化，指定block是2，这个问题是10分类的

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])


###############################################    show   ###############################################

# 显示训练集和验证集的acc和loss曲线
plt.subplot(1, 2, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()