原文：TensorFlow Tutorials

译者：飞龙

协议：CC BY-NC-SA 4.0

1.1 TensorFlow 基本操作

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. import tensorflow as tf
  3. # 基本的常量操作
  4. # 由构造器返回的值
  5. # 表示常量操作的输出
  6. a = tf.constant(2)
  7. b = tf.constant(3)
  9. # 加载默认图
  10. with tf.Session() as sess:
  11.     print "a=2, b=3"
  12.     print "Addition with constants: %i" % sess.run(a+b)
  13.     print "Multiplication with constants: %i" % sess.run(a*b)
  15. '''
  16. a=2, b=3
  17. Addition with constants: 5
  18. Multiplication with constants: 6
  19. '''
  21. # 作为图输入的变量的基本操作
  22. # 由构造器返回的值
  23. # 表示变量操作的输出（运行会话时定义为输出）
  24. # TF 图输入
  25. a = tf.placeholder(tf.int16)
  26. b = tf.placeholder(tf.int16)
  28. # 定义一些操作
  29. add = tf.add(a, b)
  30. mul = tf.mul(a, b)
  32. # 加载默认图
  33. with tf.Session() as sess:
  34.     # 使用遍历输入运行每个操作
  35.     print "Addition with variables: %i" % sess.run(add, feed_dict={a: 2, b: 3})
  36.     print "Multiplication with variables: %i" % sess.run(mul, feed_dict={a: 2, b: 3})
  38. '''
  39. Addition with variables: 5
  40. Multiplication with variables: 6
  41. '''
  43. # ----------------
  44. # 更多细节：
  45. # 来自 TF 官方教程的矩阵乘法教程
  47. # 创建常量操作，产生 1x2 矩阵
  48. # 操作作为节点添加到默认图中
  49. #
  50. # 由构造器返回的值
  51. # 表示常量操作的输出
  52. matrix1 = tf.constant([[3., 3.]])
  54. # 创建另一个常量，产生 2x1 矩阵
  55. matrix2 = tf.constant([[2.],[2.]])
  57. # 创建 Matmul 操作，它接受 'matrix1' 和 'matrix2' 作为输入
  58. # 返回的值 'product' 表示矩阵乘法的结果
  59. product = tf.matmul(matrix1, matrix2)
  61. # 为了执行 matmul 操作，我们调用会话的 'run()' 方法，传入 'product'
  62. # 它表示 matmul 操作的输出。这对调用表明我们向获取 matmul 操作的输出
  63. #
  64. # 操作所需的所有输入都由会话自动运行
  65. # 它们通常是并行运行的
  66. #
  67. # 'run(product)' 的调用会执行图中的三个操作：
  68. # 两个常量和 matmul
  69. #
  70. # 操作的输出在 'result' 中返回，作为 NumPy `ndarray` 对象
  71. with tf.Session() as sess:
  72.     result = sess.run(product)
  73.     print result
  75. # [[ 12.]]

1.2 TensorFlow 线性回归

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. import tensorflow as tf
  2. import numpy
  3. import matplotlib.pyplot as plt
  4. rng = numpy.random
  6. # 参数
  7. learning_rate = 0.01
  8. training_epochs = 2000
  9. display_step = 50
  11. # 训练数据
  12. train_X = numpy.asarray([3.3,4.4,5.5,6.71,6.93,4.168,9.779,6.182,7.59,2.167,7.042,10.791,5.313,7.997,5.654,9.27,3.1])
  13. train_Y = numpy.asarray([1.7,2.76,2.09,3.19,1.694,1.573,3.366,2.596,2.53,1.221,2.827,3.465,1.65,2.904,2.42,2.94,1.3])
  14. n_samples = train_X.shape[0]
  16. # TF 图输入
  17. X = tf.placeholder("float")
  18. Y = tf.placeholder("float")
  20. # 创建模型
  22. # 设置模型权重
  23. W = tf.Variable(rng.randn(), name="weight")
  24. b = tf.Variable(rng.randn(), name="bias")
  26. # 构造线性模型
  27. activation = tf.add(tf.mul(X, W), b)
  29. # 最小化平方误差
  30. cost = tf.reduce_sum(tf.pow(activation-Y, 2))/(2*n_samples) #L2 loss
  31. optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) #Gradient descent
  33. # 初始化变量
  34. init = tf.initialize_all_variables()
  36. # 加载图
  37. with tf.Session() as sess:
  38.     sess.run(init)
  40.     # 拟合所有训练数据
  41.     for epoch in range(training_epochs):
  42.         for (x, y) in zip(train_X, train_Y):
  43.             sess.run(optimizer, feed_dict={X: x, Y: y})
  45.         # 展示每一步的日志
  46.         if epoch % display_step == 0:
  47.             print "Epoch:", '%04d' % (epoch+1), "cost=", \
  48.                 "{:.9f}".format(sess.run(cost, feed_dict={X: train_X, Y:train_Y})), \
  49.                 "W=", sess.run(W), "b=", sess.run(b)
  51.     print "Optimization Finished!"
  52.     print "cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), \
  53.           "W=", sess.run(W), "b=", sess.run(b)
  55.     # 展示图
  56.     plt.plot(train_X, train_Y, 'ro', label='Original data')
  57.     plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
  58.     plt.legend()
  59.     plt.show()
  61. '''
  62. Epoch: 0001 cost= 3.389688730 W= 0.0198441 b= -0.273522
  63. Epoch: 0051 cost= 0.134034902 W= 0.383208 b= -0.159746
  64. Epoch: 0101 cost= 0.127440125 W= 0.375261 b= -0.102578
  65. Epoch: 0151 cost= 0.121607177 W= 0.367787 b= -0.0488099
  66. Epoch: 0201 cost= 0.116448022 W= 0.360758 b= 0.00175997
  67. Epoch: 0251 cost= 0.111884907 W= 0.354146 b= 0.0493223
  68. Epoch: 0301 cost= 0.107848980 W= 0.347928 b= 0.0940558
  69. Epoch: 0351 cost= 0.104279339 W= 0.34208 b= 0.136129
  70. Epoch: 0401 cost= 0.101122171 W= 0.336579 b= 0.1757
  71. Epoch: 0451 cost= 0.098329842 W= 0.331405 b= 0.212917
  72. Epoch: 0501 cost= 0.095860250 W= 0.32654 b= 0.247921
  73. Epoch: 0551 cost= 0.093676031 W= 0.321963 b= 0.280843
  74. Epoch: 0601 cost= 0.091744311 W= 0.317659 b= 0.311807
  75. Epoch: 0651 cost= 0.090035893 W= 0.313611 b= 0.340929
  76. Epoch: 0701 cost= 0.088524953 W= 0.309804 b= 0.36832
  77. Epoch: 0751 cost= 0.087188691 W= 0.306222 b= 0.394082
  78. Epoch: 0801 cost= 0.086007021 W= 0.302854 b= 0.418311
  79. Epoch: 0851 cost= 0.084961981 W= 0.299687 b= 0.441099
  80. Epoch: 0901 cost= 0.084037818 W= 0.296708 b= 0.462532
  81. Epoch: 0951 cost= 0.083220571 W= 0.293905 b= 0.48269
  82. Epoch: 1001 cost= 0.082497880 W= 0.29127 b= 0.50165
  83. Epoch: 1051 cost= 0.081858821 W= 0.288791 b= 0.519481
  84. Epoch: 1101 cost= 0.081293717 W= 0.28646 b= 0.536251
  85. Epoch: 1151 cost= 0.080794014 W= 0.284267 b= 0.552026
  86. Epoch: 1201 cost= 0.080352172 W= 0.282205 b= 0.566861
  87. Epoch: 1251 cost= 0.079961479 W= 0.280265 b= 0.580815
  88. Epoch: 1301 cost= 0.079616025 W= 0.278441 b= 0.593939
  89. Epoch: 1351 cost= 0.079310589 W= 0.276725 b= 0.606284
  90. Epoch: 1401 cost= 0.079040587 W= 0.275111 b= 0.617893
  91. Epoch: 1451 cost= 0.078801893 W= 0.273594 b= 0.62881
  92. Epoch: 1501 cost= 0.078590907 W= 0.272167 b= 0.639077
  93. Epoch: 1551 cost= 0.078404360 W= 0.270824 b= 0.648734
  94. Epoch: 1601 cost= 0.078239456 W= 0.269562 b= 0.657817
  95. Epoch: 1651 cost= 0.078093678 W= 0.268374 b= 0.66636
  96. Epoch: 1701 cost= 0.077964827 W= 0.267257 b= 0.674395
  97. Epoch: 1751 cost= 0.077850945 W= 0.266207 b= 0.681952
  98. Epoch: 1801 cost= 0.077750273 W= 0.265219 b= 0.68906
  99. Epoch: 1851 cost= 0.077661335 W= 0.264289 b= 0.695745
  100. Epoch: 1901 cost= 0.077582702 W= 0.263416 b= 0.702033
  101. Epoch: 1951 cost= 0.077513263 W= 0.262593 b= 0.707947
  102. Optimization Finished!
  103. cost= 0.077453 W= 0.261835 b= 0.713401
  104. '''
  106. from IPython.display import Image
  107. Image(filename='linearreg.png')

一、TensorFlow - 图1

1.3 TensorFlow Logistic 回归

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. # 导入 MINST 数据
  2. import input_data
  3. mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  5. '''
  6. Extracting /tmp/data/train-images-idx3-ubyte.gz
  7. Extracting /tmp/data/train-labels-idx1-ubyte.gz
  8. Extracting /tmp/data/t10k-images-idx3-ubyte.gz
  9. Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
  10. '''
  12. import tensorflow as tf
  14. # 参数
  15. learning_rate = 0.01
  16. training_epochs = 25
  17. batch_size = 100
  18. display_step = 1
  20. # TF 图输入
  21. x = tf.placeholder("float", [None, 784]) # mnist 数据图像，形状为 28*28=784
  22. y = tf.placeholder("float", [None, 10]) # 0-9 数字识别 => 10 个类
  24. # 创建模型
  26. # 设置模型权重
  27. W = tf.Variable(tf.zeros([784, 10]))
  28. b = tf.Variable(tf.zeros([10]))
  30. # 构造模型
  31. activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax
  33. # 最小化交叉熵误差
  34. # 交叉熵
  35. cost = -tf.reduce_sum(y*tf.log(activation)) 
  36. # 梯度下降
  37. optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) 
  39. # 初始化变量
  40. init = tf.initialize_all_variables()
  42. # 加载图
  43. with tf.Session() as sess:
  44.     sess.run(init)
  46.     # 训练循环
  47.     for epoch in range(training_epochs):
  48.         avg_cost = 0.
  49.         total_batch = int(mnist.train.num_examples/batch_size)
  50.         # 遍历所有批量
  51.         for i in range(total_batch):
  52.             batch_xs, batch_ys = mnist.train.next_batch(batch_size)
  53.             # 使用批量数据拟合训练
  54.             sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
  55.             # 计算平均损失
  56.             avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})/total_batch
  57.         #  展示每一步的日志
  58.         if epoch % display_step == 0:
  59.             print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost)
  61.     print "Optimization Finished!"
  63.     # 测试模型
  64.     correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1))
  65.     # 计算准确率
  66.     accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
  67.     print "Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})
  69. '''
  70. Epoch: 0001 cost= 29.860479714
  71. Epoch: 0002 cost= 22.080549484
  72. Epoch: 0003 cost= 21.237104595
  73. Epoch: 0004 cost= 20.460196280
  74. Epoch: 0005 cost= 20.185128237
  75. Epoch: 0006 cost= 19.940297202
  76. Epoch: 0007 cost= 19.645111119
  77. Epoch: 0008 cost= 19.507218031
  78. Epoch: 0009 cost= 19.389794492
  79. Epoch: 0010 cost= 19.177005816
  80. Epoch: 0011 cost= 19.082493615
  81. Epoch: 0012 cost= 19.072873598
  82. Epoch: 0013 cost= 18.938005402
  83. Epoch: 0014 cost= 18.891806430
  84. Epoch: 0015 cost= 18.839480221
  85. Epoch: 0016 cost= 18.769349510
  86. Epoch: 0017 cost= 18.590865587
  87. Epoch: 0018 cost= 18.623413677
  88. Epoch: 0019 cost= 18.546149085
  89. Epoch: 0020 cost= 18.432274895
  90. Epoch: 0021 cost= 18.358189004
  91. Epoch: 0022 cost= 18.380014628
  92. Epoch: 0023 cost= 18.499993471
  93. Epoch: 0024 cost= 18.386477311
  94. Epoch: 0025 cost= 18.258080609
  95. Optimization Finished!
  96. Accuracy: 0.9048
  97. '''

1.4 TensorFlow 最近邻

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. import numpy as np
  2. import tensorflow as tf
  4. # 导入 MINST 数据
  5. import input_data
  6. mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  8. '''
  9. Extracting /tmp/data/train-images-idx3-ubyte.gz
  10. Extracting /tmp/data/train-labels-idx1-ubyte.gz
  11. Extracting /tmp/data/t10k-images-idx3-ubyte.gz
  12. Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
  13. '''
  15. # 这个例子中，我们限制 mnist 数据
  16. Xtr, Ytr = mnist.train.next_batch(5000) # 训练集 5000 个（nn 候选）
  17. Xte, Yte = mnist.test.next_batch(200) # 测试集 200 个
  19. # 将图像的形状变为一维
  20. Xtr = np.reshape(Xtr, newshape=(-1, 28*28))
  21. Xte = np.reshape(Xte, newshape=(-1, 28*28))
  23. # TF 图输入
  24. xtr = tf.placeholder("float", [None, 784])
  25. xte = tf.placeholder("float", [784])
  27. # 使用 L1 距离计算最近邻
  28. distance = tf.reduce_sum(tf.abs(tf.add(xtr, tf.neg(xte))), reduction_indices=1)
  29. # 预测：获取最小距离的下标（最近邻）
  30. pred = tf.arg_min(distance, 0)
  32. accuracy = 0.
  34. # 初始化变量
  35. init = tf.initialize_all_variables()
  37. # 加载图
  38. with tf.Session() as sess:
  39.     sess.run(init)
  41.     # 遍历测试数据
  42.     for i in range(len(Xte)):
  43.         # 获取最近邻
  44.         nn_index = sess.run(pred, feed_dict={xtr: Xtr, xte: Xte[i,:]})
  45.         # 获取最近邻的类标签，并将其与真实标签比较
  46.         print "Test", i, "Prediction:", np.argmax(Ytr[nn_index]), \
  47.               "True Class:", np.argmax(Yte[i])
  48.         # 计算准确率
  49.         if np.argmax(Ytr[nn_index]) == np.argmax(Yte[i]):
  50.             accuracy += 1./len(Xte)
  51.     print "Done!"
  52.     print "Accuracy:", accuracy
  54. '''
  55. Test 0 Prediction: 7 True Class: 7
  56. Test 1 Prediction: 2 True Class: 2
  57. Test 2 Prediction: 1 True Class: 1
  58. Test 3 Prediction: 0 True Class: 0
  59. Test 4 Prediction: 4 True Class: 4
  60. Test 5 Prediction: 1 True Class: 1
  61. Test 6 Prediction: 4 True Class: 4
  62. Test 7 Prediction: 9 True Class: 9
  63. Test 8 Prediction: 8 True Class: 5
  64. Test 9 Prediction: 9 True Class: 9
  65. Test 10 Prediction: 0 True Class: 0
  66. Test 11 Prediction: 0 True Class: 6
  67. Test 12 Prediction: 9 True Class: 9
  68. Test 13 Prediction: 0 True Class: 0
  69. Test 14 Prediction: 1 True Class: 1
  70. Test 15 Prediction: 5 True Class: 5
  71. Test 16 Prediction: 4 True Class: 9
  72. Test 17 Prediction: 7 True Class: 7
  73. Test 18 Prediction: 3 True Class: 3
  74. Test 19 Prediction: 4 True Class: 4
  75. Test 20 Prediction: 9 True Class: 9
  76. Test 21 Prediction: 6 True Class: 6
  77. Test 22 Prediction: 6 True Class: 6
  78. Test 23 Prediction: 5 True Class: 5
  79. Test 24 Prediction: 4 True Class: 4
  80. Test 25 Prediction: 0 True Class: 0
  81. Test 26 Prediction: 7 True Class: 7
  82. Test 27 Prediction: 4 True Class: 4
  83. Test 28 Prediction: 0 True Class: 0
  84. Test 29 Prediction: 1 True Class: 1
  85. Test 30 Prediction: 3 True Class: 3
  86. Test 31 Prediction: 1 True Class: 1
  87. Test 32 Prediction: 3 True Class: 3
  88. Test 33 Prediction: 4 True Class: 4
  89. Test 34 Prediction: 7 True Class: 7
  90. Test 35 Prediction: 2 True Class: 2
  91. Test 36 Prediction: 7 True Class: 7
  92. Test 37 Prediction: 1 True Class: 1
  93. Test 38 Prediction: 2 True Class: 2
  94. Test 39 Prediction: 1 True Class: 1
  95. Test 40 Prediction: 1 True Class: 1
  96. Test 41 Prediction: 7 True Class: 7
  97. Test 42 Prediction: 4 True Class: 4
  98. Test 43 Prediction: 1 True Class: 2
  99. Test 44 Prediction: 3 True Class: 3
  100. Test 45 Prediction: 5 True Class: 5
  101. Test 46 Prediction: 1 True Class: 1
  102. Test 47 Prediction: 2 True Class: 2
  103. Test 48 Prediction: 4 True Class: 4
  104. Test 49 Prediction: 4 True Class: 4
  105. Test 50 Prediction: 6 True Class: 6
  106. Test 51 Prediction: 3 True Class: 3
  107. Test 52 Prediction: 5 True Class: 5
  108. Test 53 Prediction: 5 True Class: 5
  109. Test 54 Prediction: 6 True Class: 6
  110. Test 55 Prediction: 0 True Class: 0
  111. Test 56 Prediction: 4 True Class: 4
  112. Test 57 Prediction: 1 True Class: 1
  113. Test 58 Prediction: 9 True Class: 9
  114. Test 59 Prediction: 5 True Class: 5
  115. Test 60 Prediction: 7 True Class: 7
  116. Test 61 Prediction: 8 True Class: 8
  117. Test 62 Prediction: 9 True Class: 9
  118. Test 63 Prediction: 3 True Class: 3
  119. Test 64 Prediction: 7 True Class: 7
  120. Test 65 Prediction: 4 True Class: 4
  121. Test 66 Prediction: 6 True Class: 6
  122. Test 67 Prediction: 4 True Class: 4
  123. Test 68 Prediction: 3 True Class: 3
  124. Test 69 Prediction: 0 True Class: 0
  125. Test 70 Prediction: 7 True Class: 7
  126. Test 71 Prediction: 0 True Class: 0
  127. Test 72 Prediction: 2 True Class: 2
  128. Test 73 Prediction: 7 True Class: 9
  129. Test 74 Prediction: 1 True Class: 1
  130. Test 75 Prediction: 7 True Class: 7
  131. Test 76 Prediction: 3 True Class: 3
  132. Test 77 Prediction: 7 True Class: 2
  133. Test 78 Prediction: 9 True Class: 9
  134. Test 79 Prediction: 7 True Class: 7
  135. Test 80 Prediction: 7 True Class: 7
  136. Test 81 Prediction: 6 True Class: 6
  137. Test 82 Prediction: 2 True Class: 2
  138. Test 83 Prediction: 7 True Class: 7
  139. Test 84 Prediction: 8 True Class: 8
  140. Test 85 Prediction: 4 True Class: 4
  141. Test 86 Prediction: 7 True Class: 7
  142. Test 87 Prediction: 3 True Class: 3
  143. Test 88 Prediction: 6 True Class: 6
  144. Test 89 Prediction: 1 True Class: 1
  145. Test 90 Prediction: 3 True Class: 3
  146. Test 91 Prediction: 6 True Class: 6
  147. Test 92 Prediction: 9 True Class: 9
  148. Test 93 Prediction: 3 True Class: 3
  149. Test 94 Prediction: 1 True Class: 1
  150. Test 95 Prediction: 4 True Class: 4
  151. Test 96 Prediction: 1 True Class: 1
  152. Test 97 Prediction: 7 True Class: 7
  153. Test 98 Prediction: 6 True Class: 6
  154. Test 99 Prediction: 9 True Class: 9
  155. Test 100 Prediction: 6 True Class: 6
  156. Test 101 Prediction: 0 True Class: 0
  157. Test 102 Prediction: 5 True Class: 5
  158. Test 103 Prediction: 4 True Class: 4
  159. Test 104 Prediction: 9 True Class: 9
  160. Test 105 Prediction: 9 True Class: 9
  161. Test 106 Prediction: 2 True Class: 2
  162. Test 107 Prediction: 1 True Class: 1
  163. Test 108 Prediction: 9 True Class: 9
  164. Test 109 Prediction: 4 True Class: 4
  165. Test 110 Prediction: 8 True Class: 8
  166. Test 111 Prediction: 7 True Class: 7
  167. Test 112 Prediction: 3 True Class: 3
  168. Test 113 Prediction: 9 True Class: 9
  169. Test 114 Prediction: 7 True Class: 7
  170. Test 115 Prediction: 9 True Class: 4
  171. Test 116 Prediction: 9 True Class: 4
  172. Test 117 Prediction: 4 True Class: 4
  173. Test 118 Prediction: 9 True Class: 9
  174. Test 119 Prediction: 7 True Class: 2
  175. Test 120 Prediction: 5 True Class: 5
  176. Test 121 Prediction: 4 True Class: 4
  177. Test 122 Prediction: 7 True Class: 7
  178. Test 123 Prediction: 6 True Class: 6
  179. Test 124 Prediction: 7 True Class: 7
  180. Test 125 Prediction: 9 True Class: 9
  181. Test 126 Prediction: 0 True Class: 0
  182. Test 127 Prediction: 5 True Class: 5
  183. Test 128 Prediction: 8 True Class: 8
  184. Test 129 Prediction: 5 True Class: 5
  185. Test 130 Prediction: 6 True Class: 6
  186. Test 131 Prediction: 6 True Class: 6
  187. Test 132 Prediction: 5 True Class: 5
  188. Test 133 Prediction: 7 True Class: 7
  189. Test 134 Prediction: 8 True Class: 8
  190. Test 135 Prediction: 1 True Class: 1
  191. Test 136 Prediction: 0 True Class: 0
  192. Test 137 Prediction: 1 True Class: 1
  193. Test 138 Prediction: 6 True Class: 6
  194. Test 139 Prediction: 4 True Class: 4
  195. Test 140 Prediction: 6 True Class: 6
  196. Test 141 Prediction: 7 True Class: 7
  197. Test 142 Prediction: 2 True Class: 3
  198. Test 143 Prediction: 1 True Class: 1
  199. Test 144 Prediction: 7 True Class: 7
  200. Test 145 Prediction: 1 True Class: 1
  201. Test 146 Prediction: 8 True Class: 8
  202. Test 147 Prediction: 2 True Class: 2
  203. Test 148 Prediction: 0 True Class: 0
  204. Test 149 Prediction: 1 True Class: 2
  205. Test 150 Prediction: 9 True Class: 9
  206. Test 151 Prediction: 9 True Class: 9
  207. Test 152 Prediction: 5 True Class: 5
  208. Test 153 Prediction: 5 True Class: 5
  209. Test 154 Prediction: 1 True Class: 1
  210. Test 155 Prediction: 5 True Class: 5
  211. Test 156 Prediction: 6 True Class: 6
  212. Test 157 Prediction: 0 True Class: 0
  213. Test 158 Prediction: 3 True Class: 3
  214. Test 159 Prediction: 4 True Class: 4
  215. Test 160 Prediction: 4 True Class: 4
  216. Test 161 Prediction: 6 True Class: 6
  217. Test 162 Prediction: 5 True Class: 5
  218. Test 163 Prediction: 4 True Class: 4
  219. Test 164 Prediction: 6 True Class: 6
  220. Test 165 Prediction: 5 True Class: 5
  221. Test 166 Prediction: 4 True Class: 4
  222. Test 167 Prediction: 5 True Class: 5
  223. Test 168 Prediction: 1 True Class: 1
  224. Test 169 Prediction: 4 True Class: 4
  225. Test 170 Prediction: 9 True Class: 4
  226. Test 171 Prediction: 7 True Class: 7
  227. Test 172 Prediction: 2 True Class: 2
  228. Test 173 Prediction: 3 True Class: 3
  229. Test 174 Prediction: 2 True Class: 2
  230. Test 175 Prediction: 1 True Class: 7
  231. Test 176 Prediction: 1 True Class: 1
  232. Test 177 Prediction: 8 True Class: 8
  233. Test 178 Prediction: 1 True Class: 1
  234. Test 179 Prediction: 8 True Class: 8
  235. Test 180 Prediction: 1 True Class: 1
  236. Test 181 Prediction: 8 True Class: 8
  237. Test 182 Prediction: 5 True Class: 5
  238. Test 183 Prediction: 0 True Class: 0
  239. Test 184 Prediction: 2 True Class: 8
  240. Test 185 Prediction: 9 True Class: 9
  241. Test 186 Prediction: 2 True Class: 2
  242. Test 187 Prediction: 5 True Class: 5
  243. Test 188 Prediction: 0 True Class: 0
  244. Test 189 Prediction: 1 True Class: 1
  245. Test 190 Prediction: 1 True Class: 1
  246. Test 191 Prediction: 1 True Class: 1
  247. Test 192 Prediction: 0 True Class: 0
  248. Test 193 Prediction: 4 True Class: 9
  249. Test 194 Prediction: 0 True Class: 0
  250. Test 195 Prediction: 1 True Class: 3
  251. Test 196 Prediction: 1 True Class: 1
  252. Test 197 Prediction: 6 True Class: 6
  253. Test 198 Prediction: 4 True Class: 4
  254. Test 199 Prediction: 2 True Class: 2
  255. Done!
  256. Accuracy: 0.92
  257. '''

1.5 TensorFlow AlexNet

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. # 导入 MINST 数据
  2. import input_data
  3. mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  5. '''
  6. Extracting /tmp/data/train-images-idx3-ubyte.gz
  7. Extracting /tmp/data/train-labels-idx1-ubyte.gz
  8. Extracting /tmp/data/t10k-images-idx3-ubyte.gz
  9. Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
  10. '''
  12. import tensorflow as tf
  14. # 参数
  15. learning_rate = 0.001
  16. training_iters = 300000
  17. batch_size = 64
  18. display_step = 100
  20. # 网络参数
  21. n_input = 784 # MNIST 数据输入（图像大小：28x28）
  22. n_classes = 10 # MNIST 全部类别（0-9 的数字）
  23. dropout = 0.8 # 丢弃，单元被保留的概率
  25. # TF 图输入
  26. x = tf.placeholder(tf.float32, [None, n_input])
  27. y = tf.placeholder(tf.float32, [None, n_classes])
  28. keep_prob = tf.placeholder(tf.float32) # 丢弃（保留的概率）
  30. # 创建 AlexNet 模型
  31. def conv2d(name, l_input, w, b):
  32.     return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(l_input, w, strides=[1, 1, 1, 1], 
  33.                                                   padding='SAME'),b), name=name)
  35. def max_pool(name, l_input, k):
  36.     return tf.nn.max_pool(l_input, ksize=[1, k, k, 1], strides=[1, k, k, 1], 
  37.                           padding='SAME', name=name)
  39. def norm(name, l_input, lsize=4):
  40.     return tf.nn.lrn(l_input, lsize, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name=name)
  42. def alex_net(_X, _weights, _biases, _dropout):
  43.     # 改变输入图片的形状
  44.     _X = tf.reshape(_X, shape=[-1, 28, 28, 1])
  46.     # 卷积层
  47.     conv1 = conv2d('conv1', _X, _weights['wc1'], _biases['bc1'])
  48.     # 最大池化（下采样）
  49.     pool1 = max_pool('pool1', conv1, k=2)
  50.     # 应用标准化
  51.     norm1 = norm('norm1', pool1, lsize=4)
  52.     # 应用丢弃
  53.     norm1 = tf.nn.dropout(norm1, _dropout)
  55.     # 卷积层
  56.     conv2 = conv2d('conv2', norm1, _weights['wc2'], _biases['bc2'])
  57.     # 最大池化（下采样）
  58.     pool2 = max_pool('pool2', conv2, k=2)
  59.     # 应用标准化
  60.     norm2 = norm('norm2', pool2, lsize=4)
  61.     # 应用丢弃
  62.     norm2 = tf.nn.dropout(norm2, _dropout)
  64.     # 卷积层
  65.     conv3 = conv2d('conv3', norm2, _weights['wc3'], _biases['bc3'])
  66.     # 最大池化（下采样）
  67.     pool3 = max_pool('pool3', conv3, k=2)
  68.     # 应用标准化
  69.     norm3 = norm('norm3', pool3, lsize=4)
  70.     # 应用丢弃
  71.     norm3 = tf.nn.dropout(norm3, _dropout)
  73.     # 全连接层
  74.     # 修改 conv3 输出的形状来匹配密集层的输入
  75.     dense1 = tf.reshape(norm3, [-1, _weights['wd1'].get_shape().as_list()[0]]) 
  76.     # Relu 激活
  77.     dense1 = tf.nn.relu(tf.matmul(dense1, _weights['wd1']) + _biases['bd1'], name='fc1')
  79.     # Relu 激活
  80.     dense2 = tf.nn.relu(tf.matmul(dense1, _weights['wd2']) + _biases['bd2'], name='fc2') 
  82.     # 输出，类的预测
  83.     out = tf.matmul(dense2, _weights['out']) + _biases['out']
  84.     return out
  86. # 储存层的权重和偏置
  87. weights = {
  88.     'wc1': tf.Variable(tf.random_normal([3, 3, 1, 64])),
  89.     'wc2': tf.Variable(tf.random_normal([3, 3, 64, 128])),
  90.     'wc3': tf.Variable(tf.random_normal([3, 3, 128, 256])),
  91.     'wd1': tf.Variable(tf.random_normal([4*4*256, 1024])),
  92.     'wd2': tf.Variable(tf.random_normal([1024, 1024])),
  93.     'out': tf.Variable(tf.random_normal([1024, 10]))
  94. }
  95. biases = {
  96.     'bc1': tf.Variable(tf.random_normal([64])),
  97.     'bc2': tf.Variable(tf.random_normal([128])),
  98.     'bc3': tf.Variable(tf.random_normal([256])),
  99.     'bd1': tf.Variable(tf.random_normal([1024])),
  100.     'bd2': tf.Variable(tf.random_normal([1024])),
  101.     'out': tf.Variable(tf.random_normal([n_classes]))
  102. }
  104. # 构造模型
  105. pred = alex_net(x, weights, biases, keep_prob)
  107. # 定义损失和优化器
  108. cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
  109. optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
  111. # 评估模型
  112. correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
  113. accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
  115. # 初始化变量
  116. init = tf.global_variables_initializer()
  118. # 加载图
  119. with tf.Session() as sess:
  120.     sess.run(init)
  121.     step = 1
  122.     # 持续训练，直到达到最大迭代
  123.     while step * batch_size < training_iters:
  124.         batch_xs, batch_ys = mnist.train.next_batch(batch_size)
  125.         # 使用批量数据拟合训练
  126.         sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys, keep_prob: dropout})
  127.         if step % display_step == 0:
  128.             # 计算批量准确率
  129.             acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
  130.             # 计算批量损失
  131.             loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
  132.             print "Iter " + str(step*batch_size) + ", Minibatch Loss= " \
  133.                   + "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc)
  134.         step += 1
  135.     print "Optimization Finished!"
  136.     # 为 256 个 mnist 测试图像计算准确率
  137.     print "Testing Accuracy:", sess.run(accuracy, feed_dict={x: mnist.test.images[:256], 
  138.                                                              y: mnist.test.labels[:256], 
  139.                                                              keep_prob: 1.})
  141. '''
  142. Iter 6400, Minibatch Loss= 29666.185547, Training Accuracy= 0.59375
  143. Iter 12800, Minibatch Loss= 22125.562500, Training Accuracy= 0.60938
  144. Iter 19200, Minibatch Loss= 22631.134766, Training Accuracy= 0.59375
  145. Iter 25600, Minibatch Loss= 18498.414062, Training Accuracy= 0.62500
  146. Iter 32000, Minibatch Loss= 11318.283203, Training Accuracy= 0.70312
  147. Iter 38400, Minibatch Loss= 12076.280273, Training Accuracy= 0.70312
  148. Iter 44800, Minibatch Loss= 8195.520508, Training Accuracy= 0.82812
  149. Iter 51200, Minibatch Loss= 5176.181641, Training Accuracy= 0.84375
  150. Iter 57600, Minibatch Loss= 8951.896484, Training Accuracy= 0.81250
  151. Iter 64000, Minibatch Loss= 10096.946289, Training Accuracy= 0.78125
  152. Iter 70400, Minibatch Loss= 11466.641602, Training Accuracy= 0.68750
  153. Iter 76800, Minibatch Loss= 7469.824219, Training Accuracy= 0.78125
  154. Iter 83200, Minibatch Loss= 4147.449219, Training Accuracy= 0.89062
  155. Iter 89600, Minibatch Loss= 5904.782227, Training Accuracy= 0.82812
  156. Iter 96000, Minibatch Loss= 718.493713, Training Accuracy= 0.93750
  157. Iter 102400, Minibatch Loss= 2184.151367, Training Accuracy= 0.93750
  158. Iter 108800, Minibatch Loss= 2354.463135, Training Accuracy= 0.89062
  159. Iter 115200, Minibatch Loss= 8612.959961, Training Accuracy= 0.81250
  160. Iter 121600, Minibatch Loss= 2225.773926, Training Accuracy= 0.84375
  161. Iter 128000, Minibatch Loss= 160.583618, Training Accuracy= 0.96875
  162. Iter 134400, Minibatch Loss= 1524.846069, Training Accuracy= 0.93750
  163. Iter 140800, Minibatch Loss= 3501.871094, Training Accuracy= 0.89062
  164. Iter 147200, Minibatch Loss= 661.977051, Training Accuracy= 0.96875
  165. Iter 153600, Minibatch Loss= 367.857788, Training Accuracy= 0.98438
  166. Iter 160000, Minibatch Loss= 1735.458740, Training Accuracy= 0.90625
  167. Iter 166400, Minibatch Loss= 209.320374, Training Accuracy= 0.95312
  168. Iter 172800, Minibatch Loss= 1788.553955, Training Accuracy= 0.90625
  169. Iter 179200, Minibatch Loss= 912.995544, Training Accuracy= 0.93750
  170. Iter 185600, Minibatch Loss= 2534.074463, Training Accuracy= 0.87500
  171. Iter 192000, Minibatch Loss= 73.052612, Training Accuracy= 0.96875
  172. Iter 198400, Minibatch Loss= 1609.606323, Training Accuracy= 0.93750
  173. Iter 204800, Minibatch Loss= 1823.219727, Training Accuracy= 0.96875
  174. Iter 211200, Minibatch Loss= 578.051086, Training Accuracy= 0.96875
  175. Iter 217600, Minibatch Loss= 1532.326172, Training Accuracy= 0.89062
  176. Iter 224000, Minibatch Loss= 769.775269, Training Accuracy= 0.95312
  177. Iter 230400, Minibatch Loss= 2614.737793, Training Accuracy= 0.92188
  178. Iter 236800, Minibatch Loss= 938.664368, Training Accuracy= 0.95312
  179. Iter 243200, Minibatch Loss= 1520.495605, Training Accuracy= 0.93750
  180. Iter 249600, Minibatch Loss= 657.419739, Training Accuracy= 0.95312
  181. Iter 256000, Minibatch Loss= 522.802124, Training Accuracy= 0.90625
  182. Iter 262400, Minibatch Loss= 211.188477, Training Accuracy= 0.96875
  183. Iter 268800, Minibatch Loss= 520.451172, Training Accuracy= 0.92188
  184. Iter 275200, Minibatch Loss= 1418.759155, Training Accuracy= 0.89062
  185. Iter 281600, Minibatch Loss= 241.748596, Training Accuracy= 0.96875
  186. Iter 288000, Minibatch Loss= 0.000000, Training Accuracy= 1.00000
  187. Iter 294400, Minibatch Loss= 1535.772827, Training Accuracy= 0.92188
  188. Optimization Finished!
  189. Testing Accuracy: 0.980469
  190. '''

1.6 TensorFlow 卷积神经网络

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. # 导入 MINST 数据
  2. import input_data
  3. mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  5. '''
  6. Extracting /tmp/data/train-images-idx3-ubyte.gz
  7. Extracting /tmp/data/train-labels-idx1-ubyte.gz
  8. Extracting /tmp/data/t10k-images-idx3-ubyte.gz
  9. Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
  10. '''
  12. import tensorflow as tf
  14. # 参数
  15. learning_rate = 0.001
  16. training_iters = 100000
  17. batch_size = 128
  18. display_step = 20
  20. # 网络参数
  21. n_input = 784 # MNIST 数据输入（图像大小：28x28）
  22. n_classes = 10 # MNIST 全部类别（0-9 的数字）
  23. dropout = 0.75 # 丢弃，单元被保留的概率
  25. # TF 图输入
  26. x = tf.placeholder(tf.float32, [None, n_input])
  27. y = tf.placeholder(tf.float32, [None, n_classes])
  28. keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)
  30. # 创建模型
  31. def conv2d(img, w, b):
  32.     return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(img, w, strides=[1, 1, 1, 1], 
  33.                                                   padding='SAME'),b))
  35. def max_pool(img, k):
  36.     return tf.nn.max_pool(img, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')
  38. def conv_net(_X, _weights, _biases, _dropout):
  39.     # 改变输入图片的形状
  40.     _X = tf.reshape(_X, shape=[-1, 28, 28, 1])
  42.     # 卷积层
  43.     conv1 = conv2d(_X, _weights['wc1'], _biases['bc1'])
  44.     # 最大池化（下采样）
  45.     conv1 = max_pool(conv1, k=2)
  46.     # 应用丢弃
  47.     conv1 = tf.nn.dropout(conv1, _dropout)
  49.     # 卷积层
  50.     conv2 = conv2d(conv1, _weights['wc2'], _biases['bc2'])
  51.     # 最大池化（下采样）
  52.     conv2 = max_pool(conv2, k=2)
  53.     # 应用丢弃
  54.     conv2 = tf.nn.dropout(conv2, _dropout)
  56.     # 全连接层
  57.     # Reshape conv2 output to fit dense layer input
  58.     dense1 = tf.reshape(conv2, [-1, _weights['wd1'].get_shape().as_list()[0]]) 
  59.     # Relu 激活
  60.     dense1 = tf.nn.relu(tf.add(tf.matmul(dense1, _weights['wd1']), _biases['bd1']))
  61.     # 应用丢弃
  62.     dense1 = tf.nn.dropout(dense1, _dropout) # 应用丢弃
  64.     # 输出，类的预测
  65.     out = tf.add(tf.matmul(dense1, _weights['out']), _biases['out'])
  66.     return out
  68. # 储存层的权重和偏置
  69. weights = {
  70.     # 5x5 卷积, 1 输入, 32 输出
  71.     'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])), 
  72.     # 5x5 卷积, 32 输入, 64 输出
  73.     'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])), 
  74.     # 全连接, 7*7*64 输入, 1024 输出
  75.     'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])), 
  76.     # 1024 输入, 10 输出（类别预测）
  77.     'out': tf.Variable(tf.random_normal([1024, n_classes])) 
  78. }
  80. biases = {
  81.     'bc1': tf.Variable(tf.random_normal([32])),
  82.     'bc2': tf.Variable(tf.random_normal([64])),
  83.     'bd1': tf.Variable(tf.random_normal([1024])),
  84.     'out': tf.Variable(tf.random_normal([n_classes]))
  85. }
  87. # 构造模型
  88. pred = conv_net(x, weights, biases, keep_prob)
  90. # 定义损失和优化器
  91. cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
  92. optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
  94. # 评估模型
  95. correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
  96. accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
  98. # 初始化变量
  99. init = tf.global_variables_initializer()
  101. # 加载图
  102. with tf.Session() as sess:
  103.     sess.run(init)
  104.     step = 1
  105.     # 持续训练，直到达到最大迭代
  106.     while step * batch_size < training_iters:
  107.         batch_xs, batch_ys = mnist.train.next_batch(batch_size)
  108.         # 使用批量数据拟合训练
  109.         sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys, keep_prob: dropout})
  110.         if step % display_step == 0:
  111.             # 计算批量准确率
  112.             acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
  113.             # 计算批量损失
  114.             loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
  115.             print "Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
  116.                   "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc)
  117.         step += 1
  118.     print "Optimization Finished!"
  119.     # 计算准确率 for 256 mnist test images
  120.     print "Testing Accuracy:", sess.run(accuracy, feed_dict={x: mnist.test.images[:256], 
  121.                                                              y: mnist.test.labels[:256], 
  122.                                                              keep_prob: 1.})
  124. '''
  125. Iter 2560, Minibatch Loss= 26046.011719, Training Accuracy= 0.21094
  126. Iter 5120, Minibatch Loss= 10456.769531, Training Accuracy= 0.52344
  127. Iter 7680, Minibatch Loss= 6273.207520, Training Accuracy= 0.71875
  128. Iter 10240, Minibatch Loss= 6276.231445, Training Accuracy= 0.64062
  129. Iter 12800, Minibatch Loss= 4188.221680, Training Accuracy= 0.77344
  130. Iter 15360, Minibatch Loss= 2717.077637, Training Accuracy= 0.80469
  131. Iter 17920, Minibatch Loss= 4057.120361, Training Accuracy= 0.81250
  132. Iter 20480, Minibatch Loss= 1696.550415, Training Accuracy= 0.87500
  133. Iter 23040, Minibatch Loss= 2525.317627, Training Accuracy= 0.85938
  134. Iter 25600, Minibatch Loss= 2341.906738, Training Accuracy= 0.87500
  135. Iter 28160, Minibatch Loss= 4200.535156, Training Accuracy= 0.79688
  136. Iter 30720, Minibatch Loss= 1888.964355, Training Accuracy= 0.89062
  137. Iter 33280, Minibatch Loss= 2167.645996, Training Accuracy= 0.84375
  138. Iter 35840, Minibatch Loss= 1932.107544, Training Accuracy= 0.89844
  139. Iter 38400, Minibatch Loss= 1562.430054, Training Accuracy= 0.90625
  140. Iter 40960, Minibatch Loss= 1676.755249, Training Accuracy= 0.84375
  141. Iter 43520, Minibatch Loss= 1003.626099, Training Accuracy= 0.93750
  142. Iter 46080, Minibatch Loss= 1176.615479, Training Accuracy= 0.86719
  143. Iter 48640, Minibatch Loss= 1260.592651, Training Accuracy= 0.88281
  144. Iter 51200, Minibatch Loss= 1399.667969, Training Accuracy= 0.86719
  145. Iter 53760, Minibatch Loss= 1259.961426, Training Accuracy= 0.89844
  146. Iter 56320, Minibatch Loss= 1415.800781, Training Accuracy= 0.89062
  147. Iter 58880, Minibatch Loss= 1835.365967, Training Accuracy= 0.85156
  148. Iter 61440, Minibatch Loss= 1395.168823, Training Accuracy= 0.90625
  149. Iter 64000, Minibatch Loss= 973.283569, Training Accuracy= 0.88281
  150. Iter 66560, Minibatch Loss= 818.093811, Training Accuracy= 0.92969
  151. Iter 69120, Minibatch Loss= 1178.744263, Training Accuracy= 0.92188
  152. Iter 71680, Minibatch Loss= 845.889709, Training Accuracy= 0.89844
  153. Iter 74240, Minibatch Loss= 1259.505615, Training Accuracy= 0.90625
  154. Iter 76800, Minibatch Loss= 738.037109, Training Accuracy= 0.89844
  155. Iter 79360, Minibatch Loss= 862.499146, Training Accuracy= 0.93750
  156. Iter 81920, Minibatch Loss= 739.704041, Training Accuracy= 0.90625
  157. Iter 84480, Minibatch Loss= 652.880310, Training Accuracy= 0.95312
  158. Iter 87040, Minibatch Loss= 635.464600, Training Accuracy= 0.92969
  159. Iter 89600, Minibatch Loss= 933.166626, Training Accuracy= 0.90625
  160. Iter 92160, Minibatch Loss= 213.874893, Training Accuracy= 0.96094
  161. Iter 94720, Minibatch Loss= 609.575684, Training Accuracy= 0.91406
  162. Iter 97280, Minibatch Loss= 560.208008, Training Accuracy= 0.93750
  163. Iter 99840, Minibatch Loss= 963.577148, Training Accuracy= 0.90625
  164. Optimization Finished!
  165. Testing Accuracy: 0.960938
  166. '''

1.7 TensorFlow 多层感知机

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. # 导入 MINST 数据
  2. import input_data
  3. mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  5. '''
  6. Extracting /tmp/data/train-images-idx3-ubyte.gz
  7. Extracting /tmp/data/train-labels-idx1-ubyte.gz
  8. Extracting /tmp/data/t10k-images-idx3-ubyte.gz
  9. Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
  10. '''
  12. import tensorflow as tf
  14. # 参数
  15. learning_rate = 0.001
  16. training_epochs = 15
  17. batch_size = 100
  18. display_step = 1
  20. # 网络参数
  21. n_hidden_1 = 256 # 第一层的特征数量
  22. n_hidden_2 = 256 # 第二层的特征数量
  23. n_input = 784 # MNIST 数据输入（图像形状：28x28）
  24. n_classes = 10 # MNIST 全部类比（0-9 的数字）
  26. # TF 图输入
  27. x = tf.placeholder("float", [None, n_input])
  28. y = tf.placeholder("float", [None, n_classes])
  30. # 创建模型
  31. def multilayer_perceptron(_X, _weights, _biases):
  32.     # 带有 RELU 激活的隐层
  33.     layer_1 = tf.nn.relu(tf.add(tf.matmul(_X, _weights['h1']), _biases['b1'])) 
  34.     # 带有 RELU 激活的隐层
  35.     layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, _weights['h2']), _biases['b2'])) 
  36.     return tf.matmul(layer_2, weights['out']) + biases['out']
  38. # 储存层的权重和偏置
  39. weights = {
  40.     'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
  41.     'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
  42.     'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes]))
  43. }
  44. biases = {
  45.     'b1': tf.Variable(tf.random_normal([n_hidden_1])),
  46.     'b2': tf.Variable(tf.random_normal([n_hidden_2])),
  47.     'out': tf.Variable(tf.random_normal([n_classes]))
  48. }
  50. # 构造模型
  51. pred = multilayer_perceptron(x, weights, biases)
  53. # 定义损失和优化器
  54. # Softmax 损失
  55. cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y)) 
  56. # Adam 优化器
  57. optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) 
  59. # 初始化变量
  60. init = tf.global_variables_initializer()
  62. # 加载图
  63. with tf.Session() as sess:
  64.     sess.run(init)
  66.     # 训练循环
  67.     for epoch in range(training_epochs):
  68.         avg_cost = 0.
  69.         total_batch = int(mnist.train.num_examples/batch_size)
  70.         # 遍历所有批量
  71.         for i in range(total_batch):
  72.             batch_xs, batch_ys = mnist.train.next_batch(batch_size)
  73.             # 使用批量数据拟合训练
  74.             sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
  75.             # 计算平均损失
  76.             avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})/total_batch
  77.         #  展示每一步的日志
  78.         if epoch % display_step == 0:
  79.             print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost)
  81.     print "Optimization Finished!"
  83.     # 测试模型
  84.     correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
  85.     # 计算准确率
  86.     accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
  87.     print "Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})
  89. '''
  90. Epoch: 0001 cost= 160.113980416
  91. Epoch: 0002 cost= 38.665780694
  92. Epoch: 0003 cost= 24.118004577
  93. Epoch: 0004 cost= 16.440921303
  94. Epoch: 0005 cost= 11.689460141
  95. Epoch: 0006 cost= 8.469423468
  96. Epoch: 0007 cost= 6.223237230
  97. Epoch: 0008 cost= 4.560174118
  98. Epoch: 0009 cost= 3.250516910
  99. Epoch: 0010 cost= 2.359658795
  100. Epoch: 0011 cost= 1.694081847
  101. Epoch: 0012 cost= 1.167997509
  102. Epoch: 0013 cost= 0.872986831
  103. Epoch: 0014 cost= 0.630616366
  104. Epoch: 0015 cost= 0.487381571
  105. Optimization Finished!
  106. Accuracy: 0.9462
  107. '''

1.8 TensorFlow 循环神经网络

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. # 导入 MINST 数据
  2. import input_data
  3. mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  5. import tensorflow as tf
  6. from tensorflow.models.rnn import rnn, rnn_cell
  7. import numpy as np
  9. '''
  10. Extracting /tmp/data/train-images-idx3-ubyte.gz
  11. Extracting /tmp/data/train-labels-idx1-ubyte.gz
  12. Extracting /tmp/data/t10k-images-idx3-ubyte.gz
  13. Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
  14. '''
  16. '''
  17. 为了使用 reccurent 神经网络对图像进行分类，我们将每个图像的行视为像素序列。
  18. 由于 MNIST 图像形状为 28*28 px，因此我们将为每个样本处理为 28 个 28 步序列。
  19. '''
  21. # 参数
  22. learning_rate = 0.001
  23. training_iters = 100000
  24. batch_size = 128
  25. display_step = 10
  27. # 网络参数
  28. n_input = 28 # MNIST 数据输入（图像大小：28x28）
  29. n_steps = 28 # 时间步骤
  30. n_hidden = 128 # 隐层的特征数量
  31. n_classes = 10 # MNIST 全部类别（0-9 的数字）
  33. # TF 图输入
  34. x = tf.placeholder("float", [None, n_steps, n_input])
  35. istate = tf.placeholder("float", [None, 2*n_hidden]) # 状态和单元 => 2x n_hidden
  36. y = tf.placeholder("float", [None, n_classes])
  38. # 定义权重
  39. weights = {
  40.     'hidden': tf.Variable(tf.random_normal([n_input, n_hidden])), # 隐层权重
  41.     'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
  42. }
  43. biases = {
  44.     'hidden': tf.Variable(tf.random_normal([n_hidden])),
  45.     'out': tf.Variable(tf.random_normal([n_classes]))
  46. }
  48. def RNN(_X, _istate, _weights, _biases):
  50.     # 输入形状：(batch_size, n_steps, n_input)
  51.     _X = tf.transpose(_X, [1, 0, 2])  # 转置 n_steps 和 batch_size
  52.     # 改变形状来准备隐层激活的输入
  53.     _X = tf.reshape(_X, [-1, n_input]) # (n_steps*batch_size, n_input)
  54.     # 线性激活
  55.     _X = tf.matmul(_X, _weights['hidden']) + _biases['hidden']
  57.     # 定义 lstm cell
  58.     lstm_cell = rnn_cell.BasicLSTMCell(n_hidden, forget_bias=1.0)
  59.     # 分割数据，因为 RNN 单元需要输入的列表，用于 RNN 内部循环
  60.     _X = tf.split(0, n_steps, _X) # n_steps * (batch_size, n_hidden)
  62.     # 获得 lstm 单元输入
  63.     outputs, states = rnn.rnn(lstm_cell, _X, initial_state=_istate)
  65.     # 线性激活
  66.     # 获取内部循环的最后输入
  67.     return tf.matmul(outputs[-1], _weights['out']) + _biases['out']
  69. pred = RNN(x, istate, weights, biases)
  71. # 定义损失和优化器
  72. cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y)) # Softmax 损失
  73. optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) # Adam 优化器
  75. # 评估模型
  76. correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
  77. accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
  79. # 初始化变量
  80. init = tf.global_variables_initializer()
  82. # 加载图
  83. with tf.Session() as sess:
  84.     sess.run(init)
  85.     step = 1
  86.     # 持续训练，直到达到最大迭代
  87.     while step * batch_size < training_iters:
  88.         batch_xs, batch_ys = mnist.train.next_batch(batch_size)
  89.         # 重塑数据来获取 28 个元素的 28 序列
  90.         batch_xs = batch_xs.reshape((batch_size, n_steps, n_input))
  91.         # 使用批量数据拟合训练
  92.         sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys,
  93.                                        istate: np.zeros((batch_size, 2*n_hidden))})
  94.         if step % display_step == 0:
  95.             # 计算批量准确率
  96.             acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys,
  97.                                                 istate: np.zeros((batch_size, 2*n_hidden))})
  98.             # 计算批量损失
  99.             loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys,
  100.                                              istate: np.zeros((batch_size, 2*n_hidden))})
  101.             print "Iter " + str(step*batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + \
  102.                   ", Training Accuracy= " + "{:.5f}".format(acc)
  103.         step += 1
  104.     print "Optimization Finished!"
  105.     # 为 256 个 mnist 测试图像计算准确率
  106.     test_len = 256
  107.     test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
  108.     test_label = mnist.test.labels[:test_len]
  109.     print "Testing Accuracy:", sess.run(accuracy, feed_dict={x: test_data, y: test_label,
  110.                                                              istate: np.zeros((test_len, 2*n_hidden))})
  112. '''
  113. Iter 1280, Minibatch Loss= 1.888242, Training Accuracy= 0.39844
  114. Iter 2560, Minibatch Loss= 1.519879, Training Accuracy= 0.47656
  115. Iter 3840, Minibatch Loss= 1.238005, Training Accuracy= 0.63281
  116. Iter 5120, Minibatch Loss= 0.933760, Training Accuracy= 0.71875
  117. Iter 6400, Minibatch Loss= 0.832130, Training Accuracy= 0.73438
  118. Iter 7680, Minibatch Loss= 0.979760, Training Accuracy= 0.70312
  119. Iter 8960, Minibatch Loss= 0.821921, Training Accuracy= 0.71875
  120. Iter 10240, Minibatch Loss= 0.710566, Training Accuracy= 0.79688
  121. Iter 11520, Minibatch Loss= 0.578501, Training Accuracy= 0.82812
  122. Iter 12800, Minibatch Loss= 0.765049, Training Accuracy= 0.75000
  123. Iter 14080, Minibatch Loss= 0.582995, Training Accuracy= 0.78125
  124. Iter 15360, Minibatch Loss= 0.575092, Training Accuracy= 0.79688
  125. Iter 16640, Minibatch Loss= 0.701214, Training Accuracy= 0.75781
  126. Iter 17920, Minibatch Loss= 0.561972, Training Accuracy= 0.78125
  127. Iter 19200, Minibatch Loss= 0.394480, Training Accuracy= 0.85938
  128. Iter 20480, Minibatch Loss= 0.356244, Training Accuracy= 0.91406
  129. Iter 21760, Minibatch Loss= 0.632163, Training Accuracy= 0.78125
  130. Iter 23040, Minibatch Loss= 0.269334, Training Accuracy= 0.90625
  131. Iter 24320, Minibatch Loss= 0.485007, Training Accuracy= 0.86719
  132. Iter 25600, Minibatch Loss= 0.569704, Training Accuracy= 0.78906
  133. Iter 26880, Minibatch Loss= 0.267697, Training Accuracy= 0.92188
  134. Iter 28160, Minibatch Loss= 0.381177, Training Accuracy= 0.90625
  135. Iter 29440, Minibatch Loss= 0.350800, Training Accuracy= 0.87500
  136. Iter 30720, Minibatch Loss= 0.356782, Training Accuracy= 0.90625
  137. Iter 32000, Minibatch Loss= 0.322511, Training Accuracy= 0.89062
  138. Iter 33280, Minibatch Loss= 0.309195, Training Accuracy= 0.90625
  139. Iter 34560, Minibatch Loss= 0.535408, Training Accuracy= 0.83594
  140. Iter 35840, Minibatch Loss= 0.281643, Training Accuracy= 0.92969
  141. Iter 37120, Minibatch Loss= 0.290962, Training Accuracy= 0.89844
  142. Iter 38400, Minibatch Loss= 0.204718, Training Accuracy= 0.93750
  143. Iter 39680, Minibatch Loss= 0.205882, Training Accuracy= 0.92969
  144. Iter 40960, Minibatch Loss= 0.481441, Training Accuracy= 0.84375
  145. Iter 42240, Minibatch Loss= 0.348245, Training Accuracy= 0.89844
  146. Iter 43520, Minibatch Loss= 0.274692, Training Accuracy= 0.90625
  147. Iter 44800, Minibatch Loss= 0.171815, Training Accuracy= 0.94531
  148. Iter 46080, Minibatch Loss= 0.171035, Training Accuracy= 0.93750
  149. Iter 47360, Minibatch Loss= 0.235800, Training Accuracy= 0.89844
  150. Iter 48640, Minibatch Loss= 0.235974, Training Accuracy= 0.93750
  151. Iter 49920, Minibatch Loss= 0.207323, Training Accuracy= 0.92188
  152. Iter 51200, Minibatch Loss= 0.212989, Training Accuracy= 0.91406
  153. Iter 52480, Minibatch Loss= 0.151774, Training Accuracy= 0.95312
  154. Iter 53760, Minibatch Loss= 0.090070, Training Accuracy= 0.96875
  155. Iter 55040, Minibatch Loss= 0.264714, Training Accuracy= 0.92969
  156. Iter 56320, Minibatch Loss= 0.235086, Training Accuracy= 0.92969
  157. Iter 57600, Minibatch Loss= 0.160302, Training Accuracy= 0.95312
  158. Iter 58880, Minibatch Loss= 0.106515, Training Accuracy= 0.96875
  159. Iter 60160, Minibatch Loss= 0.236039, Training Accuracy= 0.94531
  160. Iter 61440, Minibatch Loss= 0.279540, Training Accuracy= 0.90625
  161. Iter 62720, Minibatch Loss= 0.173585, Training Accuracy= 0.93750
  162. Iter 64000, Minibatch Loss= 0.191009, Training Accuracy= 0.92188
  163. Iter 65280, Minibatch Loss= 0.210331, Training Accuracy= 0.89844
  164. Iter 66560, Minibatch Loss= 0.223444, Training Accuracy= 0.94531
  165. Iter 67840, Minibatch Loss= 0.278210, Training Accuracy= 0.91406
  166. Iter 69120, Minibatch Loss= 0.174290, Training Accuracy= 0.95312
  167. Iter 70400, Minibatch Loss= 0.188701, Training Accuracy= 0.94531
  168. Iter 71680, Minibatch Loss= 0.210277, Training Accuracy= 0.94531
  169. Iter 72960, Minibatch Loss= 0.249951, Training Accuracy= 0.95312
  170. Iter 74240, Minibatch Loss= 0.209853, Training Accuracy= 0.92188
  171. Iter 75520, Minibatch Loss= 0.049742, Training Accuracy= 0.99219
  172. Iter 76800, Minibatch Loss= 0.250095, Training Accuracy= 0.92969
  173. Iter 78080, Minibatch Loss= 0.133853, Training Accuracy= 0.95312
  174. Iter 79360, Minibatch Loss= 0.110206, Training Accuracy= 0.97656
  175. Iter 80640, Minibatch Loss= 0.141906, Training Accuracy= 0.93750
  176. Iter 81920, Minibatch Loss= 0.126872, Training Accuracy= 0.94531
  177. Iter 83200, Minibatch Loss= 0.138925, Training Accuracy= 0.95312
  178. Iter 84480, Minibatch Loss= 0.128652, Training Accuracy= 0.96094
  179. Iter 85760, Minibatch Loss= 0.099837, Training Accuracy= 0.96094
  180. Iter 87040, Minibatch Loss= 0.119000, Training Accuracy= 0.95312
  181. Iter 88320, Minibatch Loss= 0.179807, Training Accuracy= 0.95312
  182. Iter 89600, Minibatch Loss= 0.141792, Training Accuracy= 0.96094
  183. Iter 90880, Minibatch Loss= 0.142424, Training Accuracy= 0.96094
  184. Iter 92160, Minibatch Loss= 0.159564, Training Accuracy= 0.96094
  185. Iter 93440, Minibatch Loss= 0.111984, Training Accuracy= 0.95312
  186. Iter 94720, Minibatch Loss= 0.238978, Training Accuracy= 0.92969
  187. Iter 96000, Minibatch Loss= 0.068002, Training Accuracy= 0.97656
  188. Iter 97280, Minibatch Loss= 0.191819, Training Accuracy= 0.94531
  189. Iter 98560, Minibatch Loss= 0.081197, Training Accuracy= 0.99219
  190. Iter 99840, Minibatch Loss= 0.206797, Training Accuracy= 0.95312
  191. Optimization Finished!
  192. Testing Accuracy: 0.941406
  193. '''

1.9 TensorFlow 基本的多 GPU 计算

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

本教程要求你的计算机有2个GPU

  • “/cpu:0”：你的机器的 CPU
  • “/gpu:0”：你的机器的第一个 GPU
  • “/gpu:1”：你的机器的第二个 GPU
  • 对于这个示例，我们使用两个 GTX-980
  1. import numpy as np
  2. import tensorflow as tf
  3. import datetime
  5. # 处理器的日志
  6. log_device_placement = True
  8. # 需要执行的乘法数量
  9. n = 10
  11. # 示例：在两个 GPU 上计算 A^n + B^n
  13. # 创建随机的大型矩阵
  14. A = np.random.rand(1e4, 1e4).astype('float32')
  15. B = np.random.rand(1e4, 1e4).astype('float32')
  17. # 创建图来储存结果
  18. c1 = []
  19. c2 = []
  21. # 定义矩阵的幂
  22. def matpow(M, n):
  23.     if n < 1: # n < 1 的抽象情况
  24.         return M
  25.     else:
  26.         return tf.matmul(M, matpow(M, n-1))
  28. # 单 GPU 计算
  30. with tf.device('/gpu:0'):
  31.     a = tf.constant(A)
  32.     b = tf.constant(B)
  33.     # 计算 A^n 和 B^n 并在 c1 中储存结果
  34.     c1.append(matpow(a, n))
  35.     c1.append(matpow(b, n))
  37. with tf.device('/cpu:0'):
  38.   sum = tf.add_n(c1) # c1 中所有元素的和，也就是 A^n + B^n
  40. t1_1 = datetime.datetime.now()
  41. with tf.Session(config=tf.ConfigProto(log_device_placement=log_device_placement)) as sess:
  42.     # 运行操作
  43.     sess.run(sum)
  44. t2_1 = datetime.datetime.now()
  46. # 多 GPU 计算
  47. # GPU:0 计算 A^n
  48. with tf.device('/gpu:0'):
  49.     # 计算 A^n 并在 c2 中储存结果
  50.     a = tf.constant(A)
  51.     c2.append(matpow(a, n))
  53. #GPU:1 计算 B^n
  54. with tf.device('/gpu:1'):
  55.     # 计算 B^n 并在 c2 中储存结果
  56.     b = tf.constant(B)
  57.     c2.append(matpow(b, n))
  59. with tf.device('/cpu:0'):
  60.   sum = tf.add_n(c2) # c2 中所有元素的和，也就是 A^n + B^n
  62. t1_2 = datetime.datetime.now()
  63. with tf.Session(config=tf.ConfigProto(log_device_placement=log_device_placement)) as sess:
  64.     # 运行操作
  65.     sess.run(sum)
  66. t2_2 = datetime.datetime.now()
  68. print "Single GPU computation time: " + str(t2_1-t1_1)
  69. print "Multi GPU computation time: " + str(t2_2-t1_2)
  71. '''
  72. Single GPU computation time: 0:00:11.833497
  73. Multi GPU computation time: 0:00:07.085913
  74. '''

1.10 TensorFlow 图的可视化

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. import tensorflow as tf
  2. import numpy
  4. # 导入 MINST 数据
  5. import input_data
  6. mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  8. '''
  9. Extracting /tmp/data/train-images-idx3-ubyte.gz
  10. Extracting /tmp/data/train-labels-idx1-ubyte.gz
  11. Extracting /tmp/data/t10k-images-idx3-ubyte.gz
  12. Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
  13. '''
  15. # 使用来自之前示例的 Logistic 回归
  17. # 参数
  18. learning_rate = 0.01
  19. training_epochs = 10
  20. batch_size = 100
  21. display_step = 1
  23. # TF 图输入
  24. x = tf.placeholder("float", [None, 784], name='x') # mnist 数据图像，形状为 28*28=784
  25. y = tf.placeholder("float", [None, 10], name='y') # 0-9 数字识别 => 10 个类
  27. # 创建模型
  29. # 设置模型权重
  30. W = tf.Variable(tf.zeros([784, 10]), name="weights")
  31. b = tf.Variable(tf.zeros([10]), name="bias")
  33. # 构造模型
  34. activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax
  36. # 最小化交叉熵误差
  37. cost = -tf.reduce_sum(y*tf.log(activation)) # 交叉熵
  38. optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) # 梯度下降
  40. # 初始化变量
  41. init = tf.initialize_all_variables()
  43. # 加载图
  44. with tf.Session() as sess:
  45.     sess.run(init)
  47.     # 将日志写入器设为文件夹 '/tmp/tensorflow_logs'
  48.     summary_writer = tf.train.SummaryWriter('/tmp/tensorflow_logs', graph_def=sess.graph_def)
  50.     # 训练循环
  51.     for epoch in range(training_epochs):
  52.         avg_cost = 0.
  53.         total_batch = int(mnist.train.num_examples/batch_size)
  54.         # 遍历所有批量
  55.         for i in range(total_batch):
  56.             batch_xs, batch_ys = mnist.train.next_batch(batch_size)
  57.             # 使用批量数据拟合训练
  58.             sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
  59.             # 计算平均损失
  60.             avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})/total_batch
  61.         #  展示每一步的日志
  62.         if epoch % display_step == 0:
  63.             print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost)
  65.     print "Optimization Finished!"
  67.     # 测试模型
  68.     correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1))
  69.     # 计算准确率
  70.     accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
  71.     print "Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})

运行命令行

  1. tensorboard --logdir=/tmp/tensorflow_logs

在你的浏览器中打开 http://localhost:6006/

  1. # 图的可视化
  2. # Tensorflow 使你很容易可视化所有计算图
  3. # 你可以点击图的任何部分，来获取更多细节

一、TensorFlow - 图2

  1. # 权重细节

一、TensorFlow - 图3

  1. # 梯度下降细节

一、TensorFlow - 图4

1.11 TensorFlow 损失可视化

致谢：派生于 Aymeric Damien 的 TensorFlow 示例

配置

参考配置指南。

  1. import tensorflow as tf
  2. import numpy
  4. # 导入 MINST 数据
  5. import input_data
  6. mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  8. '''
  9. Extracting /tmp/data/train-images-idx3-ubyte.gz
  10. Extracting /tmp/data/train-labels-idx1-ubyte.gz
  11. Extracting /tmp/data/t10k-images-idx3-ubyte.gz
  12. Extracting /tmp/data/t10k-labels-idx1-ubyte.gz
  13. '''
  15. # 使用来自之前示例的 Logistic 回归
  17. # 参数
  18. learning_rate = 0.01
  19. training_epochs = 10
  20. batch_size = 100
  21. display_step = 1
  23. # TF 图输入
  24. x = tf.placeholder("float", [None, 784], name='x') # mnist 数据图像，形状为 28*28=784
  25. y = tf.placeholder("float", [None, 10], name='y') # 0-9 数字识别 => 10 个类
  27. # 创建模型
  29. # 设置模型权重
  30. W = tf.Variable(tf.zeros([784, 10]), name="weights")
  31. b = tf.Variable(tf.zeros([10]), name="bias")
  33. # 构造模型
  34. activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax
  36. # 最小化交叉熵误差
  37. cost = -tf.reduce_sum(y*tf.log(activation)) # 交叉熵
  38. optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) # 梯度下降
  40. # 初始化变量
  41. init = tf.initialize_all_variables()
  43. # 创建汇总来监控损失函数
  44. tf.scalar_summary("loss", cost)
  46. # 将所有汇总合并为一个操作
  47. merged_summary_op = tf.merge_all_summaries()
  49. # 加载图
  50. with tf.Session() as sess:
  51.     sess.run(init)
  53.     # 将日志写入器设为文件夹 '/tmp/tensorflow_logs'
  54.     summary_writer = tf.train.SummaryWriter('/tmp/tensorflow_logs', graph_def=sess.graph_def)
  56.     # 训练循环
  57.     for epoch in range(training_epochs):
  58.         avg_cost = 0.
  59.         total_batch = int(mnist.train.num_examples/batch_size)
  60.         # 遍历所有批量
  61.         for i in range(total_batch):
  62.             batch_xs, batch_ys = mnist.train.next_batch(batch_size)
  63.             # 使用批量数据拟合训练
  64.             sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
  65.             # 计算平均损失
  66.             avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})/total_batch
  67.             # 在每个迭代中写日志
  68.             summary_str = sess.run(merged_summary_op, feed_dict={x: batch_xs, y: batch_ys})
  69.             summary_writer.add_summary(summary_str, epoch*total_batch + i)
  70.         #  展示每一步的日志
  71.         if epoch % display_step == 0:
  72.             print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost)
  74.     print "Optimization Finished!"
  76.     # 测试模型
  77.     correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1))
  78.     # 计算准确率
  79.     accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
  80.     print "Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})

运行命令行

  1. tensorboard --logdir=/tmp/tensorflow_logs

在你的浏览器中打开 http://localhost:6006/

  1. # 每个小批量步骤的损失

一、TensorFlow - 图5