TensorFlow实战 11 ResNet神经网络（ILSVRC-2015 champion）

最新推荐文章于 2024-09-13 09:52:14 发布
最新推荐文章于 2024-09-13 09:52:14 发布
阅读量546 收藏 2
点赞数 1
分类专栏： TensorFlow TensorFlow实战 文章标签： tensorflow ResNet

论文地址：Deep Residual Learning for Image Recognition

背景：

        1）Highway network:修改每一层的激活函数，此前的激活函数只对输入做非线性变换Y = H(x, W_x)，Highway network允许保留一定比例的原始输入x，即 y = H(x, W_x)T(x, W_t) + x(1-T(x, W_T)),这样，前面一层的信息，有一定的比例可以不经过矩阵乘法和非线性变换，直接传输到下一层。理论上，Highway network允许任意深度的神经网络，其优化方法基本与网络的深度独立，减少了训练的复杂度。

       2）神经网络深度增加带来的不利方面：a）梯度弥散（vanishing/exploding gridents）网络深度加深，越难收敛。解决方法：标准初始化和中间标准化层（BN正则化），使用SGD等方法反向传播实现收敛；b）退化（degradation）:随着网络的加深，准确率达到饱和，然后迅速下降，导致准确率下降的原因并非过拟合，而是简单的网络加深使得系统优化更加困难。解决办法：引入残差学习框架，拟合残差映射而非拟合简单堆叠网络期望的基本映射。假设残差映射比原始的、未参考的映射更容易优化。极端情况下，将将残差置为零比通过一堆非线性层来拟合恒等映射更容易。

 

残差学习框架特点：

 

     1）极深的残差网络易于优化，但当深度增加时，对应的简单堆叠层的网络表现出更高的训练误差；

     2）深度残差网络可以从大大增加的深度中轻松获得准确性收益，生成的结果实质上比以前的网络更好.

ResNet优点

    1）相比传统的卷积神经网络如VGG复杂度降低，需要的参数下降。

    2）可以做到更深，不会出现梯度弥散的问题。

    3）优化简单，分类准确度加深由于使用更深的网络。

    4）解决深层次网络的退化问题。

残差神经网络的模块结构及变种：

基于TensorFlow的ResNet神经网络时间评估：

import tensorflow as tf
import collections
from datetime import datetime
import math
import time

slim = tf.contrib.slim

#define Block class to build different conv layer Block
class Block(collections.namedtuple('Block', ['scope', 'unit_fn', 'args'])):
	'''
	description : to build different conv layer Block
	'''

#define subsample function to excute max_pool2d operation
def subsample(x, factor, scope):
	'''
	description : to excute max_pool2d operation
	Args : 	x : the input data
			factor : the sampling factor
			scope : the name scope
	Returns: x or max_pool2d result depending on the factor
	'''
	if factor == 1:
		return x
	else:
		return slim.max_pool2d(x, [1, 1], stride = factor, scope = scope)

#define conv2d_same to excute conv operation with different padding method
def conv2d_same(x, channel, kernal, stride, scope = None):
	'''
	description:	
	Args	x : the input data
			channel : the output channel
			kernal : the kernal(filter) size
			stride : the conv stride
			scope : the name scope
	Returns : conv2d result
	'''
	if stride == 1 :
		return slim.conv2d(x, channel, kernal, stride, padding = 'SAME', scope = scope)
	else:
		pad_total = kernal - 1
		pad_beg = pad_total // 2
		pad_end = pad_total - pad_beg
		x = tf.pad(x, [[0, 0], [pad_beg, pad_end], [pad_beg, pad_end], [0, 0]])
		return slim.conv2d(x, channel, kernal, stride = stride, padding = 'VALID', scope = scope)

@slim.add_arg_scope
#define stack_block_dense function to stack the block
def stack_block_dense(x, blocks, out_collections = None):
	'''
	description: to stack the block
	Args:	x : the input data
			blocks: the name scope / block form Block
			collections: the end_points from collection
	Returns:	the densed output tensor
	'''
	for block in blocks:
		with tf.variable_scope(block.scope, 'block', [x]) as scope:
			for i, unit in enumerate(block.args):
				with tf.variable_scope('unit_%d'%(i + 1), values = [x]):
					depth, depth_bottlenect, stride = unit
					#residual learning unit
					x = block.unit_fn(x, depth = depth, depth_bottlenect = depth_bottlenect, stride = stride)
	return slim.utils.collect_named_outputs(out_collections, scope.name, x)

#define resnet_arg_scope function to predefine the parameters in resnet
def resnet_arg_scope(weight_decay = 0.0001, batch_norm_decay = 0.997, batch_norm_epsilon = 1e-5, batch_norm_scale = True, is_training = True):
	'''
	description: to predefine the parameters in resnet
	Args:	weight_decay: weight decay rate
			batch_norm_decay: BN decay rate 
			batch_norm_epsilon: BN epsilon parameter
			batch_norm_scale: BN scale parameter
			is_training:
	'''
	#define the BN parameters
	batch_norm_params = {
		'decay' : batch_norm_decay,
		'epsilon' : batch_norm_epsilon,
		'scale' : batch_norm_scale,
		'is_training' : is_training,
		'update_collections' : tf.GraphKeys.UPDATE_OPS,
	}

	#set the slim args scope
	with slim.arg_scope(
			[slim.conv2d],
			weights_regularizer = slim.l2_regularizer(weight_decay),
			weights_initializer = slim.variance_scaling_initializer(),
			activation_fn = tf.nn.relu,
			normalizer_fn = slim.batch_norm,
			normalizer_params = batch_norm_params):
		with slim.arg_scope([slim.batch_norm], **batch_norm_params):
			with slim.arg_scope([slim.max_pool2d], padding = 'SAME') as arg_scope:
				return arg_scope

@slim.add_arg_scope
#define bottlenect function to initialize the bottlenect residual learning unit
def bottlenect(x, depth, depth_bottlenect, stride, out_collections = None, scope = None):
	'''
	description: to initialize the bottlenect residual learning unit
	Args:	x : the input data
			depth : the output channel
			depth_bottlenect : bottlenect residual learning unit
			stride : the stride for conv operation
			collections : the end_points from collection
			scope : the name scope
	Returns:	H(x) = f(x) + x
	'''
	with tf.variable_scope(scope, 'bottlenect_v2', [x]) as scope:
		# access the input channel
		depth_in = slim.units.last_dimension(x.get_shape(), min_rank = 4)
		# excute the relu and BN operation for preactivation [the V2 method]
		preactivation = slim.batch_norm(x, activation_fn = tf.nn.relu, scope = 'preactivation')
		#define shortcut operation
		if depth == depth_in:
			shortcut = subsample(x, stride, 'shortcut')
		else:
			shortcut = slim.conv2d(preactivation, depth, [1, 1], stride = stride, normalizer_fn = None, activation_fn = None, scope = 'shortcut')
		#calculate f_x
		F_x = slim.conv2d(preactivation, depth_bottlenect, [1 ,1], stride = 1, scope = 'conv1')
		F_x = conv2d_same(residual, depth_bottlenect, 3, stride, scope = 'conv2')
		F_X = slim.conv2d(residual, depth, [1, 1], stride = 1, normalizer_fn = None, activation_fn = None, scope = 'conv3')
		#calculate the output
		H_x = F_x + shortcut
		return slim.utils.collect_named_outputs(out_collections, scope.name, H_x)

#define resnet_v2 main function to load the blocks
def resnet_v2(x, blocks, num_class = None, global_pool = None, include_root_block = True, reuse = None, scope = None):
	'''
	description : to load blocks
	Args:	x : the input data
			blocks : the Block object
			num_class : the number of class
			global_pool : global avg pool better than avg_pool directly
			include_root_block : whether include root block
			reuse : whether reuse the block
			scope : the name scope
	Returns:	net : the conv network result
				end_points : the output collection result
	'''
	with tf.variable_scope(scope, 'resnet_v2', [x], reuse = reuse) as scope:
		end_points = scope.original_name_scope + '_end_points'
		with slim.arg_scope([slim.conv2d, bottlenect, stack_block_dense], out_collections = end_points):
			net = x
			if include_root_block:
				with slim.arg_scope([slim.conv2d], activation_fn = None, normalizer_fn = None):
					net = conv2d_same(net, 64, 7, stride = 2, scope = 'conv1')
				net = slim.max_pool2d(net, [3, 3], stride = 2, scope = 'conv1')
			net = stack_block_dense(net, blocks)
			net = slim.batch_norm(net, activation_fn = tf.nn.relu, scope = 'postnorm')
			if global_pool:
				net = tf.reduce_mean(net, [1, 3], scope = 'pool5', keep_dims = True)
			if num_class is not None:
				net = slim.conv2d(net, num_class, [1, 1], activation_fn = None, normalizer_fn = None, scope = 'logits')
			end_points = slim.utils.convert_collection_to_dict(end_points)
			if num_class is not None:
				end_points['prediction'] = slim.sofmax(net, scope = 'prediction')
			return net, end_points

#define resnet_v2_50 network architecture
def resnet_v2_50(x, num_class = None, global_pool = True, reuse = True, scope = 'resnet_v2_50'):
	'''
	description : to build the resnet_v2_50 model
	Args :	x : the input data
			num_class : the number of class
			global_pool : global average pool
			reuse : whether reuse block
			scope : the name scope
	Returns :	net : the network model
				end_points : the end_points collection
	'''
	blocks = [
				Block('block1', bottlenect, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
				Block('block2', bottlenect, [(512, 128, 1)] * 3 + [(512, 128, 2)]),
				Block('block3', bottlenect, [(1024, 256, 1)] * 5 + [(1024, 256, 2)]),
				Block('block4', bottlenect, [(2048, 512, 1)] * 3)]
	return resnet_v2(x, blocks, num_class, global_pool, include_root_block = True, reuse = reuse, scope = scope)

#define resnet_v2_101 network architecture
def resnet_v2_101(x, num_class = None, global_pool = True, reuse = True, scope = 'resnet_v2_101'):
	'''
	description : to build the resnet_v2_101 model
	Args :	x : the input data
			num_class : the number of class
			global_pool : global average pool
			reuse : whether reuse block
			scope : the name scope
	Returns :	net : the network model
				end_points : the end_points collection
	'''
	blocks = [
				Block('block1', bottlenect, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
				Block('block2', bottlenect, [(512, 128, 1)] * 3 + [(512, 128, 2)]),
				Block('block3', bottlenect, [(1024, 256, 1)] * 22 + [(1024, 256, 2)]),
				Block('block4', bottlenect, [(2048, 512, 1)] * 3)]
	return resnet_v2(x, blocks, num_class, global_pool, include_root_block = True, reuse = reuse, scope = scope)

#define resnet_v2_152 network architecture
def resnet_v2_152(x, num_class = None, global_pool = True, reuse = True, scope = 'resnet_v2_152'):
	'''
	description : to build the resnet_v2_152 model
	Args :	x : the input data
			num_class : the number of class
			global_pool : global average pool
			reuse : whether reuse block
			scope : the name scope
	Returns :	net : the network model
				end_points : the end_points collection
	'''
	blocks = [
				Block('block1', bottlenect, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
				Block('block2', bottlenect, [(512, 128, 1)] * 7 + [(512, 128, 2)]),
				Block('block3', bottlenect, [(1024, 256, 1)] * 35 + [(1024, 256, 2)]),
				Block('block4', bottlenect, [(2048, 512, 1)] * 3)]
	return resnet_v2(x, blocks, num_class, global_pool, include_root_block = True, reuse = reuse, scope = scope)

#define resnet_v2_200 network architecture
def resnet_v2_200(x, num_class = None, global_pool = True, reuse = True, scope = 'resnet_v2_200'):
	'''
	description : to build the resnet_v2_152 model
	Args :	x : the input data
			num_class : the number of class
			global_pool : global average pool
			reuse : whether reuse block
			scope : the name scope
	Returns :	net : the network model
				end_points : the end_points collection
	'''
	blocks = [
				Block('block1', bottlenect, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
				Block('block2', bottlenect, [(512, 128, 1)] * 23 + [(512, 128, 2)]),
				Block('block3', bottlenect, [(1024, 256, 1)] * 35 + [(1024, 256, 2)]),
				Block('block4', bottlenect, [(2048, 512, 1)] * 3)]
	return resnet_v2(x, blocks, num_class, global_pool, include_root_block = True, reuse = reuse, scope = scope)

#define time_tensorflow_run function to access the time consuming
def time_tensorflow_run(sess, operator, test_name):
	'''
	description: to access the time consuming
	Args:	sess: tensorflow Session
			operator: operator for accessing
			test_name: test name
	Returns:	time consuming info
	'''
	#define pre hot batch size
	num_steps_burn_in = 10
	#define total duration
	total_duration = 0.0
	#define total duration square error
	total_duration_squared = 0.0
	
	#calculate time consuming and print result every 10 epoch
	for i in range(num_batches + num_steps_burn_in):
		start_time = time.time()
		_ = sess.run(operator)
		duration = time.time() - start_time
		if i >= num_steps_burn_in:
			if not i % 10 :
				print('%s:	step %d, 	duration := %.3f'%(datetime.now(), i - num_steps_burn_in, duration))
			total_duration += duration
			total_duration_squared += duration * duration
	#calculate avarage time consuming
	ave_time = total_duration / num_batches
	#calculate strandand deviance
	var = ave_time*ave_time - total_duration_squared / num_batches
	std_dev = math.sqrt(var)
	print('%s,	%s across %d steps, %.3f, +/- %.3f sec/batch'%(datetime.now(), test_name, num_batches, ave_time, std_dev))

#define batch size
batch_size = 32
#define image_size
image_size = 224
#generate the random image
x = tf.random_uniform((batch_size, image_size, image_size, 3))
#access the net result
with slim.arg_scope(resnet_arg_scope(is_training = False)):
	net, end_points = resnet_v2_152(x, 1000)

#initialize the global variable
init = tf.global_variables_initializer()
#create Session
sess = tf.Session()
sess.run(init)
num_batches = 100
#estimate the time consuming
time_tensorflow_run(sess, net, 'Forward')

 practice makes perfect!

 

 

qq_37172182
关注
专栏目录
Flow-Guided-Feature-Aggregation-的安装配置，demo运行，以及采用少量ILSVRC2015 VID数据集在其中训练
weixin_42258492的博客
04-28 1365
由于课题组接了一个视频检测的项目，所以找到了这个模型，用于视频目标检测的同学可以有兴趣尝试。 FGFA-github上的源码：https://github.com/msracver/Flow-Guided-Feature-Aggregation 同时Flow-Guided-Feature-Aggregation与另一篇文章Deep Feature Flow非常相似，包括环境的配置等。 DFF...
TensorFlow2.0_ResNet:使用TensorFlow-2.0的ResNet（ResNet18，ResNet34，ResNet50，ResNet101，ResNet152）实现
05-22
使用TensorFlow-2.0的ResNet（ ResNet18，ResNet34，ResNet50，ResNet101，ResNet152 ）实现 有关更多的CNN，请参见 。 火车 要求： Python> = 3.6 Tensorflow == 2.0.0 要在自己的数据集上训练ResNet，可以将...
Resnet神经网络
cbd_2012的博客
10-20 628
https://blog.csdn.net/qq_35083093/article/details/79248885 Resnet网络的应用实现       https://www.colabug.com/78698.html Resnet网络的图像识别，医学领域的应用 https://gallery.azure.ai/Notebook/Medical-Image-Recognitin-f...
深入浅出之Resnet网络
最新发布
浩瀚之水的专栏
09-13 7444
ResNet（Residual Network，残差网络）是一种由微软亚洲研究院提出的深度神经网络结构，其核心在于通过残差连接（residual connections）解决了深层网络训练中的梯度消失和梯度爆炸问题，使得网络可以训练得更深，性能更强。
卷积神经网络的网络结构——ResNet V2
小花生的博客
06-16 4111
《Identity Mappings in Deep Residual Networks》 2016，kaiming He et al，ResNet V2。 深度残差网络作为一种极深的网络框架，在精度和收敛等方面都展现出了很好的特性。作者通过对残差块(residual building blocks)背后的计算传播方式进行分析，表明了当跳跃连接(skip connections)以及附加激...
ResNet卷积神经网络--TensorFlow2
一只AI小白
04-14 482
ResNet卷积神经网络--TensorFlow2结果展示loss和acc曲线计算参数程序 结果展示 acc = 91.96% loss和acc曲线 计算参数 程序 # -*- coding: utf-8 -*- """ Created on Tue Apr 14 2020 @author: jeo13 """ # 导入包 import tensorflow as tf import os ...
Resnet网络介绍及Tensorflow实现
weixin_41469272的博客
09-14 814
Resnet网络介绍及Tensorflow实现 网络背景 以下内容原文参考博客 微软研究院的Kaiming He等4名华人提出，通过使用Residual Unit成功训练152层深的神经网络，在ILSVRC 2015比赛中获得了冠军，取得3.57%的top-5错误率，同时参数量却比VGGNet低，效果非常突出。 ResNet允许原始输入信息直接传输到后面的层中。ResNet最初的灵感...
ILSVRC-Vid-2015-Video-Detection-:ILSVRC Vid 2015视频检测笔记本
04-10
7. **深度学习库**：可能涉及到的深度学习库有TensorFlow、Keras、PyTorch等，它们提供了便捷的接口来构建、训练和优化神经网络模型。 8. **并行计算与GPU加速**：由于视频数据量大，训练过程可能需要利用GPU的并行...
卷积神经网络ResNet50训练CIFAR-100图像分类Pytorch实现
07-03
# 卷积神经网络ResNet50训练CIFAR-100图像分类Pytorch实现 1. 使用pytorch调用CIFAR-100数据集，首次训练自动下载； 2. 包含训练代码，调用resnet50模型进行训练，使用交叉熵损失和SGD优化器； 3. 包含训练了50 ...
基于TensorFlow+ResNet残差神经网络实现白细胞图片分类Python源码.zip
05-09
基于TensorFlow+ResNet残差神经网络实现白细胞图片分类Python源码.zip已获导师指导并通过的97分的高分大作业设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于TensorFlow+...
经典卷积神经网络之-2015-ResNet18-MNIST（建议使用GPU来跑）.zip
01-28
2015年，由Kaiming He等人提出的ResNet（Residual Network）进一步推动了CNN的发展，解决了深度神经网络训练中的梯度消失问题。ResNet18是ResNet系列的一个简化版本，具有18层网络结构，适用于小型数据集如MNIST。 ...
2015年ImageNet ILSVRC冠军论文学习 - ResNet
Raymond_Love的博客
03-18 1855
ResNet Residual Network（ResNet）获得了2015 ILSVRC的冠军。它的特点是大量使用了Identify mapping（一致变换），使得网络更容易学习。ResNet在网络的末端使用avg pool代替前两个全连接层。 1. 基本思想 从AlexNet到GoogleNet，VGGNet，可以看到越深的网络表达能力越好。但是，随着网络的加深，我们观察到模型的准确性...
ILSVRC2015_VID数据集说明
du的博客
11-20 9304
参考：https://blog.csdn.net/weixin_43292354/article/details/100155303 数据主页：http://bvisionweb1.cs.unc.edu/ilsvrc2015/download-videos-3j16.php#vid 数据下载：http://bvisionweb1.cs.unc.edu/ilsvrc2015/ILSVRC2015_VID.tar.gz
ILSVRC15 夺冠神器，ResNet论文阅读
qq_29679623的博客
09-05 419
论文地址：https://arxiv.org/pdf/1512.03385.pdf 作为ILSVRC15年的冠军，Kaiming大神一贯落实着不发则已，一发惊人的论文生产准则。最近静下心来仔细研究一下这篇论文，个人认为Kaiming是一个很看重问题本质的学者，他发的论文都会从问题的最本质的原因入手，比如Focal loss的提出、Faster RCNN的加速点、Mask RCNN的突破性创新等等。...
全网最全经典卷积神经网络架构汇总——深度学习之ILSVRC竞赛(ImageNet竞赛)优胜网络结构
bigcindy的博客
07-19 3193
近年来，卷积神经网络在图像分类领域取得了巨大进展，主要表现在ILSVRC竞赛中优胜冠军从经典的机器学习算法转向深度学习算法，尤其是卷积神经网络结构。在卷积神经网络发展的历史过程中，ILSVRC竞赛功不可没，从2012年到2017年，不断涌现出新的卷积神经网络结构，并将ILSVRC竞赛中ImageNet数据集图像分类错误率降至很低的水平，一度达到甚至超越人类的水平。 ILSVRC全称ImageNet Large-Scale Visual Recognition Challenge，从2010年开始举办，20
经典论文之ResNet
阿基美德的博客
08-26 4150
ResNet 原论文：Deep Residual Learning for Image Recognition ILSVRC2015冠军（分类、定位、检测）。通过残差块训练了152层网络。 解决了退化问题（plain网络随着网络加深，错误率升高） 网络加深：会出现梯度消失或梯度爆炸，这个问题可以通过正则初始化和BN来解决。 退化问题：深层网络到了一定深度，准确率趋近饱和，而且继续加深会降低准确率（degradation问题）。 这个问题并不是过拟合导致的（过拟合在训练集应该更好），也不是梯度消失造成的（论
ResNet网络搭建（tensorflow，keras）
qq_57780419的博客
04-08 1841
ResNet网络搭建（tensorflow，keras）
Tensorflow学习：ResNet代码（详细剖析）
初学者的博客
03-24 4224
https://blog.csdn.net/superman_xxx/article/details/65452735 https://blog.csdn.net/qq_29893385/article/details/81207203 https://blog.csdn.net/zzc15806/article/details/83540661 https://blog.csdn.net/...
用Tensorflow来预处理Imagenet数据
10-27 7778
[备注：我的另外一篇博文对这个Imagenet的数据处理过程有更新，请参考： https://blog.csdn.net/gzroy/article/details/85954329] 最近想以Imagenet 2012图像分类大赛的数据来进行训练和测试，看看如何能利用这么大量的图像数据来完善卷积神经网络模型。之前做的基于Cifar10的数据量还是大小了，类别也不够多。Imagenet的数据总共...
tensorflow下实现ResNet系列网络进行图片分类
在人工智能与机器学习领域，卷积神经网络（CNN）一直是图像识别与分类任务的核心技术之一。在众多的CNN架构中，残差网络（Residual Networks，简称ResNet）因其突破性的性能在多个图像处理比赛中取得了卓越的成绩。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值