TensorFlow Time Benchmark for Googlenet (inception_v1_benchmark.py)

最新推荐文章于 2023-07-12 10:53:15 发布
最新推荐文章于 2023-07-12 10:53:15 发布
阅读量2.3k 收藏 1
点赞数
分类专栏： TensorFlow 文章标签： TensorFlow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_sunnyy/article/details/70808474
版权

环境 

TensorFlow  v0.11

KNL 7210

参考内容

[1] https://github.com/tensorflow/models/blob/master/tutorials/image/alexnet/alexnet_benchmark.py

[2] https://github.com/tensorflow/models/blob/master/slim/nets/inception_v1.py

[3] http://blog.csdn.net/felaim/article/details/69404336


inception_v1_benchmark.py

#coding:utf-8

#定义函数，导入tensorflow等相关依赖库，产生截断的正态分布函数
import tensorflow as tf 
import time 
from datetime import datetime
import math
import argparse
import sys

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

#定义函数inception_v1_arg_scope,用来生成网络中常用到的函数的默认参数
def incepton_v1_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

#定义inception_v1_base,生成Inception V1网络的卷积部分
#def inception_v1_base(inputs, scope = None):
def inception_v1_base(inputs,
                      final_endpoint='Mixed_5c',
                      scope='InceptionV1'):
  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(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(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(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(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(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(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(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(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(3, values=[branch_0, branch_1, branch_2, branch_3])

        return net, end_points#返回计算出的结果和作为辅助分类的节点的结果

#定义Inception V1网络的全局平均池化，Softmax和Auxiliary Logits
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'):
  with tf.variable_scope(scope, 'InceptionV1', [inputs, num_classes],
                         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'):
        net = slim.avg_pool2d(net, [7, 7], stride=1, scope='AvgPool_0a_7x7')
        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

#测试性能定义的函数
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(FLAGS.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 / FLAGS.num_batches
    vr = total_duration_squared / FLAGS.num_batches - mn * mn
    sd = math.sqrt(vr)
    print('%s: %s across %d steps, %.3f +/- %.3f sec / batch' %(datetime.now(), info_string, FLAGS.num_batches, mn, sd))

def run_benchmark():
  """Run the benchmark on AlexNet."""
  with tf.Graph().as_default():
    # Generate some dummy images.
    #batch_size = 128
    #num_batches = 100
    image_size = 224
    inputs = tf.Variable(tf.random_normal([FLAGS.batch_size,
                                           image_size,
                                           image_size, 3],
                                          dtype=tf.float32,
                                          stddev=1e-1))

    with slim.arg_scope(incepton_v1_arg_scope()):
      logits, end_points = inception_v1(inputs, is_training = False)                                      

    init = tf.global_variables_initializer()
    config = tf.ConfigProto()
    config.gpu_options.allocator_type = 'BFC'
    sess = tf.Session(config=config)
    sess.run(init)

    time_tensorflow_run(sess, logits, "Forward")

    objective = tf.nn.l2_loss(logits)
    grad = tf.gradients(objective, end_points)
    time_tensorflow_run(sess, grad, "Forward-backward")


def main(_):
  run_benchmark()

if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--batch_size',
      type=int,
      default=128,
      help='Batch size.'
  )
  parser.add_argument(
      '--num_batches',
      type=int,
      default=100,
      help='Number of batches to run.'
  )
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)
    
"""    
#对Inception V1进行运算性能测试
batch_size = 32
height, width = 299, 299
inputs = tf.random_uniform((batch_size, height, width, 3))
with slim.arg_scope(incepton_v1_arg_scope()):
    logits, end_points = inception_v3(inputs, is_training = False)

init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
num_batches = 100
time_tensorflow_run(sess, logits, "Forward")
"""

如果使用的是TensorFlow v1.0，需要把文件中的 

 net = tf.concat(3, [branch_0, branch_1, branch_2, branch_3]) ）
改为 

net = tf.concat(axis=3, values=[branch_0, branch_1, branch_2, branch_3])

测试结果

结果并不是很好，毕竟KNL的优势在于众核 

2017-04-25 07:35:58.863717: step 0, duration = 6.619
2017-04-25 07:37:05.320621: step 10, duration = 6.456
2017-04-25 07:38:12.871317: step 20, duration = 7.003
2017-04-25 07:39:20.690622: step 30, duration = 6.374
2017-04-25 07:40:27.301483: step 40, duration = 6.639
2017-04-25 07:41:32.646297: step 50, duration = 6.279
2017-04-25 07:42:39.759388: step 60, duration = 6.721
2017-04-25 07:43:46.782720: step 70, duration = 6.836
2017-04-25 07:44:52.069185: step 80, duration = 6.376
2017-04-25 07:45:56.691117: step 90, duration = 6.537
2017-04-25 07:46:56.192209: Forward across 100 steps, 6.639 +/- 0.220 sec / batch

另附 TensorFlow v1.0 在GPU Tesla M40 24GB 的测试结果 

I tensorflow/core/common_runtime/gpu/gpu_device.cc:777] Peer access not supported between device ordinals 0 and 2
I tensorflow/core/common_runtime/gpu/gpu_device.cc:777] Peer access not supported between device ordinals 0 and 3
I tensorflow/core/common_runtime/gpu/gpu_device.cc:777] Peer access not supported between device ordinals 1 and 2
I tensorflow/core/common_runtime/gpu/gpu_device.cc:777] Peer access not supported between device ordinals 1 and 3
I tensorflow/core/common_runtime/gpu/gpu_device.cc:777] Peer access not supported between device ordinals 2 and 0
I tensorflow/core/common_runtime/gpu/gpu_device.cc:777] Peer access not supported between device ordinals 2 and 1
I tensorflow/core/common_runtime/gpu/gpu_device.cc:777] Peer access not supported between device ordinals 3 and 0
I tensorflow/core/common_runtime/gpu/gpu_device.cc:777] Peer access not supported between device ordinals 3 and 1
I tensorflow/core/common_runtime/gpu/gpu_device.cc:906] DMA: 0 1 2 3
I tensorflow/core/common_runtime/gpu/gpu_device.cc:916] 0:   Y Y N N
I tensorflow/core/common_runtime/gpu/gpu_device.cc:916] 1:   Y Y N N
I tensorflow/core/common_runtime/gpu/gpu_device.cc:916] 2:   N N Y Y
I tensorflow/core/common_runtime/gpu/gpu_device.cc:916] 3:   N N Y Y
I tensorflow/core/common_runtime/gpu/gpu_device.cc:975] Creating TensorFlow device (/gpu:0) -> (device: 0, name: Tesla M40 24GB, pci bus id: 0000:02:00.0)
I tensorflow/core/common_runtime/gpu/gpu_device.cc:975] Creating TensorFlow device (/gpu:1) -> (device: 1, name: Tesla M40 24GB, pci bus id: 0000:03:00.0)
I tensorflow/core/common_runtime/gpu/gpu_device.cc:975] Creating TensorFlow device (/gpu:2) -> (device: 2, name: Tesla M40 24GB, pci bus id: 0000:82:00.0)
I tensorflow/core/common_runtime/gpu/gpu_device.cc:975] Creating TensorFlow device (/gpu:3) -> (device: 3, name: Tesla M40 24GB, pci bus id: 0000:83:00.0)2017-04-26 04:54:20.751543: step 0, duration = 0.163
2017-04-26 04:54:22.385653: step 10, duration = 0.163
2017-04-26 04:54:24.013761: step 20, duration = 0.163
2017-04-26 04:54:25.643870: step 30, duration = 0.163
2017-04-26 04:54:27.274821: step 40, duration = 0.164
2017-04-26 04:54:28.904545: step 50, duration = 0.163
2017-04-26 04:54:30.531462: step 60, duration = 0.162
2017-04-26 04:54:32.162715: step 70, duration = 0.163
2017-04-26 04:54:33.800282: step 80, duration = 0.163
2017-04-26 04:54:35.431631: step 90, duration = 0.164
2017-04-26 04:54:36.902015: Forward across 100 steps, 0.163 +/- 0.001 sec / batch


__Sunny__
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tensorflow测试_tensorflow模型基准测试benchmark
weixin_39734493的博客
11-24 1058
深度学习模型落地需要考虑决定推理（inference）过程所需的计算资源（成本）和效率（系统的吞吐量和延时），有时甚至需要进行适当的模型裁剪和压缩工作。理论上说，模型结构一旦确定是可以计算它的复杂度和计算量，但这有些繁琐。实际中可以借助一些工具帮助预估模型实际的性能，比较模型优化前后的差别，主要使用到的是benchmark_model和summarize_graph。一、benchmark_mod...
tensorflow-inceptionv1
favomj的博客
10-08 497
中英文对照翻译:https://blog.csdn.net/c_chuxin/article/details/82856502 总结参考： https://blog.csdn.net/weixin_43624538/article/details/84863685 https://blog.csdn.net/mao_xiao_feng/article/details/53350798 代码...
tensorflow 性能benchmark
MrTeq的专栏
07-05 3271
https://www.tensorflow.org/performance/benchmarks  ***tensorflow benchmark
inception v1
Loong Cheng的博客
06-08 764
inception系列的开山之作，有网络结构设计的初期思考。 Going deeper with convolutions motivations: 提高模型性能的最直接方式：1.加深（增加层）2.加宽（增加单层的神经元个数）,带来的两个弊端：1.大规模的参数易导致过拟合且需要更多的训练集 2.更多的计算资源消耗 解决基本思想是在fc层甚至conv层使用稀疏连接结构，原因是 1...
Inception V1
sinat_30618203的博客
03-25 214
1、目的 增加网络的深度和宽度 挑战：1）bigger size -> more parameter -> overfitting 2）计算资源需求高 方案：用密集成分来近似最优的局部稀疏结构，FC层 -> 稀疏连接的结构 2、原理 1）Hebbian principle：臃肿的稀疏结构 -> 高效的密集结构，neurons that fire together, wire together 2）多尺度 3、结构设计 ...
benchmar.rar_benchmark_benchmark 社区_复杂网络_社区
07-13
文件名“benchmark_benchmark 社区_复杂网络_社区”暗示了文件内容可能包括不同基准测试的实验设置、生成的网络数据、算法实现及性能比较等。 为了进一步分析和理解这些数据，我们需要对复杂网络理论有一定的了解，...
Benchmark.rar_benchmark_benchmark三代_benchmark模型_三代benchmark_主动控制
07-14
总结来说，"Benchmark.rar_benchmark_benchmark三代_benchmark模型_三代benchmark_主动控制"是一个专注于主动控制算法评估的资源包，它提供了一个先进的三代Benchmark模型，用于比较和优化控制策略的性能。...
Benchmarks.zip_Benchmark函数_benchmark_benchmark functions_benchma
07-14
常用的智能优化算法的benchmark函数，供优化算法论文性能比较实用。
SPSA_BenchMark.zip_SPSA_benchmark_perturbation_stochastic
07-14
Simultaneous perturbation stochastic approximation
原版第三代benchmark代码.rar_ASCE-Benchmark_BENCHMARK ASCE_benchmark_dri
07-14
此为ASCE的第三代基准模型代码，可供土木工程领域学者使用。
benchmarks:Tensorflow的基准框架
04-28
TensorFlow基准 该存储库包含各种TensorFlow基准测试。 当前，它包含两个项目： ：TensorFlow的基准框架。 （不再维护）：TensorFlow CNN基准包含针对多个卷积神经网络的TensorFlow 1基准。 如果您想运行TensorFlow模型并评估其性能，请考虑使用
GoogLeNet-TensorFlow:GoogLeNet的TensorFlow实现
05-19
GoogLeNet-TensorFlow GoogLeNet的TensorFlow实现。 介绍 关注项目的结构，可以对当前代码进行适当的培训。 接下来，我将继续提高代码的可读性，并且该项目的结构还将提高GoogLeNet网络培训的准确性。 去做 该存储库将尽可能使用面向对象的编程，以使机器学习代码结构更清晰。 到目前为止，我已经实现了数据加载器和处理配置类，并且已经实现了Inception v1网络类。 此外，可以使用张量板可视化当前代码。 数据加载器 配置文件 基础网络类 初始v1网络类 初始v2网络类 初始v3网络类 初始v4网络类 张量板 培训师 更好的日志 提高准确性 用法 数据 该存储库将支持多种格式的数据。 到目前为止，它支持102flowers数据集。 102朵花 为了确保正确的培训，请按以下方式组织数据的结构。 data ├── flowers1
Inception V1 理解
01-06
在论文《Going Deeper with Convolutions》提出了GoogLeNet网络，并在 ILSVRC 2014(ImageNet Large Scale Visual Recognition Competition) 上取得了第一名，GoogLeNet 对网络中的传统卷积层进行了修改，提出了被称为 Inception 的结构，用于增加网络深度和宽度，提高深度神经网络性能。 我们知道，在卷积神经网络（CNN）中，传统情况下，最直接提升准确度的方法，就是 增加网络的尺寸，包括宽度和深度。深度也就是网络中的层数，宽度指每层中所用到的神经元的个数。但是这种简单直接的解决方式存在的两个
Inception v1
zack的博客
08-12 6928
Inception目的是为了增加网络深度和宽度的同时减少参数 论文地址： [v1] Going Deeper with Convolutions, 6.67% test error http://arxiv.org/abs/1409.4842    Inception v1的网络，将1x1，3x3，5x5的conv和3x3的pooling，堆叠在一起，一方面增加了网络的width，另一方面...
tensorflow之googlenet
gaotihong的博客
11-27 156
https://tianchi.aliyun.com/course/courseConsole?spm=5176.12282070.0.0.2a012042piZFJv&courseId=198&chapterIndex=4&sectionIndex=14 思路清晰，以后再补充： 1.加载数据 2.定义模型 3.训练 ...
环境搭建-CentOS7系统基于TensorFlow Benchmarks测试GPU
疯批美人
07-12 4631
gpu的占用率为99%，是一种比较正常的使用状态。gpu是图形处理器的简称，又称显示核心、视觉处理器、显示芯片，用途是将计算机系统所需要的显示信息进行转换驱动，并向显示器提供行扫描信号，控制显示器的正确显示，是连接显示器和个人电脑主板的重要元件，也是“人机对话”的重要设备之一。
扒一扒神经网络--Inception v1
u012885745的博客
12-03 622
Inception v1 GoogLeNet（Inception v1） Title: Going Deeper with Convolutions Author and affiliation: 贾扬青；Google Year: 2015 CVPR Honors: 1st in classification and detection in ILSVRC14 Datasets: IL...
Tensorflow——使用GoogleNet训练Fashion_mnist
weixin_45284801的博客
04-14 582
使用GoogleNet训练Fashion_mnist GoogLeNet简介 GoogLeNet是2014年提出的一种全新的深度学习结构，在这之前的AlexNet、VGG、NIN等结构都通过增大网络深度（层数）来获得更好的训练效果，但层数的增加会带来很多负作用，比如overfit、梯度消失、梯度爆炸等。inception从另一种角度来提升训练结果：在相同的计算量下能提取到更多的特征，从而提升性能。 GoogLeNet 由Inception基础块组成 Inception块相当于一个有4条子线路的小网络,它通
TensorFlow benchmarks脚本中命令参数必须加“=”
s_sunnyy的博客
02-07 1589
这个问题已在GitHub上提出 https://github.com/tensorflow/benchmarks/issues/132 ===================================================== 在TensorFlow benchmarks测试时一直使用的是“--flag value”的形式，在我的印象中这样也是可以的，将value的值赋给fla
tools/analysis_tools/benchmark.py
最新发布
09-01
根据提供的引用内容，我无法找到关于"tools/analysis_tools/benchmark.py"的具体信息。请提供更多相关的引用内容或详细描述，以便我可以为您提供准确的答案。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [关于mmdetection、mmrotate如何计算参数量、计算量和速度FPS](https://blog.csdn.net/weixin_40493382/article/details/128251056)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [mmdetection tools工具梳理](https://blog.csdn.net/weixin_44966641/article/details/124558532)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值