Tensorflow实现Google Inception Net

最新推荐文章于 2025-09-12 06:34:33 发布
原创 最新推荐文章于 2025-09-12 06:34:33 发布 · 234 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#tensorflow #inception net

本文介绍如何使用TensorFlow实现InceptionNet，并针对ImageNet数据集进行了实验。InceptionNet的特点包括分支结构、1X1卷积及BatchNormalization。此外，文章还提供了一个性能测试示例。

今天对照Tensorflow的书，实现了Inception Net。在Inception Net实际应用时，是基于ImageNet的。考虑到耗时，在本篇博客（甚至是在Tensorflow的书中），只计算每个batch的前馈计算（Forward）。

Inception Net最大的几个特点：

1. 使用了分支结构，并使用concat将分支结合在一起

2. 使用1X1的卷积，可以低成本的将特征进行跨通道的组合

3. 使用Batch Normalization(BN)，对每个batch的数据进行标准化处理，使输出规范到N（0， 1）的正态分布

代码如下：

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

# slim是一个使构建，训练，评估神经网络变得简单的库，相当于模板
slim = tf.contrib.slim
# 用lambda定义一个简单的函数，产生截断的正态分布
trunc_normal = lambda stddev: tf.truncated_normal_initializer(0.0, stddev)


# 用来生成网络中经常用到的函数的默认参数，比如卷积的激活函数、标准化器等
# moving_vars用以完成平均滑动
def inception_v3_arg_scope(weight_decay=0.00004,
                           stddev=0.1,
                           batch_norm_var_collection='moving_vars'):
    # 用以使输出保持分布相同
    batch_norm_params = {
        'decay': 0.9997,
        'epsilon': 0.001,
        'updates_collections': tf.GraphKeys.UPDATE_OPS,
        'variables_collections': {
            'beta': None,
            'gamma': None,
            'moving_mean': [batch_norm_var_collection],
            'moving_variance': [batch_norm_var_collection],
        }
    }

    with slim.arg_scope([slim.conv2d, slim.fully_connected],
                        weights_regularizer=slim.l2_regularizer(weight_decay)):
        with slim.arg_scope(
                [slim.conv2d],
                weights_initializer=tf.truncated_normal_initializer(stddev=stddev),
                activation_fn=tf.nn.relu,
                normalizer_fn=slim.batch_norm,
                normalizer_params=batch_norm_params) as sc:
            return sc


# 用以生成网络的卷积部分
def inception_v3_base(inputs, scope=None):
    # 用来保存某些关键节点以供之后使用
    end_points = {}

    # 为slim.conv2d,slim.max_pool2d,slim.avg_pool2d三个函数设置默认的stride,padding参数值
    with tf.variable_scope(scope, 'InceptionV3', [inputs]):
        with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
                            stride=1, padding='VALID'):
            # conv2d(输入的tensor, 通道数, 卷积核尺寸, 步长, padding模式)
            net = slim.conv2d(inputs, 32, [3, 3], stride=2, scope='Conv2d_1a_3X3')
            net = slim.conv2d(net, 32, [3, 3], scope='Conv2d_2a_3X3')
            net = slim.conv2d(net, 64, [3, 3], padding='SAME',
                              scope='Conv2d_2b_3X3')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='MaxPool_3a_3X3')
            # 1X1的卷积核可以低成本的将特征进行跨通道组合
            net = slim.conv2d(net, 80, [1, 1], scope='Conv2d_3b_1X1')
            net = slim.conv2d(net, 192, [3, 3], scope='Conv2d_4a_3X3')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='MaxPool_5a_3X3')

        # 第一个inception模块组
        # 第一个inception module
        # 最后通过concat将四个分支合并
        with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
                            stride=1, padding='SAME'):
            with tf.variable_scope('Mixed_5b'):
                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, 48, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = slim.conv2d(branch_1, 64, [5, 5],
                                           scope='Conv2d_0b_5X5')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3],
                                           scope='Conv2d_0b_3X3')
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3],
                                           scope='Conv2d_0c_3X3')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 32, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)

            # 第二个inception module
            with tf.variable_scope('Mixed_5c'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0b_1X1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 48, [1, 1], scope='Conv2d_0b_1X1')
                    branch_1 = slim.conv2d(branch_1, 64, [5, 5],
                                           scope='Conv2d_0c_5X5')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3],
                                           scope='Conv2d_0b_3X3')
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3],
                                           scope='Conv2d_0c_3X3')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 64, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)

            # 第三个inception module
            with tf.variable_scope('Mixed_5d'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0b_1X1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 48, [1, 1], scope='Conv2d_0b_1X1')
                    branch_1 = slim.conv2d(branch_1, 64, [5, 5],
                                           scope='Conv2d_0c_5X5')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3],
                                           scope='Conv2d_0b_3X3')
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3],
                                           scope='Conv2d_0c_3X3')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 64, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)

            # 第二个inception模块组
            # 第一个inception module
            with tf.variable_scope('Mixed_6a'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 384, [3, 3], stride=2,
                                           padding='VALID', scope='Conv2d_1a_1X1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = slim.conv2d(branch_1, 96, [3, 3],
                                           scope='Conv2d_0b_3X3')
                    branch_1 = slim.conv2d(branch_1, 96, [3, 3], stride=2,
                                           padding='VALID', scope='Conv2d_1a_1X1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.max_pool2d(net, [3, 3], stride=2, padding='VALID',
                                               scope='MaxPool_1a_3X3')
                net = tf.concat([branch_0, branch_1, branch_2], 3)

            # 第二个inception module
            with tf.variable_scope('Mixed_6b'):
                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, 128, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = slim.conv2d(branch_1, 128, [1, 7],
                                           scope='Conv2d_0b_1X7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1],
                                           scope='Conv2d_0c_7X1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 128, [7, 1],
                                           scope='Conv2d_0b_7X1')
                    branch_2 = slim.conv2d(branch_2, 128, [1, 7],
                                           scope='Conv2d_0c_1X7')
                    branch_2 = slim.conv2d(branch_2, 128, [7, 1],
                                           scope='Conv2d_0d_7X1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7],
                                           scope='Conv2d_0e_1X7')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)

            # 第三个inception module
            with tf.variable_scope('Mixed_6c'):
                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, 160, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = slim.conv2d(branch_1, 128, [1, 7],
                                           scope='Conv2d_0b_1X7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1],
                                           scope='Conv2d_0c_7X1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1],
                                           scope='Conv2d_0b_7X1')
                    branch_2 = slim.conv2d(branch_2, 160, [1, 7],
                                           scope='Conv2d_0c_1X7')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1],
                                           scope='Conv2d_0d_7X1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7],
                                           scope='Conv2d_0e_1X7')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)

            # 第四个inception module
            with tf.variable_scope('Mixed_6d'):
                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, 160, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = slim.conv2d(branch_1, 128, [1, 7],
                                           scope='Conv2d_0b_1X7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1],
                                           scope='Conv2d_0c_7X1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1],
                                           scope='Conv2d_0b_7X1')
                    branch_2 = slim.conv2d(branch_2, 160, [1, 7],
                                           scope='Conv2d_0c_1X7')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1],
                                           scope='Conv2d_0d_7X1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7],
                                           scope='Conv2d_0e_1X7')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)

            # 第五个inception module
            with tf.variable_scope('Mixed_6e'):
                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, 160, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = slim.conv2d(branch_1, 128, [1, 7],
                                           scope='Conv2d_0b_1X7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1],
                                           scope='Conv2d_0c_7X1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1],
                                           scope='Conv2d_0b_7X1')
                    branch_2 = slim.conv2d(branch_2, 160, [1, 7],
                                           scope='Conv2d_0c_1X7')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1],
                                           scope='Conv2d_0d_7X1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7],
                                           scope='Conv2d_0e_1X7')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
                end_points['Mixed_6e'] = net

            # 第三个inception模块组
            # 第一个inception module
            with tf.variable_scope('Mixed_7a'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1X1')
                    branch_0 = slim.conv2d(branch_0, 320, [3, 3], stride=2,
                                           padding='VALID', scope='Conv2d_1a_3X3')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = slim.conv2d(branch_1, 192, [1, 7],
                                           scope='Conv2d_0b_1X7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1],
                                           scope='Conv2d_0c_7X1')
                    branch_1 = slim.conv2d(branch_1, 192, [3, 3], stride=2,
                                           padding='VALID', scope='Conv2d_1a_3X3')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.max_pool2d(net, [3, 3], stride=2, padding='VALID',
                                               scope='MaxPool_1a_3X3')
                net = tf.concat([branch_0, branch_1, branch_2], 3)

            # 第二个inception module
            with tf.variable_scope('Mixed_7b'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 320, [1, 1], scope='Conv2d_0a_1X1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 384, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = tf.concat([
                        slim.conv2d(branch_1, 384, [1, 3], scope='Conv2d_0b_1X3'),
                        slim.conv2d(branch_1, 384, [3, 1], scope='Conv2d_0b_3X1')
                    ], 3)
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 448, [1, 3], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 384, [3, 3],
                                           scope='Conv2d_0b_3X3')
                    branch_2 = tf.concat([
                        slim.conv2d(branch_2, 384, [1, 3], scope='Conv2d_0c_1X3'),
                        slim.conv2d(branch_2, 384, [3, 1], scope='Conv2d_0d_3X1')
                    ], 3)
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)

            # 第三个inception module
            with tf.variable_scope('Mixed_7c'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 320, [1, 1], scope='Conv2d_0a_1X1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 384, [1, 1], scope='Conv2d_0a_1X1')
                    branch_1 = tf.concat([
                        slim.conv2d(branch_1, 384, [1, 3], scope='Conv2d_0b_1X3'),
                        slim.conv2d(branch_1, 384, [3, 1], scope='Conv2d_0b_3X1')
                    ], 3)
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 448, [1, 3], scope='Conv2d_0a_1X1')
                    branch_2 = slim.conv2d(branch_2, 384, [3, 3],
                                           scope='Conv2d_0b_3X3')
                    branch_2 = tf.concat([
                        slim.conv2d(branch_2, 384, [1, 3], scope='Conv2d_0c_1X3'),
                        slim.conv2d(branch_2, 384, [3, 1], scope='Conv2d_0d_3X1')
                    ], 3)
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3X3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1],
                                           scope='Conv2d_0b_1X1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            return net, end_points


# 实现全局平均池化，softmax，auxiliary logits，并构筑网络的整个部分
def inception_v3(inputs,
                 num_classes=1000,
                 is_training=True,
                 dropout_keep_prob=0.8,
                 prediction_fn=slim.softmax,
                 spatial_squeeze=True,
                 reuse=None,
                 scope='InceptionV3'):
    with tf.variable_scope(scope, 'InceptionV3', [inputs, num_classes],
                           reuse=reuse) as scope:
        with slim.arg_scope([slim.batch_norm, slim.dropout],
                            is_training=is_training):
            net, end_points = inception_v3_base(inputs, scope=scope)

    with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
                        stride=1, padding='SAME'):
        aux_logits = end_points['Mixed_6e']
        with tf.variable_scope('AuxLogits'):
            aux_logits = slim.avg_pool2d(
                aux_logits, [5, 5], stride=3, padding='VALID',
                scope='AvgPool_1a_5X5'
            )
            aux_logits = slim.conv2d(aux_logits, 128, [1, 1],
                                     scope='Conv2d_1b_1X1')

            aux_logits = slim.conv2d(
                aux_logits, 786, [5, 5],
                weights_initializer=trunc_normal(0.01),
                padding='VALID', scope='Conv2d_2a_5X5'
            )
            aux_logits = slim.conv2d(
                aux_logits, num_classes, [1, 1], activation_fn=None,
                normalizer_fn=None, weights_initializer=trunc_normal(0.001),
                scope='Conv2d_2b_1X1'
            )
            if spatial_squeeze:
                aux_logits = tf.squeeze(aux_logits, [1, 2],
                                        name='SpatialSqueeze')
            end_points['AuxLogits'] = aux_logits

        with tf.variable_scope('Logits'):
            net = slim.avg_pool2d(net, [8, 8], padding='VALID',
                                  scope='AvgPool_1a_8X8')
            net = slim.dropout(net, keep_prob=dropout_keep_prob,
                               scope='Dropout_1b')
            end_points['PreLogits'] = net
            logits = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
                                 normalizer_fn=None, scope='Conv2d_1c_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


num_batches = 100

# 进行性能测试
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 step, %.3f +/- %.3f sec / batch' %
                  (datetime.now(), info_string, num_batches, mn, sd))


batch_size = 32
height, width = 299, 299
inputs = tf.random_uniform((batch_size, height, width, 3))
with slim.arg_scope(inception_v3_arg_scope()):
    logits, end_points = inception_v3(inputs, is_training=False)

init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

time_tensorflow_run(sess, logits, "Forward")

结果如下：

TensorFlow实现经典深度学习网络（3）：TensorFlow实现Google Inception Net
Zhenguo_Yan的博客
10-14 809
TensorFlow实现经典深度学习网络（3）：TensorFlow实现Google Inception Net         Google Inception Net作为ILSVRC 2014比赛中的第一名（通常被称为Inception V1），其在控制计算量和参数量的同时，获得非常好的分类性能——top-5错误率6.67%，只有AlexNet的一半不到。Inception V1有22层（AlexNet 8层，VGGNet 19层），计算量却只有15亿次浮点运算，500万参数(AlexNet 6000万
TensorFlow实现Google Inception Net
励志的小胡子
03-07 512
一、InceptionNet介绍 Google Inception Net首次出现在ILSVRC 2014的比赛中，以较大的优势获得了第一名，那届比赛中的Inception Net通常被称为Inception V1，它最大的特点是控制了计算量和参数量的同时，获得了非常好的分类性能--top-5错误率6.67%。Inception V1有22层深，比AlexNet的8层或者VGGNet的19层还要...
Tensorflow 实现Google Inception Net
河南骏的博客
01-11 733
Inception V1参数少但效果好的目的有两点：第一，参数越多模型越庞大，需要提供模型学习的数据量就越大，而目前高质量的数据非常昂贵。第二，参数越多，耗费的计算资源也会更大。Inception V1参数少但效果好的原因处理模型层数更深、表达能力更强外，还有两点：一是去除了最后逇全连接层，用全局平均池化层（即将图片尺寸变为1x1）来取代它，去除全连接层后模型训练更快并且减轻了过拟合。二是Ince
六、TensorFlow实现Google Inception Net
HeinSven的博客
01-30 311
简介：Google Inception Net首次出现在ILSVRC 2014的比赛中，并获得第一名。 特点： 1、控制了计算量和参数量的同时，获得了非常好的分类性能，有22层深。 2、计算量只有15亿次浮点运算，同时只有500万的参数量。 3、去除了最后的全连接层，用全局平均池化层（即将图片尺寸变为1x1）来取代它，防止过拟合。 4、精心设计的Inception Module提高了参数...
tensorflow 实现google Inception Net
bomingzi的博客
03-29 775
Inception 有22层深，但是比alxnet的8层活着vggnet的19层更深，但是参数量更小。他去除了最后的全连接层，用全局拼婚池化来取代(图片尺寸变为1*1)，全链接层基本上占据了ALxnet活着vggnet 90%的参数量，而且容易引起过拟合。结构图如下。其结构反复堆叠在一起形成一个大网络。 模型图中有四个分枝，最左边的分支对输入进行1*1的卷积，这是NIN中提出的一个重要的结构，1*...
GoogLeNet-TensorFlow:GoogLeNet的TensorFlow实现
05-19
GoogLeNet的TensorFlow实现。 介绍 关注项目的结构，可以对当前代码进行适当的培训。 接下来，我将继续提高代码的可读性，并且该项目的结构还将提高GoogLeNet网络培训的准确性。 去做 该存储库将尽可能使用面向对象...
Inception-Module-Tensorflow:Inception模块的Tensorflow实现
05-02
除了代码本身的注释外，我还写了一篇文章，您可以在找到有关Inception Module和GoogLeNet的进一步说明。 内容 inception.py模块的实现 Inception Train & Test.ipynb ：笔记本，用于培训和测试Inception模块的实现。...
TensorFlow实现GoogLeNet-Inception图像分类模型
GoogLeNet-Inception: TensorFlow实现概述 GoogLeNet-Inception是基于Google研发的深度学习架构GoogLeNet的一种实现，专注于图像分类任务。GoogLeNet是一种卷积神经网络（CNN），它引入了一个名为“inception模块”...
tensorflow实现GoogLeNet-InceptionV1
01-06
GoogLeNet Inception v1 结构 及 pytorch、tensorflow、keras、paddle实现ImageNet识别 环境 python3.6，tensorflow-gpu 1.12.0 代码 # -*- coding: utf-8 -*- # @Time : 2020/2/3 9:56 # @Author : Zhao HL # @...
GoogleInceptionNet(V3)简介以及Tensorflow实现
Invokar的博客
01-23 1241
Tensorflow实现GoogleInceptionNet_V3 引言:Google Inception Net首次出现在ILSVRC 2014的比赛中，并且有非常好的性能——top-5的错误率6.67%，后来又逐渐提出了Inception V2、Inception V3和Incepiton V4。本文实现的网络结构为Inception V3 相关阅读： Tensorflow实现VGGNe...
TensorFlow实现Google InceptionNet V3（forward耗时检测）
马超的博客
03-23 1万+
Google InceptionNet-V3网络结构图：Inception V3网络结构图： 类型 kernel尺寸/步长（或注释） 输入尺寸 卷积 3*3 / 2 299 * 299 * 3 卷积 3*3 / 1 149 * 149 * 32 卷积 3*3 / 1 147 * 147 * 32 池化 3*3 / 2 147 * 147 *
使用自己的数据集训练GoogLenet InceptionNet V1 V2 V3模型（TensorFlow）
热门推荐
AI吃大瓜的博客
08-17 5万+
使用自己的数据集训练GoogLenet InceptionNet V1 V2 V3模型（TensorFlow） 【尊重原创，转载请注明出处】https://blog.csdn.net/guyuealian/article/details/81560537 新增博客《使用自己的数据集训练MobileNet、ResNet图像识别（TensorFlow）》https://panjinquan.blo...
tensorflow实现inception Net数据增强
修炼之路
10-22 1689
在CNN中，为了增大数据量避免模型的过拟合，通常都会对训练数据做数据增强处理，这篇文章主要介绍在Inception Net中是如何做数据增强的，tensorflow官方通过slim已经实现了VGG、Inception、LeNet网络的数据增强的，官网链接如下：https://github.com/tensorflow/models/tree/master/research/slim/preproc...
【深度学习】经典网络-(InceptionV1)GoogLeNet网络复现(使用Tensorflow实现)
shankezh的博客
03-14 3025
论文地址：（V1）https://arxiv.org/abs/1409.4842 本文所包含代码GitHub地址：https://github.com/shankezh/DL_HotNet_Tensorflow 如果对机器学习有兴趣，不仅仅满足将深度学习模型当黑盒模型使用的，想了解为何机器学习可以训练拟合最佳模型，可以看我过往的博客，使用数学知识推导了机器学习中比较经典的案例，并且使用了pyt...
Tensorflow实战9：Googel Inception net实现即时间测评
Felaim的博客
04-06 3304
1.Google Inception Net简介Google Inception Net首次出现在ILSVRC 2014的比赛中（和VGGNet同年），就以较大优势取得了第一名，在比赛中使用的Inception V1通常被称作为Inception V1，虽然这个网络结构有22层，但是只有500万个参数量，是之前我们讲过的AlexNet参数量的1/12。为什么要降低参数量呢？第一点，参数量越大需要的数
学习《TensorFlow实战Google深度学习框架》（十）Inception-v3模型
洛北辰南的博客
03-26 1690
6.4.2 Inception-v3模型
【Tensorflow】深度学习实战05——Tensorflow实现Inception V3
不用先生的博客
06-18 2253
【fishing-pan：https://blog.csdn.net/u013921430转载请注明出处】 前言 前些日子在忙其他的事情，一直没有更新自己学习神经网络的博客，就在端午这天更吧！也祝大家端午节愉快，身体安康。 这篇博客主要讲的是Google Inception Net，Google Net从Inception V1到Inception V4，可以说都是干...
神经网络之Inception模型的实现（Python+TensorFlow）
不眠旅行
08-12 6273
用tensorflow+python实现经典神经网络 inception_v3，增加理解，留作笔记。
《用 Python 和 TensorFlow 构建你的第一个神经网络：从零开始识别手写数字》
最新发布
windowshht的博客
09-12 911
这篇文章介绍了如何使用Python和TensorFlow构建首个神经网络来识别手写数字。主要内容包括：环境准备、MNIST数据加载与预处理、三层MLP网络构建（使用ReLU和Softmax激活函数）、模型训练与评估（达到约98%准确率）、结果可视化展示。文章还提供了优化建议（回调函数、模型保存、TensorBoard）和进阶方向（转向CNN网络），并推荐了相关学习资源。适合Python初学者和想了解TensorFlow的开发者，通过完整项目流程帮助读者入门深度学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值