resnet keras 结构_ResNet原理及其tensorflow2.0实现

fd8894ff3601757802df34a67b474959.png

ResNet原理及其tensorflow 2.0实现

ResNet介绍:

ResNet是微软研究院华裔学者何凯明等人提出的一种深层卷积神经网络,ResNet 全名为resdual network,残差网络。

ResNet在2015 ILSVRC和COCO比赛上以巨大的优势取得了5项第一。ResNet的提出有效解决了网络层数增加导致的train error增加的问题,使得神经网络的层数大大提高。

神经网络层数的增加,堆叠更深层的网络结构时,退化问题却出现了:随着网络深度的增加,网络的准确度会慢慢饱和,然后迅速下降,并且这种下降不是由于过拟合导致的,对于一个合适的深度神经网络而言,增加层数使得train error增加。

a1369da087601c8fc7764d95c6186e45.png
Figure 1. Training error (left) and test error (right) on CIFAR-10 with 20-layer and 56-layer “plain” networks.

ResNet通过一个深度残差学习框架来解决退化问题,如figure 2所示,其主要思想是增加short connections。对于一个层堆积模块(building block),当输入为x时,其特征映射为

,我们将特征映射改为残差:
,原始的特征映射为
.残差映射比起原始映射更加容易学习,因为当恒等映射(identity mapping)为最优映射时,只需将残差映射训练为0即可,而不必训练堆积层映射为恒等映射;残差映射的最差也是恒等映射,即映射的性能不会因为堆积更多层而下降。

056de7aa05e48007cae4357be951f399.png

Figure2的结构可以定义为

,
表示将要训练的残差映射,
xy分别代表输入和输出向量。
在figure2中可以更加具体定义为
,表示激活函数reLU,
x的维度必须相等,才能进行运算,所以在实际情况中,由于卷积层,可能使得
的维度减小,需要减小
identity x 的维度,可以通过1x1卷积核实现。

ResNet结构:

Plain network是不加short connection的网络结构,其baselines很大程度上参考了VGG19的网络结构,其卷积层的设计遵循两个准则:

  1. 输出feature map的数目与卷积核数目相同;
  2. 如果feature map的尺寸减半,卷积核的数目加倍,确保层的时间复杂度不变。

除此之外,卷积层使用stride = 2进行下采样,并在最后使用global average pooling layer和full connection全连接层。

Figure 3右是一个34层ResNet网络,每两层卷积层间增加short connection。虚线的short connection表示和x的维度不一致,有两种解决方案:(1)采用zero-padding增加维度,为了保持参数,卷积层中进行了strides =2的下采样,(2)建立projection shortcut,采用1x1的卷积核来匹配维度

ac58f67bb226746972925c167ac0a2d0.png
Figure 3. Example network architectures for ImageNet. Left: the VGG-19 model (19.6 billion FLOPs)as a reference. Middle: a plain network with 34 parameter layers (3.6 billion FLOPs).Right: a residual network with 34 parameter layers(3.6 billion FLOPs)

值得注意的是,尽管ResNet-34的层数相对于VGG-19增加了,但是ResNet-34卷积核数目更少,复杂度更小。

ResNet网络结构有18-layer,34-layer,50-layer,101-layer,152-layer几种,其网络结构如table1所示。

16a630593e59ecdbed0c513d6c300f50.png
Table 1. Architectures for ImageNet.

18层和34层的building block是相同的,为2层卷积结构,卷积核的大小为33;而50层,101层和152层ResNet网络的building block结构是相同的,为3层卷积结构,卷积核大小分别为11,3和11, 如figure 4所示。经过数个building block后,其输出再经过一个平均池化层(average pooling)和一个对应类别维度的全连接层。

714a9165b4ecb82e353db7e13e59e873.png
Figure 4. A deeper residual function F for ImageNet. Left: a building block (on 56×56 feature maps) as in Fig. 3 for ResNet-34. Right: a “bottleneck” building block for ResNet-50/101/152.

对比plain-18,34网络和ResNet-18,34的训练和validation效果,可以看出残差网络有效解决了增加层数导致退化问题。

c0d92c404d43e0a160dd0fcf2e8c3e4e.png
Figure 5. Training on ImageNet. Thin curves denote training error, and bold curves denote validation error of the center crops. Left: plain networks of 18 and 34 layers. Right: ResNets of 18 and 34 layers.

ResNet-18,34 Tensorflow 2.0实现:

import 

参考资料

  1. Deep Residual Learning for Image Recognition.
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: TensorFlow 2.可以通过使用Keras API来实现ResNet50模型。ResNet50是一种深度卷积神经网络,由50个卷积层组成,用于图像分类和目标检测等任务。 以下是使用TensorFlow 2.和Keras API实现ResNet50的示例代码: ```python import tensorflow as tf from tensorflow.keras.applications.resnet50 import ResNet50 from tensorflow.keras.layers import Dense, Flatten from tensorflow.keras.models import Model # 加载ResNet50模型 resnet = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) # 冻结ResNet50模型的所有层 for layer in resnet.layers: layer.trainable = False # 添加自定义输出层 x = resnet.output x = Flatten()(x) x = Dense(1024, activation='relu')(x) predictions = Dense(100, activation='softmax')(x) # 构建新模型 model = Model(inputs=resnet.input, outputs=predictions) # 编译模型 model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) ``` 在上面的代码中,我们首先加载了预训练的ResNet50模型,并将其所有层都冻结。然后,我们添加了自定义的输出层,并使用Keras API构建了一个新模型。最后,我们编译了模型并指定了优化器、损失函数和评估指标。 接下来,我们可以使用该模型进行训练和预测。例如,我们可以使用以下代码加载图像数据集并训练模型: ```python from tensorflow.keras.preprocessing.image import ImageDataGenerator # 加载图像数据集 train_datagen = ImageDataGenerator(rescale=1./255) train_generator = train_datagen.flow_from_directory( 'data/train', target_size=(224, 224), batch_size=32, class_mode='categorical') # 训练模型 model.fit_generator( train_generator, steps_per_epoch=200, epochs=50) ``` 在上面的代码中,我们使用Keras的ImageDataGenerator类加载了图像数据集,并指定了训练集的目录、图像大小和批量大小等参数。然后,我们使用fit_generator()方法训练模型,并指定了训练集的步数和训练轮数等参数。 最后,我们可以使用以下代码对新数据进行预测: ```python import numpy as np from tensorflow.keras.preprocessing import image # 加载测试图像 img_path = 'data/test/cat.jpg' img = image.load_img(img_path, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=) x = preprocess_input(x) # 预测图像类别 preds = model.predict(x) print('Predicted:', decode_predictions(preds, top=3)[]) ``` 在上面的代码中,我们使用Keras的image模块加载了测试图像,并将其转换为NumPy数组。然后,我们使用预处理函数preprocess_input()对图像进行预处理,并使用模型的predict()方法对图像进行预测。最后,我们使用decode_predictions()函数将预测结果转换为可读的格式。 ### 回答2: Tensorflow是一种流行的深度学习框架,它可以用来实现各种神经网络模型,包括ResNet。首先,需要安装Tensorflow2.0版本。进入Python环境,可以用命令`pip install tensorflow==2.0`来安装。 ResNet是一种广泛使用的深度卷积神经网络结构,其核心思想是使用残差模块来缓解深层网络中的梯度消失问题,以提高训练效果和模型的表现力。ResNet有很多变种,包括ResNet-50、ResNet-101等。这里以ResNet-50为例进行实现。 首先,需要导入必要的库,包括Tensorflow和相关的Keras模块: ``` import tensorflow as tf from tensorflow import keras from tensorflow.keras.layers import Conv2D, BatchNormalization, ReLU, Add, AvgPool2D, Dense, Flatten ``` 然后,定义ResNet-50的基本残差模块,包含两个卷积层和一个残差连接: ``` class ResidualBlock(keras.Model): def __init__(self, in_channels, out_channels, strides=1, use_bias=False): super(ResidualBlock, self).__init__() self.conv1 = keras.Sequential([ Conv2D(out_channels // 4, kernel_size=1, strides=1, use_bias=False), BatchNormalization(), ReLU() ]) self.conv2 = keras.Sequential([ Conv2D(out_channels // 4, kernel_size=3, strides=strides, padding='same', use_bias=False), BatchNormalization(), ReLU() ]) self.conv3 = keras.Sequential([ Conv2D(out_channels, kernel_size=1, strides=1, use_bias=False), BatchNormalization(), ]) self.shortcut = keras.Sequential() if strides != 1 or in_channels != out_channels: self.shortcut = keras.Sequential([ Conv2D(out_channels, kernel_size=1, strides=strides, use_bias=False), BatchNormalization(), ]) self.relu = ReLU() def call(self, inputs): x = self.conv1(inputs) x = self.conv2(x) x = self.conv3(x) shortcut = self.shortcut(inputs) x = Add()([x, shortcut]) x = self.relu(x) return x ``` 接着,定义ResNet-50的整体结构,包含多个残差模块和全连接层: ``` class ResNet(keras.Model): def __init__(self, block, num_blocks, num_classes): super(ResNet, self).__init__() self.in_channels = 64 self.conv1 = keras.Sequential([ Conv2D(64, kernel_size=7, strides=2, padding='same', use_bias=False), BatchNormalization(), ReLU(), AvgPool2D(pool_size=3, strides=2, padding='same') ]) self.layer1 = self._make_layer(block, 64, num_blocks[0], strides=1) self.layer2 = self._make_layer(block, 128, num_blocks[1], strides=2) self.layer3 = self._make_layer(block, 256, num_blocks[2], strides=2) self.layer4 = self._make_layer(block, 512, num_blocks[3], strides=2) self.avgpool = AvgPool2D(pool_size=7, strides=1) self.flatten = Flatten() self.fc = Dense(num_classes, activation='softmax') def _make_layer(self, block, out_channels, num_blocks, strides): strides_list = [strides] + [1] * (num_blocks - 1) layers = keras.Sequential() for stride in strides_list: layers.add(block(self.in_channels, out_channels, stride)) self.in_channels = out_channels return layers def call(self, inputs): x = self.conv1(inputs) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.layer4(x) x = self.avgpool(x) x = self.flatten(x) x = self.fc(x) return x ``` 可以看到,ResNet-50的实现比较复杂,包含多个残差模块和全连接层。其中,`_make_layer`方法用来构建多个残差模块,`call`方法用来定义整个网络结构。最后可以用以下代码来进行模型的训练和测试: ``` model = ResNet(ResidualBlock, [3, 4, 6, 3], num_classes=10) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data() x_train = x_train.astype('float32') / 255.0 x_test = x_test.astype('float32') / 255.0 y_train = keras.utils.to_categorical(y_train, num_classes=10) y_test = keras.utils.to_categorical(y_test, num_classes=10) model.fit(x_train, y_train, batch_size=64, epochs=10, validation_data=(x_test, y_test)) ``` 这里的数据集是CIFAR-10,数据预处理和训练过程略。运行以上代码,就可以得到一个训练好的ResNet-50模型。 ### 回答3: ResNet50是Residual Network的一种经典架构,它能有效缓解深度卷积神经网络的梯度弥散问题,使得网络能够更深,参数更多,最终达到更好的性能。今天我们将介绍如何用TensorFlow 2.0实现ResNet50。 首先,我们导入相关的包: ``` import tensorflow as tf from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, BatchNormalization, GlobalAveragePooling2D, Dropout, Flatten, Input, add from tensorflow.keras.models import Model ``` 然后我们定义ResNet50的基础单元,也叫作残差块。这个残差块由两层卷积、批归一化、Relu激活函数和一个恒等映射构成。就像这样: ``` def residual_block(inputs, filters, kernel_size, strides): shortcut = inputs x = Conv2D(filters[0], kernel_size=1, strides=strides, padding='valid')(inputs) x = BatchNormalization()(x) x = tf.keras.layers.ReLU()(x) x = Conv2D(filters[1], kernel_size=kernel_size, strides=1, padding='same')(x) x = BatchNormalization()(x) x = tf.keras.layers.ReLU()(x) x = Conv2D(filters[2], kernel_size=1, strides=1, padding='valid')(x) x = BatchNormalization()(x) if strides != 1 or inputs.shape[-1] != filters[2]: shortcut = Conv2D(filters[2], kernel_size=1, strides=strides, padding='valid')(shortcut) shortcut = BatchNormalization()(shortcut) x = add([x, shortcut]) x = tf.keras.layers.ReLU()(x) return x ``` 接下来定义ResNet50的完整模型。整个模型由7个卷积层、4个残差块和一个全连接层构成。就像这样: ``` def ResNet50(input_shape=(224, 224, 3)): inputs = Input(input_shape) x = Conv2D(64, kernel_size=7, strides=2, padding='same')(inputs) x = BatchNormalization()(x) x = tf.keras.layers.ReLU()(x) x = MaxPooling2D(pool_size=3, strides=2, padding='same')(x) x = residual_block(x, [64, 64, 256], kernel_size=3, strides=1) x = residual_block(x, [64, 64, 256], kernel_size=3, strides=1) x = residual_block(x, [64, 64, 256], kernel_size=3, strides=1) x = residual_block(x, [128, 128, 512], kernel_size=3, strides=2) x = residual_block(x, [128, 128, 512], kernel_size=3, strides=1) x = residual_block(x, [128, 128, 512], kernel_size=3, strides=1) x = residual_block(x, [128, 128, 512], kernel_size=3, strides=1) x = residual_block(x, [256, 256, 1024], kernel_size=3, strides=2) x = residual_block(x, [256, 256, 1024], kernel_size=3, strides=1) x = residual_block(x, [256, 256, 1024], kernel_size=3, strides=1) x = residual_block(x, [256, 256, 1024], kernel_size=3, strides=1) x = residual_block(x, [256, 256, 1024], kernel_size=3, strides=1) x = residual_block(x, [256, 256, 1024], kernel_size=3, strides=1) x = residual_block(x, [512, 512, 2048], kernel_size=3, strides=2) x = residual_block(x, [512, 512, 2048], kernel_size=3, strides=1) x = residual_block(x, [512, 512, 2048], kernel_size=3, strides=1) x = GlobalAveragePooling2D()(x) x = Dense(1000, activation='softmax')(x) model = Model(inputs=inputs, outputs=x) return model ``` 最后我们构建一个ResNet50模型,并使用ImageDataGenerator读取数据集和fit方法训练模型: ``` datagenerator_train = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1/255.0) datagenerator_test = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1/255.0) train_generator = datagenerator_train.flow_from_directory('./data/train', target_size=(224,224), batch_size=32, class_mode='categorical') valid_generator = datagenerator_test.flow_from_directory('./data/valid', target_size=(224,224), batch_size=32, class_mode='categorical') model = ResNet50() model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) history = model.fit(train_generator, epochs=10, validation_data=valid_generator) ``` 现在,你已经成功地使用TensorFlow 2.0实现ResNet50模型,并使用ImageDataGenerator读取数据集和fit方法训练了模型,你可以拿到数据集进行测试并进行更多的调整,期望能够取得优秀的结果。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值