CNN ResNet

最新推荐文章于 2024-12-14 05:00:00 发布
最新推荐文章于 2024-12-14 05:00:00 发布
阅读量271 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Python_TensorFlow 文章标签： CNN ResNet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30534935/article/details/89647757

代码抄写自《tensorflow实战》一书，以便大家运行测试学习。

# -*- coding: utf-8 -*-
#import os
#os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
 
# ResNet V2
# 载入模块、TensorFlow
import collections
import tensorflow as tf
 
slim = tf.contrib.slim
 
# 定义Block
class Block(collections.namedtuple('Block', ['scope', 'unit_fn', 'args'])):
    'A named tuple describing a ResNet block'
 
# 定义降采样subsample方法
def subsample(inputs, factor, scope=None):
 
    if factor == 1:
        return inputs
    else:
        return slim.max_pool2d(inputs, [1, 1], stride=factor, scope=scope)
 
# 定义conv2d_same函数创建卷积层
def conv2d_same(inputs, num_outputs, kernel_size, stride, scope=None):
 
    if stride == 1:
        return slim.conv2d(inputs, num_outputs, kernel_size, stride=1,
                           padding='SAME', scope=scope)
    else:
        # kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
        pad_total = kernel_size - 1
        pad_beg = pad_total // 2
        pad_end = pad_total - pad_beg
        inputs = tf.pad(inputs,
                        [[0, 0], [pad_beg, pad_end], [pad_beg, pad_end], [0, 0]])
        return slim.conv2d(inputs, num_outputs, kernel_size, stride=stride,
                           padding='VALID', scope=scope)
 
 
@slim.add_arg_scope
# 定义堆叠Blocks函数，两层循环
def stack_blocks_dense(net, blocks,
                       outputs_collections=None):
 
    for block in blocks:
        with tf.variable_scope(block.scope, 'block', [net]) as sc:
            for i, unit in enumerate(block.args):
                with tf.variable_scope('unit_%d' % (i + 1), values=[net]):
                    unit_depth, unit_depth_bottleneck, unit_stride = unit
                    net = block.unit_fn(net,
                                        depth=unit_depth,
                                        depth_bottleneck=unit_depth_bottleneck,
                                        stride=unit_stride)
            net = slim.utils.collect_named_outputs(outputs_collections, sc.name, net)
 
    return net
 
# 创建ResNet通用arg_scope，定义函数默认参数值
def resnet_arg_scope(is_training=True,
                     weight_decay=0.0001,
                     batch_norm_decay=0.997,
                     batch_norm_epsilon=1e-5,
                     batch_norm_scale=True):
 
    batch_norm_params = {
        'is_training': is_training,
        'decay': batch_norm_decay,
        'epsilon': batch_norm_epsilon,
        'scale': batch_norm_scale,
        'updates_collections': tf.GraphKeys.UPDATE_OPS,
    }
 
    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_sc:
                return arg_sc
 
 
@slim.add_arg_scope
# 定义核心bottleneck残差学习单元
def bottleneck(inputs, depth, depth_bottleneck, stride,
               outputs_collections=None, scope=None):
 
    with tf.variable_scope(scope, 'bottleneck_v2', [inputs]) as sc:
        depth_in = slim.utils.last_dimension(inputs.get_shape(), min_rank=4)
        preact = slim.batch_norm(inputs, activation_fn=tf.nn.relu, scope='preact')
        if depth == depth_in:
            shortcut = subsample(inputs, stride, 'shortcut')
        else:
            shortcut = slim.conv2d(preact, depth, [1, 1], stride=stride,
                                   normalizer_fn=None, activation_fn=None,
                                   scope='shortcut')
 
        residual = slim.conv2d(preact, depth_bottleneck, [1, 1], stride=1,
                               scope='conv1')
        residual = conv2d_same(residual, depth_bottleneck, 3, stride,
                               scope='conv2')
        residual = slim.conv2d(residual, depth, [1, 1], stride=1,
                               normalizer_fn=None, activation_fn=None,
                               scope='conv3')
 
        output = shortcut + residual
 
        return slim.utils.collect_named_outputs(outputs_collections,
                                                sc.name,
                                                output)
 
# 定义生成ResNet V2的主函数
def resnet_v2(inputs,
              blocks,
              num_classes=None,
              global_pool=True,
              include_root_block=True,
              reuse=None,
              scope=None):
 
    with tf.variable_scope(scope, 'resnet_v2', [inputs], reuse=reuse) as sc:
        end_points_collection = sc.original_name_scope + '_end_points'
        with slim.arg_scope([slim.conv2d, bottleneck,
                             stack_blocks_dense],
                            outputs_collections=end_points_collection):
            net = inputs
            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='pool1')
            net = stack_blocks_dense(net, blocks)
 
            net = slim.batch_norm(net, activation_fn=tf.nn.relu, scope='postnorm')
            if global_pool:
                # Global average pooling.
                net = tf.reduce_mean(net, [1, 2], name='pool5', keep_dims=True)
            if num_classes is not None:
                net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
                                  normalizer_fn=None, scope='logits')
            # Convert end_points_collection into a dictionary of end_points.
            end_points = slim.utils.convert_collection_to_dict(end_points_collection)
            if num_classes is not None:
                end_points['predictions'] = slim.softmax(net, scope='predictions')
            return net, end_points
 
# 设计层数为50的ResNet V2
def resnet_v2_50(inputs,
                 num_classes=None,
                 global_pool=True,
                 reuse=None,
                 scope='resnet_v2_50'):
    blocks = [
        Block('block1', bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
        Block(
            'block2', bottleneck, [(512, 128, 1)] * 3 + [(512, 128, 2)]),
        Block(
            'block3', bottleneck, [(1024, 256, 1)] * 5 + [(1024, 256, 2)]),
        Block(
            'block4', bottleneck, [(2048, 512, 1)] * 3)]
    return resnet_v2(inputs, blocks, num_classes, global_pool,
                     include_root_block=True, reuse=reuse, scope=scope)
 
# 设计101层的ResNet V2
def resnet_v2_101(inputs,
                  num_classes=None,
                  global_pool=True,
                  reuse=None,
                  scope='resnet_v2_101'):
    blocks = [
        Block(
            'block1', bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
        Block(
            'block2', bottleneck, [(512, 128, 1)] * 3 + [(512, 128, 2)]),
        Block(
            'block3', bottleneck, [(1024, 256, 1)] * 22 + [(1024, 256, 2)]),
        Block(
            'block4', bottleneck, [(2048, 512, 1)] * 3)]
    return resnet_v2(inputs, blocks, num_classes, global_pool,
                     include_root_block=True, reuse=reuse, scope=scope)
 
# 设计152层的ResNet V2
def resnet_v2_152(inputs,
                  num_classes=None,
                  global_pool=True,
                  reuse=None,
                  scope='resnet_v2_152'):
    blocks = [
        Block(
            'block1', bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
        Block(
            'block2', bottleneck, [(512, 128, 1)] * 7 + [(512, 128, 2)]),
        Block(
            'block3', bottleneck, [(1024, 256, 1)] * 35 + [(1024, 256, 2)]),
        Block(
            'block4', bottleneck, [(2048, 512, 1)] * 3)]
    return resnet_v2(inputs, blocks, num_classes, global_pool,
                     include_root_block=True, reuse=reuse, scope=scope)
 
# 设计200层的ResNet V2
def resnet_v2_200(inputs,
                  num_classes=None,
                  global_pool=True,
                  reuse=None,
                  scope='resnet_v2_200'):
    blocks = [
        Block(
            'block1', bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
        Block(
            'block2', bottleneck, [(512, 128, 1)] * 23 + [(512, 128, 2)]),
        Block(
            'block3', bottleneck, [(1024, 256, 1)] * 35 + [(1024, 256, 2)]),
        Block(
            'block4', bottleneck, [(2048, 512, 1)] * 3)]
    return resnet_v2(inputs, blocks, num_classes, global_pool,
                     include_root_block=True, reuse=reuse, scope=scope)
 
 
from datetime import datetime
import math
import time
 
# # 评测函数
# def time_tensorflow_run(session, target, info_string):
#     num_steps_burn_in = 10
#     total_duration = 0.0
#     total_duration_squared = 0.0
#     for i in range(num_batches + num_steps_burn_in):
#         start_time = time.time()
#         _ = session.run(target)
#         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
#     mn = total_duration / num_batches
#     vr = total_duration_squared / num_batches - mn * mn
#     sd = math.sqrt(vr)
#     print('%s: %s across %d steps, %.3f +/- %.3f sec / batch' %
#           (datetime.now(), info_string, num_batches, mn, sd))
 
 
batch_size = 32
height, width = 224, 224
inputs = tf.random_uniform((batch_size, height, width, 3))
with slim.arg_scope(resnet_arg_scope(is_training=False)):
    net, end_points = resnet_v2_152(inputs, 1000) # 152层评测
 
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
num_batches = 100
time_tensorflow_run(sess, net, "Forward")
CNN和ResNet
qq_56468628的博客
08-27 2597
卷积神经网络（Convolutional Neural Networks, CNN）是一类包含卷积计算且具有深度结构的前馈神经网络（Feedforward Neural Networks），是深度学习（deep learning）的代表算法之一。
CNN经典网络：ResNet系列
qq_39382877的博客
07-27 466
前言 ResNetV1 ResNetV2 ResNetV1 论文：https://arxiv.org/pdf/1512.03385v1.pdf 代码：参考Tensorflow/slim 特点 第一次提出残差结构，主要解决两个问题 梯度消失 随着网络深度增加，性能没有提升反而有所下降 如下图，本来要学习H(x)，现在转换为F(x)+x，二者效果相同，但是优化难度下降，并且因为多了一个x...
CNN——ResNet
weixin_64924692的博客
01-07 2569
无论是VGG还是GoogleNet都表明增加网络的深度的重要性，网络越深可以提取到越高级的特征。那么是否意味着直接简单的将网络堆深是不是就可以了？增加网络深度首先会带来的问题就是梯度消失或者梯度爆炸导致难以收敛，但这个问题已经可以通过合适的权重初始化手段，Xavier初始化，MSRA 初始化还有Batch Normalization解决。另一个问题便是网络退化现象，这既不是梯度消失或者梯度爆炸导致也不是过拟合导致的，如下图所示，56层网络在训练集和测试集上的误差都比20层网络大。
CNN——AlexLet
m0_43425029的博客
02-08 430
import torch import torchvision from torch import nn from torch.utils.data import Dataset,DataLoader from torchvision import transforms from d2l import torch as d2l def load_data_fashion_mnist(batch_size,resize): trans = [] if resize: tr.
ResNet——CNN经典网络模型详解(pytorch实现)
热门推荐
weixin_44023658的博客
04-29 15万+
1、前言 ResNet（Residual Neural Network）由微软研究院的Kaiming He等四名华人提出，通过使用ResNet Unit成功训练出了152层的神经网络，并在ILSVRC2015比赛中取得冠军，在top5上的错误率为3.57%，同时参数量比VGGNet低，效果非常突出。ResNet的结构可以极快的加速神经网络的训练，模型的准确率也有比较大的提升。同时ResNet的推广...
RadioML2016.10.a MLP CNN ResNet Code
06-19
RadioML2016.10.a MLP CNN ResNet Code 是一个与机器学习相关的项目，主要涉及了深度学习中的两种重要模型：多层感知机（MLP）和卷积神经网络（CNN），以及ResNet（残差网络）的实现。这个项目的完整代码库可能包含...
keras-frcnn.zip_RCNN 分类_faster-rcnn_keras CNN resnet_keras frcn
07-15
"keras-frcnn.zip_RCNN 分类_faster-rcnn_keras CNN resnet_keras frcn" 这个标题提到了几个关键术语，它们分别是： 1. **RCNN (Region-based Convolutional Neural Network)**：RCNN是一种用于目标检测的深度学习...
CNN resnet vgg
最新发布
02-22
### 比较 CNN、ResNet 和 VGG 架构及其差异 #### 卷积神经网络 (CNN) 卷积神经网络是一种专门设计用于处理具有网格结构的数据（如图像）的深层神经网络架构。其核心组件包括卷积层、池化层和全连接层。通过这些...
深度学习——知识点总结1( Resnet )
07-08 1983
阿里面试题： 1。 resnet相关知识点+作用+为什么会起作用： （0）问题的提出 与 残差块 网络层数增多一般会伴着下面几个问题 计算资源的消耗。 （问题1可以通过GPU集群来解决） 模型容易过拟合。 （问题2的过拟合通过采集海量数据，并配合Dropout正则化等方法也可以有效避免） 梯度消失/梯度爆炸问题的产生。 （问题3通过正则化初始化和中间的正则化层（Batch Norm...
CNN版本的ResNet
weixin_43872912的博客
07-04 223
因为最近要看一篇ResNet版本的SNN网络，所以去了解了一下ResNet。这是一种深度残差网络， def _block(self, x, n_out, n, init_stride=2, is_training=True, scope="block"): with tf.variable_scope(scope): h_out = n_out // 4 out = self._bottleneck(x, h_out, n_out, stride=init_strid
经典CNN模型（五）：ResNet（PyTorch详细注释版）
qq_51872445的博客
07-25 8268
ResNet，即残差神经网络（Residual Neural Network），是由何凯明（Kaiming He）、张祥雨、任少卿和孙剑在 2015 年提出的一种深度学习架构，旨在解决深度神经网络中的退化问题。在传统的深度神经网络中，随着网络层数的增加，训练误差会逐渐增大，这种现象被称为“退化”。ResNet 通过引入一种特殊的残差学习框架来解决这一问题，允许网络学习更深层次的结构，而不遭受退化问题的影响。
CNN架构之ResNet
weixin_45268911的博客
07-18 1546
CNN架构之ResNet ResNet在2015年的ImageNet大规模视觉识别竞赛（ImageNet Large Scale Visual Recognition Challenge, ILSVRC）中获得了图像分类和物体识别的优胜，名声大噪。在此之前，AlexNet——2012年ImageNet的获胜者，这个模型仅有8个卷积层的深度学习，后来的VGG网络有16乃至19层，GoogleNet有22层，而ResNet 有152层。随着模型变得越来越深，Top-5的错误率也越来越低，目前降到了3.5%附近
CNN与ResNet联系与区别
geo436872的博客
06-03 1万+
在传统的CNN中，信息从输入一直通过各个层向前传播，而ResNet则在传统CNN基础上增加了残差块，在ResNet中，每个残差块包含了多个卷积层和一条跨过若干层的“捷径”（shortcut connection），使得信息可以直接从前面的某一层传到后面的某一层。由于残差块的使用，ResNet可以训练更深的神经网络，例如ResNet-152就有152个卷积层，并且在训练误差和测试误差上都表现出了更好的性能。而ResNet是残差网络，是一种在CNN基础上的变体，通过引入残差块来训练更深层次的神经网络。
（5）机器学习算法知识---CNN与ResNet
zjj1910066023的博客
05-25 7788
文章目录二、ResNet（残差网络）总结 普通神经网络是由输入层、隐藏层、输出层组成，当参数过多，训练就会变的很慢，这个时候就可以减少参数。 输入层：输入的不是一个特征，一个维度，而是一个长方体的矩阵（三维的） 卷积层：提取特征。 举例：输入一个数据维度是7x7x3，7x7表示图像h=7，w=7，有三个通道。Filter W0表示先随机初始化一组权重参数，这里强调一下，输入数据维度通道数与Filter W0维度数是一样的，这里都是3，Filter W0中 3x3x3的矩阵我们称作**卷积核。**计
CNN 经典网络之-ResNet
qq_43703185的博客
03-19 673
原文链接：https://www.cnblogs.com/yanshw/p/10576354.html resnet 又叫深度残差网络 图像识别准确率很高，主要作者是国人哦   深度网络的退化问题 深度网络难以训练，梯度消失，梯度爆炸，老生常谈，不多说 resnet 解决了这个问题，并且将网络深度扩展到了最多152层。怎么解决的呢？   残差学习 结构如图 &nb...
【深度学习进阶】CNN-ResNet
专注上位机开发、机器视觉、机器学习、嵌入式软硬件开发
12-14 9096
ResNet（残差网络，Residual Network）是由微软研究院的研究人员在2015年提出的一种深度卷积神经网络架构，它解决了训练非常深的网络时遇到的主要挑战之一——退化问题。随着网络深度增加，训练误差不再继续减小反而开始增加，这并不是由于过拟合引起的。ResNet通过引入“残差学习”框架来解决这个问题，极大地推动了深度学习的发展，并在多个计算机视觉任务中取得了优异的成绩。
【论文阅读】【cnn】resnet
Chen_Swan的博客
04-22 570
resnet解决的是网络的退化问题。在vgg中提出，增加网络深度可以增加模型的表达能力。但是人们发现深度达到一定之后，CNN网络再一味增加层数并不能带来分类性能的提高，甚至会让网络收敛变慢，测试集精度下降。训练集精度下降可以说明这个不是过拟合的原因。因此resnet提出这是网络的“退化问题”。 深度神经网络可以拟合各种表示，按道理说，n+1层的cnn的解空间包含了n层的cnn的解空间，因此n+1...
经典cnn之resnet
qq_32110859的博客
01-19 327
https://arxiv.org/pdf/1512.03385.pdf#page=9&zoom=100,0,157 摘要  residual 残余的 We provide comprehensive empirical evidence showing that these residual networks are easier to optimize, and can gai...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值