JAVA 深度学习-TensorFlow 完整的TensorFlow入门教程

1:你想要学习TensorFlow,首先你得安装Tensorflow,在你学习的时候你最好懂以下的知识:
    a:怎么用python编程
     b:了解一些关于数组的知识
     c:最理想的情况是:关于机器学习,懂一点点;或者不懂也是可以慢慢开始学习的。

2:TensorFlow提供很多API,最低级别是API:TensorFlow Core,提供给你完成程序控制,还有一些高级别的API,它们是构建在
TensorFlow Core之上的,这些高级别的API更加容易学习和使用,于此同时,这些高级别的API使得重复的训练任务更加容易,
也使得多个使用者操作对他保持一致性,一个高级别的API像tf.estimator帮助你管理数据集合,估量,训练和推理。

3:TensorsTensorFlow的数据中央控制单元是tensor(张量),一个tensor由一系列的原始值组成,这些值被形成一个任意维数的数组。
一个tensor的列就是它的维度。

4:
import tensorflow as tf
上面的是TensorFlow 程序典型的导入语句,作用是:赋予Python访问TensorFlow类(classes),方法(methods),符号(symbols)

5The Computational Graph TensorFlow核心程序由2个独立部分组成:
    a:Building the computational graph构建计算图
    b:Running the computational graph运行计算图
一个computational graph(计算图)是一系列的TensorFlow操作排列成一个节点图。
  1. node1 = tf.constant(3.0, dtype=tf.float32)
  2. node2 = tf.constant(4.0)# also tf.float32 implicitly
  3. print(node1, node2)
最后打印结果是:
Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0",shape=(), dtype=float32)
要想打印最终结果,我们必须用到session:一个session封装了TensorFlow运行时的控制和状态
  1. sess = tf.Session()
  2. print(sess.run([node1, node2]))
我们可以组合Tensor节点操作(操作仍然是一个节点)来构造更加复杂的计算,
  1. node3 = tf.add(node1, node2)
  2. print("node3:", node3)
  3. print("sess.run(node3):", sess.run(node3))
打印结果是:
  1. node3:Tensor("Add:0", shape=(), dtype=float32)
  2. sess.run(node3):7.0

6:TensorFlow提供一个统一的调用称之为TensorBoard,它能展示一个计算图的图片;如下面这个截图就展示了这个计算图
7:一个计算图可以参数化的接收外部的输入,作为一个placeholders(占位符),一个占位符是允许后面提供一个值的。
  1. a = tf.placeholder(tf.float32)
  2. b = tf.placeholder(tf.float32)
  3. adder_node = a + b # + provides a shortcut for tf.add(a, b)
这里有点像一个function (函数)或者lambda表达式,我们定义了2个输入参数a和b,然后提供一个在它们之上的操作。我们可以使用
feed_dict(传递字典)参数传递具体的值到run方法的占位符来进行多个输入,从而来计算这个图。
  1. print(sess.run(adder_node, {a:3, b:4.5}))
  2. print(sess.run(adder_node, {a: [1,3], b: [2,4]}))
结果是:
  1. 7.5
  2. [3. 7.]
在TensorBoard,计算图类似于这样:

8:我们可以增加另外的操作来让计算图更加复杂,比如
  1. add_and_triple = adder_node *3.
  2. print(sess.run(add_and_triple, {a:3, b:4.5}))
  3. 输出结果是:
  4. 22.5
在TensorBoard,计算图类似于这样:

9:在机器学习中,我们通常想让一个模型可以接收任意多个输入,比如大于1个,好让这个模型可以被训练,在不改变输入的情况下,
我们需要改变这个计算图去获得一个新的输出。变量允许我们增加可训练的参数到这个计算图中,它们被构造成有一个类型和初始值:
  1. W = tf.Variable([.3], dtype=tf.float32)
  2. b = tf.Variable([-.3], dtype=tf.float32)
  3. x = tf.placeholder(tf.float32)
  4. linear_model = W*x + b

10:当你调用tf.constant常量被初始化,它们的值是不可以改变的,而变量当你调用tf.Variable时没有被初始化,
在TensorFlow程序中要想初始化这些变量,你必须明确调用一个特定的操作,如下:
  1. init = tf.global_variables_initializer()
  2. sess.run(init)

11:要实现初始化所有全局变量的TensorFlow子图的的处理是很重要的,直到我们调用sess.run这些变量都是未被初始化的。
既然x是一个占位符,我们就可以同时地对多个x的值进行求值linear_model,例如:
  1. print(sess.run(linear_model, {x: [1,2,3,4]}))
  2. 求值linear_model
  3. 输出为
  4. [0. 0.30000001 0.60000002 0.90000004]

12:我们已经创建了一个模型,但是我们至今不知道它是多好,在这些训练数据上对这个模型进行评估,我们需要一个
y占位符来提供一个期望的值,并且我们需要写一个loss function(损失函数),一个损失函数度量当前的模型和提供
的数据有多远,我们将会使用一个标准的损失模式来线性回归,它的增量平方和就是当前模型与提供的数据之间的损失
linear_model - y创建一个向量,其中每个元素都是对应的示例错误增量。这个错误的方差我们称为tf.square。然后
,我们合计所有的错误方差用以创建一个标量,用tf.reduce_sum抽象出所有示例的错误。
  1. y = tf.placeholder(tf.float32)
  2. squared_deltas = tf.square(linear_model - y)
  3. loss = tf.reduce_sum(squared_deltas)
  4. print(sess.run(loss, {x: [1,2,3,4], y: [0, -1, -2, -3]}))
  5. 输出的结果为
  6. 23.66


13:我们分配一个值给W和b(得到一个完美的值是-1和1)来手动改进这一点,一个变量被初始化一个值会调用tf.Variable
但是可以用tf.assign来改变这个值,例如:fixW = tf.assign(W, [-1.])
  1. fixb = tf.assign(b, [1.])
  2. sess.run([fixW, fixb])
  3. print(sess.run(loss, {x: [1,2,3,4], y: [0, -1, -2, -3]}))
  4. 最终打印的结果是:
  5. 0.0

14tf.train APITessorFlow提供optimizers(优化器),它能慢慢改变每一个变量以最小化数,最简单的优化器是
gradient descent(梯度下降),它根据变量派生出损失的大小,来修改每个变量。通常手工计算变量符号是乏味且容易出错的,
因此,TensorFlow使用函数tf.gradients这个模型一个描述,从而能自动地提供衍生品,简而言之,优化器通常会为你做这个。例如:
  1. optimizer = tf.train.GradientDescentOptimizer(0.01)
  2. train = optimizer.minimize(loss)
  3. sess.run(init)# reset values to incorrect defaults.
  4. for iin range(1000):
  5. sess.run(train, {x: [1,2,3,4], y: [0, -1, -2, -3]})
  6. print(sess.run([W, b]))
  7. 输出结果为
  8. [array([-0.9999969], dtype=float32), array([ 0.99999082], dtype=float32)]

现在你已经完成了实际的机器学习,尽管这个简单的线性回归模型不要求太多TensorFlow core代码,更复杂的模型和
方法将数据输入到模型中,需要跟多的代码,因此TensorFlow为常见模式,结构和功能提供更高级别的抽象,我们将会
在下一个章节学习这些抽象。

15tf.estimatortf.setimator是一个更高级别的TensorFlow库,它简化了机械式的机器学习,包含以下几个方面:
  • running training loops 运行训练循环
  • running evaluation loops 运行求值循环
  • managing data sets 管理数据集合
tf.setimator定义了很多相同的模型。

16:A custom modeltf.setimator没有把你限制在预定好的模型中,假设我们想要创建一个自定义的模型,它不是由
TensorFlow建成的。我还是能保持这些数据集合,输送,训练高级别的抽象;例如:tf.estimator;

17:现在你有了关于TensorFlow的一个基本工作知识,我们还有更多教程,它能让你学习更多。如果你是一个机器学习初学者,
你可以继续学习MNIST for beginners否则你可以学习Deep MNIST for experts.

完整的代码:
  1. import tensorflow as tf
  2. node1 = tf.constant(3.0, dtype=tf.float32)
  3. node2 = tf.constant(4.0) # also tf.float32 implicitly
  4. print(node1, node2)
  5. sess = tf.Session()
  6. print(sess.run([node1, node2]))
  7. # from __future__ import print_function
  8. node3 = tf.add(node1, node2)
  9. print("node3:", node3)
  10. print("sess.run(node3):", sess.run(node3))
  11. # 占位符
  12. a = tf.placeholder(tf.float32)
  13. b = tf.placeholder(tf.float32)
  14. adder_node = a + b # + provides a shortcut for tf.add(a, b)
  15. print(sess.run(adder_node, {a: 3, b: 4.5}))
  16. print(sess.run(adder_node, {a: [1, 3], b: [2, 4]}))
  17. add_and_triple = adder_node * 3.
  18. print(sess.run(add_and_triple, {a: 3, b: 4.5}))
  19. # 多个变量求值
  20. W = tf.Variable([.3], dtype=tf.float32)
  21. b = tf.Variable([-.3], dtype=tf.float32)
  22. x = tf.placeholder(tf.float32)
  23. linear_model = W*x + b
  24. # 变量初始化
  25. init = tf.global_variables_initializer()
  26. sess.run(init)
  27. print(sess.run(linear_model, {x: [1, 2, 3, 4]}))
  28. # loss function
  29. y = tf.placeholder(tf.float32)
  30. squared_deltas = tf.square(linear_model - y)
  31. loss = tf.reduce_sum(squared_deltas)
  32. print("loss function", sess.run(loss, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]}))
  33. ss = (0-0)*(0-0) + (0.3+1)*(0.3+1) + (0.6+2)*(0.6+2) + (0.9+3)*(0.9+3) # 真实算法
  34. print("真实算法ss", ss)
  35. print(sess.run(loss, {x: [1, 2, 3, 4], y: [0, 0.3, 0.6, 0.9]})) # 测试参数
  36. # ft.assign 变量重新赋值
  37. fixW = tf.assign(W, [-1.])
  38. fixb = tf.assign(b, [1.])
  39. sess.run([fixW, fixb])
  40. print(sess.run(linear_model, {x: [1, 2, 3, 4]}))
  41. print(sess.run(loss, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]}))
  42. # tf.train API
  43. optimizer = tf.train.GradientDescentOptimizer(0.01) # 梯度下降优化器
  44. train = optimizer.minimize(loss) # 最小化损失函数
  45. sess.run(init) # reset values to incorrect defaults.
  46. for i in range(1000):
  47. sess.run(train, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]})
  48. print(sess.run([W, b]))
  49. print("------------------------------------1")
  50. # Complete program:The completed trainable linear regression model is shown here:完整的训练线性回归模型代码
  51. # Model parameters
  52. W = tf.Variable([.3], dtype=tf.float32)
  53. b = tf.Variable([-.3], dtype=tf.float32)
  54. # Model input and output
  55. x = tf.placeholder(tf.float32)
  56. linear_model = W*x + b
  57. y = tf.placeholder(tf.float32)
  58. # loss
  59. loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares
  60. # optimizer
  61. optimizer = tf.train.GradientDescentOptimizer(0.01)
  62. train = optimizer.minimize(loss)
  63. # training data
  64. x_train = [1, 2, 3, 4]
  65. y_train = [0, -1, -2, -3]
  66. # training loop
  67. init = tf.global_variables_initializer()
  68. sess = tf.Session()
  69. sess.run(init) # reset values to wrong
  70. for i in range(1000):
  71. sess.run(train, {x: x_train, y: y_train})
  72. # evaluate training accuracy
  73. curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})
  74. print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))
  75. print("------------------------------------2")
  76. # tf.estimator 使用tf.estimator实现上述训练
  77. # Notice how much simpler the linear regression program becomes with tf.estimator:
  78. # NumPy is often used to load, manipulate and preprocess data.
  79. import numpy as np
  80. import tensorflow as tf
  81. # Declare list of features. We only have one numeric feature. There are many
  82. # other types of columns that are more complicated and useful.
  83. feature_columns = [tf.feature_column.numeric_column("x", shape=[1])]
  84. # An estimator is the front end to invoke training (fitting) and evaluation
  85. # (inference). There are many predefined types like linear regression,
  86. # linear classification, and many neural network classifiers and regressors.
  87. # The following code provides an estimator that does linear regression.
  88. estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns)
  89. # TensorFlow provides many helper methods to read and set up data sets.
  90. # Here we use two data sets: one for training and one for evaluation
  91. # We have to tell the function how many batches
  92. # of data (num_epochs) we want and how big each batch should be.
  93. x_train = np.array([1., 2., 3., 4.])
  94. y_train = np.array([0., -1., -2., -3.])
  95. x_eval = np.array([2., 5., 8., 1.])
  96. y_eval = np.array([-1.01, -4.1, -7, 0.])
  97. input_fn = tf.estimator.inputs.numpy_input_fn(
  98. {"x": x_train}, y_train, batch_size=4, num_epochs=None, shuffle=True)
  99. train_input_fn = tf.estimator.inputs.numpy_input_fn(
  100. {"x": x_train}, y_train, batch_size=4, num_epochs=1000, shuffle=False)
  101. eval_input_fn = tf.estimator.inputs.numpy_input_fn(
  102. {"x": x_eval}, y_eval, batch_size=4, num_epochs=1000, shuffle=False)
  103. # We can invoke 1000 training steps by invoking the method and passing the
  104. # training data set.
  105. estimator.train(input_fn=input_fn, steps=1000)
  106. # Here we evaluate how well our model did.
  107. train_metrics = estimator.evaluate(input_fn=train_input_fn)
  108. eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
  109. print("train metrics: %r"% train_metrics)
  110. print("eval metrics: %r"% eval_metrics)
  111. print("------------------------------------3")
  112. # A custom model:客户自定义实现训练
  113. # Declare list of features, we only have one real-valued feature
  114. def model_fn(features, labels, mode):
  115. # Build a linear model and predict values
  116. W = tf.get_variable("W", [1], dtype=tf.float64)
  117. b = tf.get_variable("b", [1], dtype=tf.float64)
  118. y = W*features['x'] + b
  119. # Loss sub-graph
  120. loss = tf.reduce_sum(tf.square(y - labels))
  121. # Training sub-graph
  122. global_step = tf.train.get_global_step()
  123. optimizer = tf.train.GradientDescentOptimizer(0.01)
  124. train = tf.group(optimizer.minimize(loss),
  125. tf.assign_add(global_step, 1))
  126. # EstimatorSpec connects subgraphs we built to the
  127. # appropriate functionality.
  128. return tf.estimator.EstimatorSpec(
  129. mode=mode,
  130. predictions=y,
  131. loss=loss,
  132. train_op=train)
  133. estimator = tf.estimator.Estimator(model_fn=model_fn)
  134. # define our data sets
  135. x_train = np.array([1., 2., 3., 4.])
  136. y_train = np.array([0., -1., -2., -3.])
  137. x_eval = np.array([2., 5., 8., 1.])
  138. y_eval = np.array([-1.01, -4.1, -7., 0.])
  139. input_fn = tf.estimator.inputs.numpy_input_fn(
  140. {"x": x_train}, y_train, batch_size=4, num_epochs=None, shuffle=True)
  141. train_input_fn = tf.estimator.inputs.numpy_input_fn(
  142. {"x": x_train}, y_train, batch_size=4, num_epochs=1000, shuffle=False)
  143. eval_input_fn = tf.estimator.inputs.numpy_input_fn(
  144. {"x": x_eval}, y_eval, batch_size=4, num_epochs=1000, shuffle=False)
  145. # train
  146. estimator.train(input_fn=input_fn, steps=1000)
  147. # Here we evaluate how well our model did.
  148. train_metrics = estimator.evaluate(input_fn=train_input_fn)
  149. eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
  150. print("train metrics: %r"% train_metrics)
  151. print("eval metrics: %r"% eval_metrics)

展开阅读全文

没有更多推荐了,返回首页