卷积神经网络的概念

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

 

 Tensorflow-卷积神经网络构建.

代码：

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

 

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

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