本文已同步本人另外一个博客(http://blog.csdn.net/qq_37608890/article/details/79371347)

本文根据最近学习TensorFlow书籍网络文章的情况,特将一些学习心得做了总结,详情如下.如有不当之处,请各位大拿多多指点,在此谢过。

一、AlexNet模型及其基本原理阐述

1、关于AlexNet

2012年,AlexKrizhevsky提出了深度卷积神经网络模型AlexNet,可以看作LeNet的一种更深更宽的版本。该模型包含了6亿3000万个连接,6000万个参数和65万个神经元,拥有5个卷积层,其中3个卷积层后面连接了最大池化层,最后还有3个全连接层。它将LeNet的思想得到更广泛的传播,把把CNN的基本原理应用到很深很宽的网络中。

2、AlexNet主要使用到的新技术点

(1)成功使用RelU作为CNN的激活函数,并验证其效果在较深的网络超过Sigmoid函数,成功解决了Sigmoid函数在网络较深时梯度弥散问题。

(2)训练时使用Droupout随机忽略一部分神经元,以避免出现模型过拟合。

(3) 在CNN中使用重叠的最大池化。

(4) 提出了LRN层,对局部神经元的活动创建竞争机制,使得其中响应比较大的值变得相对更大,并抑制其他反馈较小的神经元,增强了模型的泛化能力。

(5) 使用CUDA加速深度卷积网络的训练,利用GPU强大的并行计算能力,处理神经网络训练时大量的矩阵运算。

(6) 数据增强,随机地从256*256的原始图像中截取224*224大小的区域(以及水平翻转的镜像),相当于增加了(256-224)^2=2048倍的数据量。

3、原理阐释

整个AlexNet包括8个需要训练参数的层(不含LRN和池化层),前5层为卷积层,后3层为全连接层,如图1所示。AlexNet最后一层是有1000类输出的Softmax层用作分类。LRN层出现在第1个及第2个卷积层后,而最大池化层出现在两个LRN层及最后一个卷积层后。RelU激活函数则应用在这8层每一层的后面。

图1AlexNet的网络结构

AlexNet每层的超参数如图1所示,其中输入的图片尺寸为224*224,第一个卷积层使用了较大的卷积核尺寸11*11,步长为4,有96个卷积核;然后是一个LRN层;再往后是一个3*3的最大池化层,步长为2。再往后的卷积核尺寸都比较小,基本都是5*5或3*3的大小,且步长都是1,即会扫描全图像所有像素;而最大池化层依然保持为3*3,步长为2。

这里不难发现,前几个卷积层里面,虽然计算量很大,但参数量很小,基本都在1M左右甚至更小,只占AlexNet总参数量很小一部分。这也是卷积层的价值所在:通过较小的参数量提取有效的特征。

如果前几层直接使用全连接层,则参数量和计算量将会难以想象。尽管每一个卷积层只占整个网络参数量的1%不到,但如果抛弃任何一个卷积层,都会迫使整个网络的分类能力大幅度下降。

图1中特殊的地方是卷积部分都是画成上下两块,意思是说把这一层计算出来的featuremap分开,但是前一层用到的数据要看连接的虚线,如图中input层之后的第一层第二层之间的虚线是分开的,是说二层上面的128map是由一层上面的48map计算的,下面同理;而第三层前面的虚线是完全交叉的,就是说每一个192map都是由前面的128+128=256map同时计算得到的。

Alexnet有一个特殊的计算层,LRN层,做的事是对当前层的输出结果做平滑处理,图2所示:

图2

前后几层(对应位置的点)对中间这一层做一下平滑约束,计算方法如下:

二、经典卷积神经网络AlexNet模型实现过程

1、简要说明

因为使用ImageNet数据集训练一个完整的AlexNet非常耗时,这里AlexNet的实现将不涉及实际数据的训练,但会创建一个完整的AlexNet卷积神经网络,然后对它每个batch的前馈计算(forward)和反馈计算(backward)的速度进行测试。下面使用随机图片数据来计算每轮前馈、反馈的平均耗时。当然,读者也可以自行下载ImageNet数据完成训练并测试。

2、实现过程

  1. ==============================================================================
  2. from datetime import datetime
  3. import math
  4. import time
  5. import tensorflow as tf
  6.  
  7. #这里总共测试100个batch的数据。
  8. batch_size=32
  9. num_batches=100
  10. #定义一个用来显示网络每一层结构的函数print_activations,展示每一个卷积层或池化层输出的tensor尺寸。
  11. def print_activations(t):
  12. print(t.op.name, ' ', t.get_shape().as_list())
  13.  
  14. #设计AlexNet网络结构。
  15. #设定inference函数,用于接受images作为输入,返回最后一层pool5(第5个池化层)及parameters(AlexnNet中所有需要训练的模型参数)
  16. #该函数包括多个卷积层和池化层。
  17. def inference(images):
  18. parameters = []
  19. # 第1个卷积层
  20. with tf.name_scope('conv1') as scope:
  21. kernel = tf.Variable(tf.truncated_normal([11, 11, 3, 64], dtype=tf.float32,
  22. stddev=1e-1), name='weights')
  23. conv = tf.nn.conv2d(images, kernel, [1, 4, 4, 1], padding='SAME')
  24. biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),
  25. trainable=True, name='biases')
  26. bias = tf.nn.bias_add(conv, biases)
  27. conv1 = tf.nn.relu(bias, name=scope)
  28. print_activations(conv1)
  29. parameters += [kernel, biases]
  30.  
  31. # 添加LRN层和最大池化层
  32. lrn1 = tf.nn.lrn(conv1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='lrn1')
  33. pool1 = tf.nn.max_pool(lrn1,
  34. ksize=[1, 3, 3, 1],
  35. strides=[1, 2, 2, 1],
  36. padding='VALID',
  37. name='pool1')
  38. print_activations(pool1)
  39.  
  40. # 设计第2个卷积层
  41. with tf.name_scope('conv2') as scope:
  42. kernel = tf.Variable(tf.truncated_normal([5, 5, 64, 192], dtype=tf.float32,
  43. stddev=1e-1), name='weights')
  44. conv = tf.nn.conv2d(pool1, kernel, [1, 1, 1, 1], padding='SAME')
  45. biases = tf.Variable(tf.constant(0.0, shape=[192], dtype=tf.float32),
  46. trainable=True, name='biases')
  47. bias = tf.nn.bias_add(conv, biases)
  48. conv2 = tf.nn.relu(bias, name=scope)
  49. parameters += [kernel, biases]
  50. print_activations(conv2)
  51.  
  52. # 对第2个卷积层的输出进行处理,同样也是先做LRN处理再做最大化池处理。
  53. lrn2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='lrn2')
  54. pool2 = tf.nn.max_pool(lrn2,
  55. ksize=[1, 3, 3, 1],
  56. strides=[1, 2, 2, 1],
  57. padding='VALID',
  58. name='pool2')
  59. print_activations(pool2)
  60.  
  61. # 设计第3个卷积层
  62. with tf.name_scope('conv3') as scope:
  63. kernel = tf.Variable(tf.truncated_normal([3, 3, 192, 384],
  64. dtype=tf.float32,
  65. stddev=1e-1), name='weights')
  66. conv = tf.nn.conv2d(pool2, kernel, [1, 1, 1, 1], padding='SAME')
  67. biases = tf.Variable(tf.constant(0.0, shape=[384], dtype=tf.float32),
  68. trainable=True, name='biases')
  69. bias = tf.nn.bias_add(conv, biases)
  70. conv3 = tf.nn.relu(bias, name=scope)
  71. parameters += [kernel, biases]
  72. print_activations(conv3)
  73.  
  74. # 设计第4个卷积层
  75. with tf.name_scope('conv4') as scope:
  76. kernel = tf.Variable(tf.truncated_normal([3, 3, 384, 256],
  77. dtype=tf.float32,
  78. stddev=1e-1), name='weights')
  79. conv = tf.nn.conv2d(conv3, kernel, [1, 1, 1, 1], padding='SAME')
  80. biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
  81. trainable=True, name='biases')
  82. bias = tf.nn.bias_add(conv, biases)
  83. conv4 = tf.nn.relu(bias, name=scope)
  84. parameters += [kernel, biases]
  85. print_activations(conv4)
  86.  
  87. # 设计第5个卷积层
  88. with tf.name_scope('conv5') as scope:
  89. kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 256],
  90. dtype=tf.float32,
  91. stddev=1e-1), name='weights')
  92. conv = tf.nn.conv2d(conv4, kernel, [1, 1, 1, 1], padding='SAME')
  93. biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
  94. trainable=True, name='biases')
  95. bias = tf.nn.bias_add(conv, biases)
  96. conv5 = tf.nn.relu(bias, name=scope)
  97. parameters += [kernel, biases]
  98. print_activations(conv5)
  99.  
  100. # 最大池化层
  101. pool5 = tf.nn.max_pool(conv5,
  102. ksize=[1, 3, 3, 1],
  103. strides=[1, 2, 2, 1],
  104. padding='VALID',
  105. name='pool5')
  106. print_activations(pool5)
  107.  
  108. return pool5, parameters
  109.  
  110. #构建函数time_tensorflow_run,用来评估AlexNet每轮计算时间。
  111. def time_tensorflow_run(session, target, info_string):
  112. num_steps_burn_in = 10
  113. total_duration = 0.0
  114. total_duration_squared = 0.0
  115. for i in range(num_batches + num_steps_burn_in):
  116. start_time = time.time()
  117. _ = session.run(target)
  118. duration = time.time() - start_time
  119. if i >= num_steps_burn_in:
  120. if not i % 10:
  121. print ('%s: step %d, duration = %.3f' %
  122. (datetime.now(), i - num_steps_burn_in, duration))
  123. total_duration += duration
  124. total_duration_squared += duration * duration
  125. mn = total_duration / num_batches
  126. vr = total_duration_squared / num_batches - mn * mn
  127. sd = math.sqrt(vr)
  128. print ('%s: %s across %d steps, %.3f +/- %.3f sec / batch' %
  129. (datetime.now(), info_string, num_batches, mn, sd))
  130.  
  131. #主函数
  132. def run_benchmark():
  133.  
  134. with tf.Graph().as_default():
  135. image_size = 224
  136. images = tf.Variable(tf.random_normal([batch_size,
  137. image_size,
  138. image_size, 3],
  139. dtype=tf.float32,
  140. stddev=1e-1))
  141.  
  142. pool5, parameters = inference(images)
  143.  
  144. init = tf.global_variables_initializer()
  145.  
  146. config = tf.ConfigProto()
  147. config.gpu_options.allocator_type = 'BFC'
  148. sess = tf.Session(config=config)
  149. sess.run(init)
  150.  
  151. time_tensorflow_run(sess, pool5, "Forward")
  152.  
  153. objective = tf.nn.l2_loss(pool5)
  154.  
  155. grad = tf.gradients(objective, parameters)
  156. # Run the backward benchmark.
  157. time_tensorflow_run(sess, grad, "Forward-backward")
  158.  
  159. #执行主函数
  160. run_benchmark()

3、执行结果分析

这里有三部分如下:

首先是AlexNet的网络结构

  1. conv1 [32, 56, 56, 64]
  2. pool1 [32, 27, 27, 64]
  3. conv2 [32, 27, 27, 192]
  4. pool2 [32, 13, 13, 192]
  5. conv3 [32, 13, 13, 384]
  6. conv4 [32, 13, 13, 256]
  7. conv5 [32, 13, 13, 256]
  8. pool5 [32, 6, 6, 256]

其次是Forward运行的时间。

  1. 2018-02-26 08:08:01.966903: step 0, duration = 0.914
  2. 2018-02-26 08:08:11.376824: step 10, duration = 0.939
  3. 2018-02-26 08:08:21.075799: step 20, duration = 0.953
  4. 2018-02-26 08:08:30.983637: step 30, duration = 0.930
  5. 2018-02-26 08:08:40.616086: step 40, duration = 0.938
  6. 2018-02-26 08:08:50.259619: step 50, duration = 0.965
  7. 2018-02-26 08:09:01.280123: step 60, duration = 1.128
  8. 2018-02-26 08:09:11.993487: step 70, duration = 0.998
  9. 2018-02-26 08:09:22.223815: step 80, duration = 0.935
  10. 2018-02-26 08:09:31.741528: step 90, duration = 0.921
  11. 2018-02-26 08:09:40.085934: Forward across 100 steps, 0.990 +/- 0.082 sec / batch

最后是backward运行的时间。

  1. 2018-02-26 08:10:19.714161: step 0, duration = 3.387
  2. 2018-02-26 08:10:55.765137: step 10, duration = 3.495
  3. 2018-02-26 08:11:32.451839: step 20, duration = 4.189
  4. 2018-02-26 08:12:07.982546: step 30, duration = 3.369
  5. 2018-02-26 08:12:43.531404: step 40, duration = 3.415
  6. 2018-02-26 08:13:18.980045: step 50, duration = 3.470
  7. 2018-02-26 08:13:54.535575: step 60, duration = 3.371
  8. 2018-02-26 08:14:29.413705: step 70, duration = 3.655
  9. 2018-02-26 08:15:06.147061: step 80, duration = 3.583
  10. 2018-02-26 08:15:43.403758: step 90, duration = 3.921
  11. 2018-02-26 08:16:16.511215: Forward-backward across 100 steps, 3.602 +/- 0.237 sec / batch

三、小结

AlexNet为卷积神经网络和深度学习正名,为复兴神经网络做出了很多贡献,当然,超大型的数据集ImageNet也给深度学习带来了很大贡献。训练深度卷积神经网络,必须要有一个类似于ImageNet这样超大型数据集才能避免出现过拟合现象,从而更能体现深度学习的优势所在。因此,传统机器学习模型更适合一个小型数据集,在面对大型数据集时,需要更大学习容量的模型,那就是深度学习模型。

深度学习的参数不一定比传统机器学习模型多,尤其是在卷积层使用的参数量一般都比较少,但其抽取特征的能力非常强悍,这是CNN之所以有效的原因。

参考资料   主要参考资料《TensorFlow实战》(黄文坚  唐源 著)(电子工业出版社)

TensorFlow实战之实现AlexNet经典卷积神经网络的更多相关文章

  1. TensorFlow实战第八课(卷积神经网络CNN)

    首先我们来简单的了解一下什么是卷积神经网路(Convolutional Neural Network) 卷积神经网络是近些年逐步兴起的一种人工神经网络结构, 因为利用卷积神经网络在图像和语音识别方面能 ...

  2. 五大经典卷积神经网络介绍:LeNet / AlexNet / GoogLeNet / VGGNet/ ResNet

    欢迎大家关注我们的网站和系列教程:http://www.tensorflownews.com/,学习更多的机器学习.深度学习的知识! LeNet / AlexNet / GoogLeNet / VGG ...

  3. 经典卷积神经网络(LeNet、AlexNet、VGG、GoogleNet、ResNet)的实现(MXNet版本)

    卷积神经网络(Convolutional Neural Network, CNN)是一种前馈神经网络,它的人工神经元可以响应一部分覆盖范围内的周围单元,对于大型图像处理有出色表现. 其中 文章 详解卷 ...

  4. 经典卷积神经网络的学习(一)—— AlexNet

    AlexNet 为卷积神经网络和深度学习正名,以绝对优势拿下 ILSVRC 2012 年冠军,引起了学术界的极大关注,掀起了深度学习研究的热潮. AlexNet 在 ILSVRC 数据集上达到 16. ...

  5. TensorFlow 一步一步实现卷积神经网络

    欢迎大家关注我们的网站和系列教程:http://www.tensorflownews.com/,学习更多的机器学习.深度学习的知识! TensorFlow 从入门到精通系列教程: http://www ...

  6. 在 TensorFlow 中实现文本分类的卷积神经网络

    在TensorFlow中实现文本分类的卷积神经网络 Github提供了完整的代码: https://github.com/dennybritz/cnn-text-classification-tf 在 ...

  7. 在TensorFlow中实现文本分类的卷积神经网络

    在TensorFlow中实现文本分类的卷积神经网络 Github提供了完整的代码: https://github.com/dennybritz/cnn-text-classification-tf 在 ...

  8. 《TensorFlow实战》中AlexNet卷积神经网络的训练中

    TensorFlow实战中AlexNet卷积神经网络的训练 01 出错 TypeError: as_default() missing 1 required positional argument: ...

  9. 经典卷积神经网络算法(2):AlexNet

    .caret, .dropup > .btn > .caret { border-top-color: #000 !important; } .label { border: 1px so ...

随机推荐

  1. 注解Responsebody RequestBody RequestMapping

    编写代码时候很容易遗漏注解,尤其比较重要的注解,调试很久也找不到原因,在处理页面请求异常时,如果后台正常,就是发现没有把想要的对象传到页面就注意下看注解是否缺失?例如:/** * @Author gj ...

  2. Linuxc - 标准输入流、标准输出流、标准错误流

    输入流stdin默认是键盘,输出流stdout默认是显示器,错误流stderr #include <stdio.h> int main() { printf("请输入选择的数字: ...

  3. 安卓开发-intent在Activity之间数据传递

    安卓开发-intent在Activity之间数据传递 [TOC] intent实现普通跳转 使用intent的setclass方法,示例(由此界面跳转到NewActivity界面) //使用setOn ...

  4. POI--HSSFRow类

    用POI在工作表里作成一个行,可以用「HSSFRow」类,它的构造方法有三个. protected HSSFRow() protected HSSFRow(Workbook book, Sheet s ...

  5. Python Django连接(听明白了是连接不是创建!)Mysql已存在的数据库

    再声明一次!是连接不是创建!网上的一些人难道连接和创建这俩词都弄不懂就在那里瞎写一些文章! (Python Django连接存在的数据库) Python连接存在的数据库-------MySql 1.首 ...

  6. Maven初步

    Maven初入 maven 是一个项目管理工具, 它包含了一个 项目对象模型(Project Object Model POM), 一组标准集合, 一个项目生命周期(Project Lifecycle ...

  7. java.lang.Thread

    package java.lang; import java.lang.ref.Reference; import java.lang.ref.ReferenceQueue; import java. ...

  8. 错误:The request sent by the client was syntactically incorrect的解决

    问题: 错误400-The request sent by the client was syntactically incorrect. springMVC中,某个页面提交时报400错误,如下图. ...

  9. java 包命名规范

    转载 原文地址:http://blog.csdn.net/kongjiea/article/details/45365753 Java的包名都有小写单词组成,类名首字母大写:包的路径符合所开发的 系统 ...

  10. 【Java】泛型学习笔记

    参考书籍 <Java核心技术:卷1> 泛型, 先睹为快 先通过一个简单的例子说明下Java中泛型的用法: 泛型的基本形式类似于模板, 通过一个类型参数T, 你可以"私人定制&qu ...