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

1. TensorFlow核心理解

TensorFlow本质上是一张计算图，数据在图上计算和流动。

写TensorFlow程序，需要:

1. 构建一张计算图;
2. 运行会话，执行图中的运算。

2. TensorFlow的几个概念

1. 图（Graph）：用来表示计算任务，也就我们要做的一些操作。
2. 会话（Session）：建立会话，执行图中的计算，得到结果。如果把每个图看做一个车床，那会话就是一个车间，里面有若干个车床，用来把数据生产成结果。
3. 张量（Tensor）：用来表示数据，是我们的原料。
4. 变量（Variable）：用来记录一些数据和状态，是我们的容器。
5. feed和fetch：可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据。相当于一些铲子，可以操作数据。

形象的比喻是：把会话看做车间，图看做车床，里面用Tensor做原料，变量做容器，feed和fetch做铲子，把数据加工成我们的结果。(摘自五分钟带你入门TensorFlow) 

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

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

运行结果：

[1. 2. 3.]

4. 矩阵乘法示例

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

sess = tf.Session()          # 定义一个会话
result = sess.run(product)   # 运算乘法
print(result)    # 打印结果：[[16]]

5. 给Variable赋值

n = tf.Variable(0, name='count')  # 创建一个变量
m = tf.add(n, 10)                 # 创建一个加法操作，给n加10
op = tf.assign(n, m)              # 创建一个赋值操作，把m赋值给n
with tf.Session() as sess:        # 创建一个会话
    sess.run(tf.global_variables_initializer())   # 初始化变量
    print(sess.run(n))       # 打印最初的n值
    for i in range(4):
        sess.run(op)
        print(sess.run(n))

运行结果：

0
10
20
30
40

6. 通过feed_dict设置placeholder的值

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

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


# example 2
a = tf.placeholder(tf.float32, shape=[3])
b = tf.constant([5, 5, 5], tf.float32)
c = a + b
with tf.Session() as sess:
    print(sess.run(c, feed_dict={a: [1, 2, 3]}))   # 把[1, 2, 3]赋值给a
# 打印结果：[6. 7. 8.]

7. 搭建简单的神经网络

'''
用神经网络拟合一个二维线性函数
'''
import tensorflow as tf
import numpy as np

# create data
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data*0.1 + 0.3

### create tensorflow structure start ###
Weights = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
biases = tf.Variable(tf.zeros([1]))

y = Weights*x_data + biases

loss = tf.reduce_mean(tf.square(y-y_data))   # Computes the mean of elements across dimensions of a tensor.
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)   # 使用optimizer的minimize方法来更新参数
### create tensorflow structure end ###

sess = tf.Session()
init = tf.global_variables_initializer()   # 初始化所有之前定义的Variable
sess.run(init)

for step in range(201):
    sess.run(train)
    if step % 20 == 0:
        print(step, sess.run(Weights), sess.run(biases))

(程序来自莫烦TensorFlow教程)

运行结果：

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. 搭建简单的神经网络

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

batch_size = 10
w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))

# None可以根据batch大小确定维度，在shape的一个维度上使用None
x = tf.placeholder(tf.float32, shape=(None, 2))
y = tf.placeholder(tf.float32, shape=(None, 1))

# 激活函数使用ReLU
a = tf.nn.relu(tf.matmul(x, w1))
yhat = tf.nn.relu(tf.matmul(a, w2))

# 定义交叉熵为损失函数，训练过程使用Adam算法最小化交叉熵
cross_entropy = -tf.reduce_mean(y*tf.log(tf.clip_by_value(yhat, 1e-10, 1.0)))
train_step = tf.train.AdamOptimizer(0.001).minimize(cross_entropy)

rdm = RandomState(1)
data_size = 512

# 生成两个特征，共data_size个样本
X = rdm.rand(data_size, 2)

# 定义规则给出样本标签，所有x1+x2<1的样本认为是正样本，其他为负样本。Y，1为正样本
Y = [[int(x1+x2 < 1)] for (x1, x2) in X]

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # print(sess.run(w1))
    # print(sess.run(w2))
    steps = 11000
    for i in range(steps):

        # 选定每一个批量读取的首尾位置，确保在1个epoch内采样训练
        start = i * batch_size % data_size
        end = min(start + batch_size, data_size)
        sess.run(train_step, feed_dict={x:X[start:end], y:Y[start:end]})
        if i % 1000 == 0:
            training_loss = sess.run(cross_entropy, feed_dict={x:X, y:Y})
            print("在迭代 %d 次后，训练损失为 %g" % (i, training_loss))

上面的程序来自TensorFlow极简入门教程，该程序定义了一个简单的三层全连接网络（输入层、隐藏层和输出层分别为 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