InceptionNet10详细原理（含tensorflow版源码）

InceptionNet10原理

        InceptionNet10是基于谷歌团队在2014年提出的Inception网络的一个简化版本，也称为Mini-Inception。Inception网络是一种卷积神经网络模型，它通过模块化的方式来提高网络的深度和宽度，从而在图像分类、目标检测等计算机视觉任务中取得了优异的表现。

        InceptionNet10模型的设计基于InceptionV1模型，其主要特点是采用了多个不同尺寸的卷积核和池化核，并通过1x1的卷积核来减少特征图的维度和参数数量。这种设计可以提高特征提取的效率和准确性，并且减少了网络的计算量和存储空间。InceptionNet10模型的结构如下所示：

• 输入层：接受大小为224x224的RGB图像。
• 卷积层：共3个卷积层，分别使用不同的卷积核尺寸和数量来提取图像特征。
• 池化层：共2个池化层，使用不同的池化核尺寸和步长来减少特征图的大小。
• Inception模块：共2个Inception模块，每个模块包含多个不同尺寸的卷积核和池化核，以及1x1的卷积层来减少维度和参数数量。
• 全局平均池化层：对特征图进行全局平均池化，将特征图转化为一维向量。
• 全连接层：包含一个大小为1000的全连接层，用于分类输出。
• 输出层：使用softmax激活函数，生成1000个类别的概率分布。
• 
• 

 上图内容可以看到，有一个3x3卷积、两个block、每个block里面有两个小block（第一个小block的步长为2）、平均池化后全连接。

        InceptionNet10模型的训练过程通常采用基于随机梯度下降（Stochastic Gradient Descent，SGD）的反向传播算法，通过最小化交叉熵损失函数来优化模型参数。在训练过程中，可以使用数据增强、正则化、dropout等技术来提高模型的泛化能力和鲁棒性。

        总的来说，InceptionNet10是一种轻量级的卷积神经网络模型，具有高效的特征提取和分类能力，可以应用于图像分类、目标检测等计算机视觉任务

InceptionNet10源码（tensorflow版）

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers,datasets,models

class ConvBnRelu(models.Model):
    def __init__(self,filter,xx,yy,strides = (1,1)):
        super(ConvBnRelu, self).__init__()
        self.model = models.Sequential([
            layers.Conv2D(filter,(xx,yy),strides=strides,padding='same'),
            layers.BatchNormalization(),
            layers.Activation('relu'),
        ])
    def call(self, inputs, training=None, mask=None):
        x = self.model(inputs)
        return x

class InceptionBlock(models.Model):
    def __init__(self,filters,strides = (1,1)):
        super(InceptionBlock, self).__init__()
        self.x1 = ConvBnRelu(filters,1,1,strides=strides)

        self.x2_1 = ConvBnRelu(filters,1,1,strides=strides)
        self.x2_2 = ConvBnRelu(filters,3,3,strides=(1,1))

        self.x3_1 = ConvBnRelu(filters,1,1,strides=strides)
        self.x3_2 = ConvBnRelu(filters,5,5,strides=(1,1))

        self.x4_1 = layers.MaxPooling2D((3,3),strides=(1,1),padding='same')
        self.x4_2 = ConvBnRelu(filters,1,1,strides=strides)
    def call(self, x, training=None, mask=None):
        x1 = self.x1(x)

        x2_1 = self.x2_1(x)
        x2_2 = self.x2_2(x2_1)

        x3_1 = self.x3_1(x)
        x3_2 = self.x3_2(x3_1)

        x4_1 = self.x4_1(x)
        x4_2 = self.x4_2(x4_1)

        x = layers.concatenate([x1,x2_2,x3_2,x4_2],axis=3)
        return x

class InceptionNet10(models.Model):
    def __init__(self,block_num,classes_num,in_it = 16):
        super(InceptionNet10, self).__init__()
        self.inputs = in_it
        self.outputs = in_it

        self.x1 = ConvBnRelu(self.inputs,3,3)

        self.blocks = models.Sequential()
        for block_i in range(block_num):
            for i in range(2):
                if i == 0:
                    block = InceptionBlock(self.outputs,strides=(2,2))
                else:
                    block = InceptionBlock(self.outputs,strides=(1,1))
                self.blocks.add(block)
            self.outputs *= 2
        self.pool = layers.GlobalAveragePooling2D()
        self.fc = layers.Dense(classes_num,activation='softmax')
    def call(self, inputs, training=None, mask=None):
        x = self.x1(inputs)
        x = self.blocks(x)
        x = self.pool(x)
        x = self.fc(x)

        return x




def main():
    (train_x,train_y),(test_x,test_y) = datasets.cifar10.load_data()
    train_x = train_x.reshape((-1,32,32,3)) / 255.0
    test_x = test_x.reshape((-1,32,32,3)) / 255.0

    model = InceptionNet10(2,10)

    model.compile(loss=keras.losses.sparse_categorical_crossentropy,
                  optimizer=keras.optimizers.Adam(0.01),
                  metrics=['accuracy'])
    model.fit(train_x,train_y,batch_size=128,epochs=20)

    score = model.evaluate(test_x,test_y)
    print("loss:",score[0])
    print("acc:",score[1])


    pass

if __name__ == '__main__':
    main()

 训练20个epoch的效果