TensorFlow入门教程系列(一)：基本概念及示例

1.核心理解

本质上是一个计算图，其中数据被计算和流动。

要编写程序，您需要：

构建计算图；运行会话以在图中执行操作。 2.的几个概念图（Graph）：用来表示计算任务，也就是我们要做的一些操作。 ()：建立会话，在图中进行计算，得到结果。如果您将每个图表视为一台车床，那么本次会议就是一个研讨会，其中有几台车床用于将数据生成结果。 ()：用来表示数据，是我们的原材料。变量()：用来记录一些数据和状态，是我们的容器。 feed 和 fetch：您可以为任何操作 ( ) 赋值或获取数据。相当于一些铁锹，可以操作数据。

图像的隐喻是：把对话想象成一个车间，把图形想象成车床，它作为原材料，变量作为容器，进料和取料作为铲子，数据处理成我们的结果. （节选自《五分钟让你开始》）

3. 创建一个常量并查看其内容

1 import tensorflow as tf
2 a = tf.constant([1, 2, 3], dtype=tf.float32)
3 with tf.Session() as sess:  # 为查看结果必须创建一个session
4     print(sess.run(a))

运行结果：

[1. 2. 3.]

4.矩阵乘法示例

 1 import tensorflow as tf
 2 m1 = tf.constant([[2, 3]])       # 创建一个常量m1
 3 m2 = tf.constant([[2], [4]])     # 创建一个常量m2
 4 product = tf.matmul(m1, m2)      # 创建一个矩阵乘法，要注意的是，创建了乘法后，不会立即执行，要在会话中才执行
 5 print(product)    # 这个时候打印，得到的不是乘法之后的结果，而是乘法本身
 6                   # 打印结果是：Tensor("MatMul_1:0", shape=(1, 1), dtype=int32)
 7 
 8 sess = tf.Session()          # 定义一个会话
 9 result = sess.run(product)   # 运算乘法
10 print(result)    # 打印结果：[[16]]

5.作业

1 n = tf.Variable(0, name='count')  # 创建一个变量
2 m = tf.add(n, 10)                 # 创建一个加法操作，给n加10
3 op = tf.assign(n, m)              # 创建一个赋值操作，把m赋值给n
4 with tf.Session() as sess:        # 创建一个会话

5     sess.run(tf.global_variables_initializer())   # 初始化变量
6     print(sess.run(n))       # 打印最初的n值
7     for i in range(4):
8         sess.run(op)
9         print(sess.run(n))

运行结果：

0
10
20
30
40

6.通过设置值

有时候，我们在声明变量的时候不赋值，在计算的时候赋值。实现“声明变量而不赋值”的方法是使用占位符，它只会分配必要的内存，没有初始值。在会话中，占位符可以使用提要数据。

 1 # example 1
 2 input1 = tf.placeholder(tf.float32)   # 创建一个变量占位符input1
 3 input2 = tf.placeholder(tf.float32)   # 创建一个变量占位符input2
 4 new_value = tf.add(input1, input2)    # 创建一个加法操作
 5 with tf.Session() as sess:            # 使用这种写法，在运行完毕后，会话将自动关闭
 6     print(sess.run(new_value, feed_dict={input1: 9, input2: 5}))   # 在运算时，用feed_dict设置两个输入的值
 7 # 打印结果：14.0
 8 
 9 
10 # example 2
11 a = tf.placeholder(tf.float32, shape=[3])
12 b = tf.constant([5, 5, 5], tf.float32)
13 c = a + b

14 with tf.Session() as sess:
15     print(sess.run(c, feed_dict={a: [1, 2, 3]}))   # 把[1, 2, 3]赋值给a
16 # 打印结果：[6. 7. 8.]

7.构建一个简单的神经网络

 1 '''
 2 用神经网络拟合一个二维线性函数
 3 '''
 4 import tensorflow as tf
 5 import numpy as np
 6 
 7 # create data
 8 x_data = np.random.rand(100).astype(np.float32)
 9 y_data = x_data*0.1 + 0.3
10 
11 ### create tensorflow structure start ###
12 Weights = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
13 biases = tf.Variable(tf.zeros([1]))
14 
15 y = Weights*x_data + biases
16 
17 loss = tf.reduce_mean(tf.square(y-y_data))   # Computes the mean of elements across dimensions of a tensor.
18 optimizer = tf.train.GradientDescentOptimizer(0.5)
19 train = optimizer.minimize(loss)   # 使用optimizer的minimize方法来更新参数
20 ### create tensorflow structure end ###
21 
22 sess = tf.Session()

23 init = tf.global_variables_initializer()   # 初始化所有之前定义的Variable
24 sess.run(init)
25 
26 for step in range(201):
27     sess.run(train)
28     if step % 20 == 0:
29         print(step, sess.run(Weights), sess.run(biases))

（程序来自莫凡教程）

运行结果：

0 [0.20165633] [0.34025076]
20 [0.11860122] [0.28987983]
40 [0.10562234] [0.29694113]
60 [0.1016994] [0.29907542]
80 [0.10051368] [0.29972056]
100 [0.10015527] [0.29991552]
120 [0.10004691] [0.2999745]
140 [0.10001419] [0.2999923]
160 [0.10000429] [0.2999977]
180 [0.1000013] [0.2999993]
200 [0.1000004] [0.2999998]

8.构建一个简单的神经网络

 1 '''
 2 搭建一个三层的全连接神经网络进行二分类
 3 '''
 4 import tensorflow as tf
 5 from numpy.random import RandomState

 6 
 7 batch_size = 10
 8 w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))
 9 w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))
10 
11 # None可以根据batch大小确定维度，在shape的一个维度上使用None
12 x = tf.placeholder(tf.float32, shape=(None, 2))
13 y = tf.placeholder(tf.float32, shape=(None, 1))
14 
15 # 激活函数使用ReLU
16 a = tf.nn.relu(tf.matmul(x, w1))
17 yhat = tf.nn.relu(tf.matmul(a, w2))
18 
19 # 定义交叉熵为损失函数，训练过程使用Adam算法最小化交叉熵
20 cross_entropy = -tf.reduce_mean(y*tf.log(tf.clip_by_value(yhat, 1e-10, 1.0)))
21 train_step = tf.train.AdamOptimizer(0.001).minimize(cross_entropy)
22 
23 rdm = RandomState(1)
24 data_size = 512
25 
26 # 生成两个特征，共data_size个样本
27 X = rdm.rand(data_size, 2)
28 
29 # 定义规则给出样本标签，所有x1+x2<1的样本认为是正样本，其他为负样本。Y，1为正样本
30 Y = [[int(x1+x2 < 1)] for (x1, x2) in X]
31 

32 with tf.Session() as sess:
33     sess.run(tf.global_variables_initializer())
34     # print(sess.run(w1))
35     # print(sess.run(w2))
36     steps = 11000
37     for i in range(steps):
38 
39         # 选定每一个批量读取的首尾位置，确保在1个epoch内采样训练
40         start = i * batch_size % data_size
41         end = min(start + batch_size, data_size)
42         sess.run(train_step, feed_dict={x:X[start:end], y:Y[start:end]})
43         if i % 1000 == 0:
44             training_loss = sess.run(cross_entropy, feed_dict={x:X, y:Y})
45             print("在迭代 %d 次后，训练损失为 %g" % (i, training_loss))

以上程序来自极简教程，定义了一个简单的三层全连接网络（输入、隐藏和输出层分别为2、3和2个神经元），隐藏层和激活函数输出层使用 ReLU 函数。该模型使用总数为 512 个样本和每次迭代 10 个读取的批次进行训练。这个简单的全连接网络使用交叉熵作为损失函数，并使用 Adam 优化算法进行权重更新。

运行结果：

在迭代 0 次后，训练损失为 0.309702
在迭代 1000 次后，训练损失为 0.0393322
在迭代 2000 次后，训练损失为 0.0173816
在迭代 3000 次后，训练损失为 0.0102881
在迭代 4000 次后，训练损失为 0.00676341
在迭代 5000 次后，训练损失为 0.00446996
在迭代 6000 次后，训练损失为 0.00297459
在迭代 7000 次后，训练损失为 0.0021837
在迭代 8000 次后，训练损失为 0.00179786
在迭代 9000 次后，训练损失为 0.00132818
在迭代 10000 次后，训练损失为 0.000957028