网络结构之 GoogleNet(Inception V1)

最新推荐文章于 2024-08-27 19:30:00 发布
最新推荐文章于 2024-08-27 19:30:00 发布
阅读量2.4k 收藏 5
点赞数
分类专栏： 网络结构 图像分类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zziahgf/article/details/82801050
版权

原文：AIUAI -网络结构之 GoogleNet(Inception V1)

GoogleNet - Going deeper with convolutions - 2014

GoogleNet，即 Inception V1 网络结构，包含 9 个 Inception 结构：

GoogleNet - Netscope

Inception 结构(网络宽度)：

每个 Inception 结构有 4 个分支，主要包含 1x1, 3x3, 5x5 卷积核和 max pooling 操作(pooling 的步长为 1，以保持输出特征层的尺寸与卷积核输出尺寸一致). 1x1 卷积核核的作用是降维，以避免 cancatenation 操作导致特征层过深，并减少网络参数.

Tensorflow Slim 的 Inception V1 定义

Tensorflow Slim 中的 Inception V1 里采用的卷积核只有 1x1 和 3x3 两种，没有 5x5 的卷积核.

"""
Inception V1 分类网络的定义. 
"""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf

from nets import inception_utils

slim = tf.contrib.slim
trunc_normal = lambda stddev: tf.truncated_normal_initializer(0.0, stddev)


def inception_v1_base(inputs,
                      final_endpoint='Mixed_5c',
                      scope='InceptionV1'):
  """
  Inception V1 基础结构定义.

  参数：
  inputs: Tensor，尺寸为 [batch_size, height, width, channels].
  final_endpoint: 指定网络定义结束的节点endpoint，即网络深度. 
                          候选值： ['Conv2d_1a_7x7', 'MaxPool_2a_3x3', 'Conv2d_2b_1x1',
						  'Conv2d_2c_3x3', 'MaxPool_3a_3x3', 'Mixed_3b', 'Mixed_3c',
						  'MaxPool_4a_3x3', 'Mixed_4b', 'Mixed_4c', 'Mixed_4d', 'Mixed_4e',
						  'Mixed_4f', 'MaxPool_5a_2x2', 'Mixed_5b', 'Mixed_5c']
    scope: 可选变量作用域 variable_scope.

  返回值:
      字典，包含网络各层的激活值.

  Raises:
    ValueError: if final_endpoint is not set to one of the predefined values.
  """
  end_points = {}
  with tf.variable_scope(scope, 'InceptionV1', [inputs]):
    with slim.arg_scope(
        [slim.conv2d, slim.fully_connected],
        weights_initializer=trunc_normal(0.01)):
      with slim.arg_scope([slim.conv2d, slim.max_pool2d],
                          stride=1, padding='SAME'):
        end_point = 'Conv2d_1a_7x7'
        net = slim.conv2d(inputs, 64, [7, 7], stride=2, scope=end_point)
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points
        end_point = 'MaxPool_2a_3x3'
        net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points
        end_point = 'Conv2d_2b_1x1'
        net = slim.conv2d(net, 64, [1, 1], scope=end_point)
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points
        end_point = 'Conv2d_2c_3x3'
        net = slim.conv2d(net, 192, [3, 3], scope=end_point)
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points
        end_point = 'MaxPool_3a_3x3'
        net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_3b'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 96, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 128, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 16, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 32, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 32, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_3c'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 192, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 32, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'MaxPool_4a_3x3'
        net = slim.max_pool2d(net, [3, 3], stride=2, scope=end_point)
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_4b'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 96, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 208, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 16, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 48, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_4c'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 112, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 224, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 24, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 64, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_4d'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 256, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 24, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 64, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_4e'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 112, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 144, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 288, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 32, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 64, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_4f'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 256, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 320, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 32, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 128, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 128, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'MaxPool_5a_2x2'
        net = slim.max_pool2d(net, [2, 2], stride=2, scope=end_point)
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_5b'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 256, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 320, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 32, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 128, [3, 3], scope='Conv2d_0a_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 128, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points

        end_point = 'Mixed_5c'
        with tf.variable_scope(end_point):
          with tf.variable_scope('Branch_0'):
            branch_0 = slim.conv2d(net, 384, [1, 1], scope='Conv2d_0a_1x1')
          with tf.variable_scope('Branch_1'):
            branch_1 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
            branch_1 = slim.conv2d(branch_1, 384, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_2'):
            branch_2 = slim.conv2d(net, 48, [1, 1], scope='Conv2d_0a_1x1')
            branch_2 = slim.conv2d(branch_2, 128, [3, 3], scope='Conv2d_0b_3x3')
          with tf.variable_scope('Branch_3'):
            branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
            branch_3 = slim.conv2d(branch_3, 128, [1, 1], scope='Conv2d_0b_1x1')
          net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])
        end_points[end_point] = net
        if final_endpoint == end_point: return net, end_points
    raise ValueError('Unknown final endpoint %s' % final_endpoint)


def inception_v1(inputs,
                 num_classes=1000,
                 is_training=True,
                 dropout_keep_prob=0.8,
                 prediction_fn=slim.softmax,
                 spatial_squeeze=True,
                 reuse=None,
                 scope='InceptionV1',
                 global_pool=False):
  """
  Inception V1 结构的定义.

  参数:
    inputs: Tensor，尺寸为 [batch_size, height, width, channels].
    num_classes: 待预测的类别数. 如果 num_classes=0或None，则忽略 logits 层；返回 logits 层的输入特征(dropout 层前的网络层).
    is_training: 是否是训练阶段.
    dropout_keep_prob: 保留的激活值的比例.
    prediction_fn: 计算 logits 预测值输出的函数，如softmax.
    spatial_squeeze: 如果是 True, logits 的 shape 是 [B, C]；
	                            如果是 false，则 logits 的 shape 是 [B, 1, 1, C]；
								其中，B 是 batch_size，C 是类别数.
    reuse: 是否重用网络及网络的变量值.
			   如果需要重用，则必须给定重用的 'scope'.
    scope: 可选变量作用域 variable_scope.
    global_pool: 可选 boolean 值，选择是否在 logits 网络层前使用 avgpooling 层.
						默认值是 fasle，则采用固定窗口的 pooling 层，将 inputs 降低到 1x1.
						inputs 越大，则 outputs 越大.
						如果值是 true, 则任何 inputs 尺寸都 pooled 到 1x1.

  返回值:
    net: Tensor，如果 num_classes 为非零值，则返回 logits(pre-softmax activations).
	       如果 num_classes 是 0 或 None，则返回 logits 网络层的 non-dropped-out 输入.
    end_points: 字典，包含网络各层的激活值.
  """
  # Final pooling and prediction
  with tf.variable_scope(scope, 'InceptionV1', [inputs], reuse=reuse) as scope:
    with slim.arg_scope([slim.batch_norm, slim.dropout],
                        is_training=is_training):
      net, end_points = inception_v1_base(inputs, scope=scope)
      with tf.variable_scope('Logits'):
        if global_pool:
          # Global average pooling.
          net = tf.reduce_mean(net, [1, 2], keep_dims=True, name='global_pool')
          end_points['global_pool'] = net
        else:
          # Pooling with a fixed kernel size.
          net = slim.avg_pool2d(net, [7, 7], stride=1, scope='AvgPool_0a_7x7')
          end_points['AvgPool_0a_7x7'] = net
        if not num_classes:
          return net, end_points
        net = slim.dropout(net, dropout_keep_prob, scope='Dropout_0b')
        logits = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
                             normalizer_fn=None, scope='Conv2d_0c_1x1')
        if spatial_squeeze:
          logits = tf.squeeze(logits, [1, 2], name='SpatialSqueeze')

        end_points['Logits'] = logits
        end_points['Predictions'] = prediction_fn(logits, scope='Predictions')
  return logits, end_points
inception_v1.default_image_size = 224

inception_v1_arg_scope = inception_utils.inception_arg_scope
AIHGF
关注
专栏目录
InceptionV1网络
gzy_wyu的博客
02-10 3006
个人笔记 感谢指正 InceptionV1 参考来源：https://zhuanlan.zhihu.com/p/73828787 https://zhuanlan.zhihu.com/p/42124583 InceptionV1简介 InceptionV1 是GooLeNet另一个称呼，GooLeNet深度只有22层，但大小却比AlexNet和VGG小很多，GooLeNet的参数为500万个，Al...
谈Inception V1网络结构 与 GoogLeNet
MasterMiao的博客
08-15 745
谈Inception网络结构1 x 1 卷积核Inception V1Inception V2Inception V3Inception V4参考文章 1 x 1 卷积核         此观点是在 Network in Network（NIN）中提出，那这样的卷积有什么用处呢？先回顾下相关基础概念吧~         卷积核： 可以看作对某个**局部**的加权求和；它是对应局部感知，它的原理是在观察某个物体时我们既不能观察每
Googlenet inception v1网络结构详解
12-27
总结了很多牛人的知识，解释了自己的很多疑点。
深度学习--Inception-ResNet-v1网络结构
dulingtingzi的博客
04-09 3500
本文转载自：https://blog.csdn.net/lovelyaiq/article/details/79026181，只有一小部分根据自己的理解做了修整版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/lovelyaiq/article/details/79026181目录(?)[-]Stem结构Inception-resnet-A模块Red...
跟着问题学8——GoogLeNet网络详解及代码实战
最新发布
weixin_42251091的博客
08-27 1028
GoogLeNet是2014年Christian Szegedy等人在2014年大规模视觉挑战赛(ILSVRC-2014)上使用的一种全新卷积神经网络结构，并以6.65%的错误率力压VGGNet等模型取得了ILSVRC-2014在分类任务上的冠军，于2015年在CVPR发表了论文《Going Deeper with Convolutions》。
19_谷歌GoogLeNet(InceptionV1)深度学习图像分类算法
https://github.com/foxpup11?tab=repositories
07-08 969
https://www.bilibili.com/video/BV17g411L7Se/?spm_id_from=333.999.0.0&vd_source=7dace3632125a1ef7fd32c285eb2fbac
InceptionV1网络结构讲解（Tensorflow-2.6.0实现结构）
Keep_Trying_Go的博客
04-19 2491
文章目录1.结构表2.InceptionV1提升网络性能的方法3.InceptionV1模块（1）模块一（2）模块二 （改进模块）4.网络结构5.关于1x1的作用6.Multi-scale processing 1.结构表 2.InceptionV1提升网络性能的方法 传统的模块提升网络性能的方法是增加网络深度和宽度（卷积核的个数），但是会存在一些问题： 1.参数量太大，如果训练数据集有限，很容易产生过拟合。 2.网络模型越大，参数越多，则计算复杂度越大，对内存的占用和计算量的要求很高。 3.网络结构越
inception v1 网络结构
DeepCBW的博客
01-14 365
轻量级神经网络架构Inception-V1
weixin_48678602的博客
05-07 1162
谷歌自从2014年提出GoogleNet 网络模型，又叫Inception网络，目前有inception-v1、inception-v2、inception-v3、inception-v4四个框架。inception与ResNet结合成INception-ResNet-V1和INception-ResNet-V2等多个版本，给轻量化网络模型提供了很多可参考的意义，inception模块都是基于在Inception V1的基础上进行优化改进，主要介绍一下inception-V1的网络架构和INception-
inception v1 结构图
页页读
09-30 641
GoogLeNet Inception v1 结构 及 pytorch、tensorflow、keras、paddle实现ImageNet识别
01-20
GoogLeNet是谷歌在imageNet上的ILSVRC 2014大赛冠军方案，论文“Going deeper with convolutions”网络主要部分有Inception模块组成，v1版本的核心思想是通过多个并行的稀疏结构代替密集结构，从而在扩大特征范围的...
googlenet网络图
07-08
caffe, GoogLeNet网络流程图，对整体有一个更好的审视。
GoogLeNet Inception v1详解
For_learning的博客
03-10 363
GoogLeNet Inception v1 论文《Going Deeper with Convolutions》 1. 研究背景 提高神经网络的性能，最直接的方法就是增加神经网络的大小，大小包括了网络的深度和宽度。 但是一味地增加网络大小，会带来一些不利的影响： 神经网络的大小增加，会带来大量的参数，模型更容易出现过拟合问题； 神经网络的大小增加，会使模型在训练过程中的计算开销增加。 解决上述问题方法，在模型中引入稀疏性（sparsity），用一个稀疏的网络结构去代替现有的全连接网络结构，以减少网
深度学习经典网络：Inception系列网络（Inception v1 & Inception v2(BN)）
weixin_42615068的博客
07-28 1138
Inception v1(GoogleNet): https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43022.pdf Inception v2: https://arxiv.org/pdf/1502.03167.pdf 一、Inception v1 Motivation:   2014年...
『GoogLeNet』inception
七秒钟的记忆
03-03 229
inception模块
GoogLeNet v1结构
helluy的博客
11-16 2023
GooLeNetInception块GooLeNet GooLeNet是google2014年推出的深度神经网络模型，原论文名称为：Going deeper with convolutions，在沐神的书上也被叫做含并⾏连结的⽹络（主要由于Inception块中的结构）。该模型在2014年ILSVRC 2014比赛中竞赛中夺得冠军，14年之后也在不断发展，这里就介绍一下初始的版本。 Inception块 GooLeNet思想有点类似于VGG，先构建块，网络主要通过块的堆叠实现，不过这里的块与VGG块不同，称
深度学习方法（十一）：卷积神经网络结构变化——Google Inception V1-V4，Xception（depthwise convolution）...
weixin_30549657的博客
03-15 399
欢迎转载，转载请注明：本文出自Bin的专栏blog.csdn.net/xbinworld。 技术交流QQ群：433250724，欢迎对算法、机器学习技术感兴趣的同学加入。 上一篇讲了深度学习方法（十）：卷积神经网络结构变化——Maxout Networks，Network In Network，Global Average Pooling，本篇讲一讲Google的Inc...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值