卷积神经网络的概念

在多层感知器(Multilayer Perceptrons,简称MLP)中,每一层的神经元都连接到下一层的所有神经元。一般称这种类型的层为完全连接。

 

多层感知器示例

 

反向传播

几个人站成一排第一个人看一幅画(输入数据),描述给第二个人(隐层)……依此类推,到最后一个人(输出)的时候,画出来的画肯定不能看了(误差较大)。

反向传播就是,把画拿给最后一个人看(求取误差),然后最后一个人就会告诉前面的人下次描述时需要注意哪里(权值修正)

其实反向传播就是梯度下降的反向继续

 

什么是卷积:convolution

卷积运算

 

 

计算步骤解释如下,原图大小为7*7,通道数为3:,卷积核大小为3*3,Input Volume中的蓝色方框和Filter W0中红色方框的对应位置元素相乘再求和得到res(即,下图中的步骤1.res的计算),再把res和Bias b0进行相加(即,下图中的步骤2),得到最终的Output Volume

卷积示例

以下是一组未经过滤的猫咪照片:

 

如果分别应用水平和垂直边缘滤波器,会得出以下结果:

 

可以看到某些特征是变得更加显著的,而另一些特征逐渐消失。有趣的是,每个过滤器都展示了不同的特征。

这就是卷积神经网络学习识别图像特征的方法。

 

卷积函数如下:卷积函数tf.nn.conv2d

第一个参数:input [训练时一个batch图像的数量,图像高度,图像宽度, 图像通道数])

第二个参数:filter

filter就是卷积核(这里要求用Tensor来表示卷积核,并且Tensor(一个4维的Tensor,要求类型与input相同)的shape为[filter_height, filter_width, in_channels, out_channels]具体含义[卷积核高度,卷积核宽度,图像通道数,卷积核个数],这里的图片通道数也就input中的图像通道数,二者相同。)

第三个参数:strides

strides就是卷积操作时在图像每一维的步长,strides是一个长度为4的一维向量

第四个参数:padding

第五个参数:use_cudnn_on_gpu

第六个参数:data_format

NHWC:[batch, height, width, channels]

第七个参数:name

padding是一个string类型的变量,只能是 "SAME" 或者 "VALID",决定了两种不同的卷积方式。下面我们来介绍 "SAME" 和 "VALID" 的卷积方式,如下图我们使用单通道的图像,图像大小为5*5,卷积核用3*3

如果以上参数不明白如何使用如下示例:

简单的单层神经网络预测手写数字图片

  1. import tensorflow as tf
  2. from tensorflow.examples.tutorials.mnist import input_data
  3. from tensorflow.contrib.slim.python.slim.nets.inception_v3 import inception_v3_base
  4. FLAGS = tf.app.flags.FLAGS
  5. tf.app.flags.DEFINE_integer("is_train", 1, "指定程序是预测还是训练")
  6. def full_connected():
  7. # 获取真实的数据
  8. mnist = input_data.read_data_sets("./data/mnist/input_data/", one_hot=True)
  9. # 1、建立数据的占位符 x [None, 784] y_true [None, 10]
  10. with tf.variable_scope("data"):
  11. x = tf.placeholder(tf.float32, [None, 784])
  12. y_true = tf.placeholder(tf.int32, [None, 10])
  13. # 2、建立一个全连接层的神经网络 w [784, 10] b [10]
  14. with tf.variable_scope("fc_model"):
  15. # 随机初始化权重和偏置
  16. weight = tf.Variable(tf.random_normal([784, 10], mean=0.0, stddev=1.0), name="w")
  17. bias = tf.Variable(tf.constant(0.0, shape=[10]))
  18. # 预测None个样本的输出结果matrix [None, 784]* [784, 10] + [10] = [None, 10]
  19. y_predict = tf.matmul(x, weight) + bias
  20. # 3、求出所有样本的损失,然后求平均值
  21. with tf.variable_scope("soft_cross"):
  22. # 求平均交叉熵损失
  23. loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict))
  24. # 4、梯度下降求出损失
  25. with tf.variable_scope("optimizer"):
  26. train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
  27. # 5、计算准确率
  28. with tf.variable_scope("acc"):
  29. equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 1))
  30. # equal_list None个样本 [1, 0, 1, 0, 1, 1,..........]
  31. accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32))
  32. # 收集变量 单个数字值收集
  33. tf.summary.scalar("losses", loss)
  34. tf.summary.scalar("acc", accuracy)
  35. # 高纬度变量收集
  36. tf.summary.histogram("weightes", weight)
  37. tf.summary.histogram("biases", bias)
  38. # 定义一个初始化变量的op
  39. init_op = tf.global_variables_initializer()
  40. # 定义一个合并变量de op
  41. merged = tf.summary.merge_all()
  42. # 创建一个saver
  43. saver = tf.train.Saver()
  44. # 开启会话去训练
  45. with tf.Session() as sess:
  46. # 初始化变量
  47. sess.run(init_op)
  48. # 建立events文件,然后写入
  49. filewriter = tf.summary.FileWriter("./tmp/summary/test/", graph=sess.graph)
  50. if FLAGS.is_train == 1:
  51. # 迭代步数去训练,更新参数预测
  52. for i in range(2000):
  53. # 取出真实存在的特征值和目标值
  54. mnist_x, mnist_y = mnist.train.next_batch(50)
  55. # 运行train_op训练
  56. sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y})
  57. # 写入每步训练的值
  58. summary = sess.run(merged, feed_dict={x: mnist_x, y_true: mnist_y})
  59. filewriter.add_summary(summary, i)
  60. print("训练第%d步,准确率为:%f" % (i, sess.run(accuracy, feed_dict={x: mnist_x, y_true: mnist_y})))
  61. # 保存模型
  62. saver.save(sess, "./tmp/ckpt/fc_model")
  63. else:
  64. # 加载模型
  65. saver.restore(sess, "./tmp/ckpt/fc_model")
  66. # 如果是0,做出预测
  67. for i in range(100):
  68. # 每次测试一张图片 [0,0,0,0,0,1,0,0,0,0]
  69. x_test, y_test = mnist.test.next_batch(1)
  70. print("第%d张图片,手写数字图片目标是:%d, 预测结果是:%d" % (
  71. i,
  72. tf.argmax(y_test, 1).eval(),
  73. tf.argmax(sess.run(y_predict, feed_dict={x: x_test, y_true: y_test}), 1).eval()
  74. ))
  75. return None
  76. # 定义一个初始化权重的函数
  77. def weight_variables(shape):
  78. w = tf.Variable(tf.random_normal(shape=shape, mean=0.0, stddev=1.0))
  79. return w
  80. # 定义一个初始化偏置的函数
  81. def bias_variables(shape):
  82. b = tf.Variable(tf.constant(0.0, shape=shape))
  83. return b
  84. def model():
  85. """
  86. 自定义的卷积模型
  87. :return:
  88. """
  89. # 1、准备数据的占位符 x [None, 784] y_true [None, 10]
  90. with tf.variable_scope("data"):
  91. x = tf.placeholder(tf.float32, [None, 784])
  92. y_true = tf.placeholder(tf.int32, [None, 10])
  93. # 2、一卷积层 卷积: 5*5*1,32个,strides=1 激活: tf.nn.relu 池化
  94. with tf.variable_scope("conv1"):
  95. # 随机初始化权重, 偏置[32]
  96. w_conv1 = weight_variables([5, 5, 1, 32])
  97. b_conv1 = bias_variables([32])
  98. # 对x进行形状的改变[None, 784] [None, 28, 28, 1]
  99. x_reshape = tf.reshape(x, [-1, 28, 28, 1])
  100. # [None, 28, 28, 1]-----> [None, 28, 28, 32]
  101. x_relu1 = tf.nn.relu(tf.nn.conv2d(x_reshape, w_conv1, strides=[1, 1, 1, 1], padding="SAME") + b_conv1)
  102. # 池化 2*2 ,strides2 [None, 28, 28, 32]---->[None, 14, 14, 32]
  103. x_pool1 = tf.nn.max_pool(x_relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")
  104. # 3、二卷积层卷积: 5*5*32,64个filter,strides=1 激活: tf.nn.relu 池化:
  105. with tf.variable_scope("conv2"):
  106. # 随机初始化权重, 权重:[5, 5, 32, 64] 偏置[64]
  107. w_conv2 = weight_variables([5, 5, 32, 64])
  108. b_conv2 = bias_variables([64])
  109. # 卷积,激活,池化计算
  110. # [None, 14, 14, 32]-----> [None, 14, 14, 64]
  111. x_relu2 = tf.nn.relu(tf.nn.conv2d(x_pool1, w_conv2, strides=[1, 1, 1, 1], padding="SAME") + b_conv2)
  112. # 池化 2*2, strides 2, [None, 14, 14, 64]---->[None, 7, 7, 64]
  113. x_pool2 = tf.nn.max_pool(x_relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")
  114. # 4、全连接层 [None, 7, 7, 64]--->[None, 7*7*64]*[7*7*64, 10]+ [10] =[None, 10]
  115. with tf.variable_scope("conv2"):
  116. # 随机初始化权重和偏置
  117. w_fc = weight_variables([7 * 7 * 64, 10])
  118. b_fc = bias_variables([10])
  119. # 修改形状 [None, 7, 7, 64] --->None, 7*7*64]
  120. x_fc_reshape = tf.reshape(x_pool2, [-1, 7 * 7 * 64])
  121. # 进行矩阵运算得出每个样本的10个结果
  122. y_predict = tf.matmul(x_fc_reshape, w_fc) + b_fc
  123. return x, y_true, y_predict
  124. def conv_fc():
  125. # 获取真实的数据
  126. mnist = input_data.read_data_sets("./data/mnist/input_data/", one_hot=True)
  127. # 定义模型,得出输出
  128. x, y_true, y_predict = model()
  129. # 进行交叉熵损失计算
  130. # 3、求出所有样本的损失,然后求平均值
  131. with tf.variable_scope("soft_cross"):
  132. # 求平均交叉熵损失# 求平均交叉熵损失
  133. loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict))
  134. # 4、梯度下降求出损失
  135. with tf.variable_scope("optimizer"):
  136. train_op = tf.train.GradientDescentOptimizer(0.0001).minimize(loss)
  137. # 5、计算准确率
  138. with tf.variable_scope("acc"):
  139. equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 1))
  140. # equal_list None个样本 [1, 0, 1, 0, 1, 1,..........]
  141. accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32))
  142. # 定义一个初始化变量的op
  143. init_op = tf.global_variables_initializer()
  144. # 开启回话运行
  145. with tf.Session() as sess:
  146. sess.run(init_op)
  147. # 循环去训练
  148. for i in range(1000):
  149. # 取出真实存在的特征值和目标值
  150. mnist_x, mnist_y = mnist.train.next_batch(50)
  151. # 运行train_op训练
  152. sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y})
  153. print("训练第%d步,准确率为:%f" % (i, sess.run(accuracy, feed_dict={x: mnist_x, y_true: mnist_y})))
  154. return None
  155. if __name__ == "__main__":
  156. conv_fc()

 

 Tensorflow-卷积神经网络构建.

代码:

  1. ​​import numpy as np
  2. import tensorflow as tf
  3. input_ = np.random.randn(1,32,32,1).astype('float32')
  4. filter_ = np.random.randn(5,5,1,8).astype('float32')
  5. conv1 = tf.nn.conv2d(input_,filter_,[1,1,1,1],'VALID')
  6. conv1 = tf.nn.relu(conv1)
  7. # 池化
  8. pool1 = tf.nn.max_pool(conv1,[1,2,2,1],[1,2,2,1],'SAME')
  9. #第二层卷积
  10. filter2_ = np.random.randn(5,5,8,20).astype('float32')
  11. conv2 = tf.nn.conv2d(pool1,filter2_,[1,1,1,1],'VALID')
  12. #第二层池化
  13. pool2 = tf.nn.max_pool(conv2,[1,2,2,1],[1,2,2,1],'SAME')
  14. #第三层卷积
  15. filter3_ = np.random.randn(5,5,20,120).astype('float32')
  16. conv3 = tf.nn.conv2d(pool2,filter3_,[1,1,1,1],'VALID')
  17. #全连接层
  18. full = tf.reshape(conv3,shape = (1,120))
  19. W = tf.random_normal(shape = [120,9])
  20. fc = tf.matmul(full,W)
  21. fc
  22. nd = np.random.randn(30)
  23. tf.nn.relu(nd)
  24. with tf.Session() as sess:
  25. ret =sess.run(tf.nn.relu(nd))
  26. print(ret)

 

版权声明:如无特殊说明,文章均为本站原创,转载请注明出处

本文链接:http://wakemeupnow.cn/article/rnn0/