ResNet原理与实战

目录

ResNet原理     

ResNet实战程序 

各个网络的区别：

ResNet原理     

          resNet诞生于2015年，是当年ImageNet竞赛的冠军，Top5的错误率为3.57%，ResNet提出了层间残差跳连，引入了前方信息，缓解了梯度消失使神经网络层数增加成为了可能。纵览前面博客讲过的四个卷积神经网络层数如下所示：

        通过以上网络可以发现，人们在探索卷积实现特征提取的道路上，通过加深网络层数得到了越来越好的效果。

        ResNet的作者何凯明在cifar10数据集上做了个实验，他发现，56层卷积网络的错误率 ，要高于20层卷积网络的错误率。他认为单纯堆叠神经网络层数会使神经网络模型退化，以至于后面的特征丢失了前面的特征的原本模样，于是他用一个跳连线，将前面的特征值直接接到了后边，使输出结果H（x）包含了堆叠卷积的非线性输出F(x)和跳过这两层堆叠卷积直接连接过来的恒等映射x，让他们对应元素相加，这一操作有效缓解了神经网络的模型堆叠导致的退化，使得神经网络可以向着更深层级发展。如下图所示：

         ResNet块中有两种情况，一种情况是用图中的实线表示，这种情况两层堆叠卷积，没有改变特征图的维度，也就是它们特征图的个数、高、宽和深度都相同，可直接将F(x)与x相加。，另一种情况用图中的虚线表示，这种情况中这两层堆叠的卷积改变了特征图的维度，需要借助1*1的卷积来调整x的维度，使得w(x)与F(x)的维度一致。（1*1卷积操作可以通过步长改变特征图尺寸，通过卷积核个数改变特征图深度），如下图所示：

    

         ResNet块有两种形式，一种在堆叠卷积前后维度相同，另一种在堆叠卷积前后维度不同，我们可以把ResNet块的两种结构封装到一个橙色块中，写出ResNetBlock类，每调用一次ResNetBlock类会生成一个黄色块，如果堆叠卷积层前后维度不同，设置residual_path等于1，调用红色块代码，使用1*1卷积操作，调整输入特征图inputs的尺寸或者深度后将堆叠卷积输出特征y,和if语句计算出的residual相加过激活然后输出；如果堆叠卷积层前后维度相同不执行红色块内代码，直接将堆叠卷积输出特征y和输入特征图inputs相加。过激活然后输出。

 完整的ResNet模型结构如下所示：

ResNet实战程序 

import keras.layers
import numpy as np
import tensorflow as tf
import os
from matplotlib import pyplot as plt
import PySide2
from tensorflow.keras.layers import Conv2D,BatchNormalization,Activation,MaxPooling2D,Dropout,Flatten,Dense,GlobalAveragePooling2D
from tensorflow.keras import Model


dirname = os.path.dirname(PySide2.__file__)
plugin_path = os.path.join(dirname, 'plugins', 'platforms')
os.environ['QT_QPA_PLATFORM_PLUGIN_PATH'] = plugin_path
np.set_printoptions(threshold=np.inf)  # 设置打印出所有参数，不要省略

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

# 由于fashion数据集是三维的(60000, 28, 28)，而cifar10 数据集是四维的，而此网络是用来识别四维的数据所所以需要将3维的输入扩展维4维的输入
x_train = np.expand_dims(x_train, axis=3)
x_test = np.expand_dims(x_test, axis=3)

class ResnetBlock(Model):
    def __init__(self, filters, strides=1, residual_path=False):
        super(ResnetBlock, self).__init__()
        self.filters = filters
        self.strides = strides
        self.residual_path = residual_path

        self.c1 = Conv2D(filters, (3, 3), strides=strides, padding='same', use_bias=False)
        self.b1 = BatchNormalization()
        self.a1 = Activation('relu')

        self.c2 = Conv2D(filters, (3, 3), strides=1, padding='same', use_bias=False)
        self.b2 = BatchNormalization()

        # residual_path为True时，对输入进行下采样，即采用1*1的卷积核做卷积操作，保证x能和F(x)维度相同，顺利x相加
        if residual_path:
            self.down_c1 = Conv2D(filters, (1, 1), strides=strides, padding='same', use_bias=False)
            self.down_b1 = BatchNormalization()

        self.a2 = Activation('relu')

    def call(self, inputs):
        residual = inputs  # residual等于输入值本身即redidual
        # 将输入通过卷积、BN层、激活层计算F（x）
        x = self.c1(inputs)
        x = self.b1(x)
        x = self.a1(x)

        x = self.c2(x)
        y = self.b2(x)

        if self.residual_path:
            residual = self.down_c1(inputs)
            residual = self.down_b1(residual)

        out = self.a2(y + residual)  # 最后输出的是两部分的和，即F(x)+x或者F(x)+w（x）再过激活函数
        return out


class ResNet18(Model):
    def __init__(self, block_list, initial_filters=64):  # block_list表示每个block有几个卷积层
        super(ResNet18, self).__init__()
        self.num_blocks = len(block_list)  # 共有几个block
        self.block_list = block_list
        self.out_filters = initial_filters
        self.c1 = Conv2D(self.out_filters, (3, 3), strides=1, padding='same', use_bias=False)
        self.b1 = BatchNormalization()
        self.a1 = Activation('relu')
        self.blocks = tf.keras.models.Sequential()

        # 构建ResNet网络结构
        for block_id in range(len(block_list)):   # 第几个resnet block
            for layer_id in range(block_list[block_id]):  # 第几个卷积层
                if block_id != 0 and layer_id == 0:  # 对出第一个block以外的每个block的输入进行下采样
                    block = ResnetBlock(self.out_filters, strides=2, residual_path=True)
                else:
                    block = ResnetBlock(self.out_filters, residual_path=False)
                self.blocks.add(block)   # 将构建好的block加入resnet
            self.out_filters *= 2  # 下一个block的卷积核数是上一个block的2倍
        self.p1 = tf.keras.layers.GlobalAveragePooling2D()
        self.f1 = tf.keras.layers.Dense(10, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

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

model = ResNet18([2, 2, 2, 2])


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

checkpoint_save_path = './checkpoint/mnist.ckpt'
if os.path.exists(checkpoint_save_path + '.index'):
    print('------------------------load the model---------------------')
    model.load_weights(checkpoint_save_path)


cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path,
                                                 save_weights_only=True,
                                                 save_best_only=True)

history = model.fit(x_train, y_train, batch_size=8, epochs=5,
                    validation_data=(x_test, y_test),
                    validation_freq=1,
                    callbacks=[cp_callback])
model.summary()

print(model.trainable_variables)
file = open('./weights.txt', 'w')
for v in model.trainable_variables:
    file.write(str(v.name) + '\n')
    file.write(str(v.shape) + '\n')
    file.write(str(v.numpy()) + '\n')
file.close()

############################  show  #############################
# 显示训练集和验证集的acc和loss曲线
acc=history.history['sparse_categorical_accuracy']
val_acc = history.history['val_sparse_categorical_accuracy']
loss = history.history['loss']
val_loss = history.history['val_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()

各个网络的区别：