TensorFlow是一个采用数据流图，用于数值计算的开源软件库。自己接触tensorflow比较的早，可是并没有系统深入的学习过，现在TF在深度学习已经成了“标配”，所以打算系统的学习一遍。在本篇文章中主要介绍TF的基础知识。。。

创建并运行图

首先创建 两个变量

import tensorflow as tf
reset_graph()
x = tf.Variable(3, name="x")
y = tf.Variable(4, name="y")
f = x*x*y + y + 2
>>f
<tf.Tensor 'add_3:0' shape=() dtype=int32>

然而，f中并没有得到想要的结果，实际上上面的代码并没有真正的运行，它只是创建了一个计算图(compution graph)，并且定义的变量也并没有被初始化，为了计算刚才定义的图，我们需要开启一个session，然后初始化上面的变量。

sess = tf.Session()
sess.run(x.initializer)
sess.run(y.initializer)
result = sess.run(f)
sess.close()  # 最终关闭这个session
>>print(result)
42

类似python的with open()语法，我们还可以这样写

with tf.Session() as sess:
    x.initializer.run() #sess.run(x.initializer)
    y.initializer.run()
    result = f.eval()  #sess.run(f)
    print(result)

注意上面代码注释的部分，这两钟方法是等价的，即

 x.initializer.run()  = tf.get_default_session().run(x.initializer)

选择哪一种写法主要取决于哪种方法简单。那么如果我们由很多的变量，都需要进行初始化，再逐一初始化就显得繁琐了，这时候我们可以使用global_variables_initializer()方法进行初始化。

init = tf.global_variables_initializer() # 准备init节点
with tf.Session() as sess:
    init.run()              #执行初始化动作
    print(f.eval)

从上面的代码可以看出，TF程序的运行过程分为两个阶段，

• 1.构建计算图，构建能够表示 机器学习模型的图。
• 2.运行部分，通常是一个循环，重复地对训练步骤进行评估，改善模型的参数。

管理计算图

当我们创建一个节点的时候， 被创建的节点自动的被添加到默认的计算图中：

>>x.graph is tf.get_default_graph() 
True

但是大多的时候，我们想分别管理相互独立的graphs，这时候就要创建新的graph

graph = tf.Graph()
with graph.as_default():
    x1 = tf.Variable(2)
    
print(x1.graph is graph) #True
print(x1.graph is tf.get_default_graph) #False

note:我们在使用Python shell试验阶段的时候，可能会出现输出和我们的预期不一样，这是因为多次运行导致默认的graph包含重复的nodes，一个解决方案是重启shell，另外一个是使用tf.reset_default_graph()。

节点的生命周期

节点的生命周期也成为变量的生命周期，因为在TF中每一个变量在graph中都对应一个node，当我们创建一个node，TF会自动判断该节点的依赖关系，例如下面这段代码：

w = tf.constant(3)
x = w + 2
y = x + 5
z = x * 3
with tf.Session() as sess:
    print(y.eval()) #10
    print(z.eval()) #15

上面这段代码定义了一个简单的graph，并计算y和z的值，TF发现y依赖x、x依赖w。所以它依次计算w、x和y。再计算z的时候，发现需要计算x和w。最终这段代码执行了两次w和x。当执行完毕后所有的节点都被删除，除了Variable值，variable的生命周期为整个session。也就是说variable的生命周期从initializer开始，到sessionclose结束。
上面这段代码在正式的生产环境下效率是很低的，为了避免被重复计算，我们就需要告诉TF计算y和z在同一个graph中。下面是代码：

with tf.Session() as sess: 
    y_val,z_val = sess.run([y,z]) ##
    print(y_val) 
    print(z_val) 

note:在单进程的TF程序中，多个session是不共用变量(数据)的，每一个session有着独自的变量copy。在分布式TF程序中，变量是存储在server，而不是在session中，所以多个session可以共享变量。

使用TF求解线性回归

1 正规方程求解

在之前的文章使用sklearn进行数据挖掘介绍了使用sklean进行数据挖掘，这里我们使用TF来进行计算，不过为了方便我们直接使用sklean提供的数据集，跳过数据处理过程，直接使用正规方程(Normal Equation)方法求解\(\theta=(X^T\cdot X)^{-1}\cdot X^T\cdot y\)。类似Numpy，TF也提供了许多数据转换的方法，在numpy数组被成为ndarray，详见掌握numpy，在TF中的多维数组被成为张量(tensors)。

import numpy as np
from sklearn.datasets import fetch_california_housing
housing = fetch_california_housing()
m,n = housing.data.shape
data = np.c_[np.ones((m,1)),housing.data] #添加X0=1
X = tf.constant(data,dtype=tf.float32,name='X')
y = tf.constant(housing.target.reshape(-1,1),dtype=tf.float32,name='y')#转为列向量(1D -> 2D)
X_T = tf.transpose(X)
theat = tf.matmul(tf.matmul(tf.matrix_inverse( tf.matmul(X_T,X)),X_T),y)    
with tf.Session() as sess:
    theat_hat = theat.eval()
    print(theat_hat)

上面这段代码可以完全使用Numpy替代，当然也可以使用sklearn的回归方法，也是分分钟搞定的事情，

from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(housing.data, housing.target.reshape(-1, 1))
print(np.vstack((lin_reg.intercept_.reshape(-1, 1), lin_reg.coef_.T)))

使用TF的优势是可以使用GPU进行运算。
note:reshape(-1,1)的作用是将一维数组转化为二维数组，参数-1表示unspecified,表示会根据数组的长度作为这一维度的值。

2 使用批梯度下降求解

上面使用的是正规方程求解，现在我们使用梯度下降方法求解，在求解之前我们需要现对数据做normalize，否则会导致收敛速度慢

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaled_data = scaler.fit_transform(housing.data)
data = np.c_[np.ones((m,1)),scaled_data] #添加X0=1

下面就是使用TF计算梯度下降了，最终的迭代公式为$ \theta^{‘}=\frac{2}{m}X^T\cdot (X\cdot \theta-y) $，这里就不再赘述。

n_epoch = 100
learning_rate = 0.1
X = tf.constant(data,dtype=tf.float32,name='X')
y = tf.constant(housing.target.reshape(-1,1),dtype=tf.float32,name='y')
theta = tf.Variable(tf.random_uniform([n+1,1],-1,1),name='theta')
y_pred = tf.matmul(X,theta,name='prediction')
error = y_pred - y
mse = tf.reduce_mean(tf.square(error),name='mse') #Mean Squared Error 
gradient = 2/m * tf.matmul(tf.transpose(X),error)
training_op = tf.assign(theta,theta - learning_rate * gradient)

init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    for epoch in range(n_epoch):
        if epoch % 100 == 0:
            print("Epoch", epoch, "MSE =", mse.eval())
        sess.run(training_op)
    >>print('best theta:',theta.eval())
Epoch 0 MSE = 9.16154
Epoch 100 MSE = 0.714501
Epoch 200 MSE = 0.566705
Epoch 300 MSE = 0.555572
Epoch 400 MSE = 0.548812
Epoch 500 MSE = 0.543636
Epoch 600 MSE = 0.539629
Epoch 700 MSE = 0.536509
Epoch 800 MSE = 0.534068
Epoch 900 MSE = 0.532147
'best theta:'
[[ 2.06855249],
 [ 0.88740271],
 [ 0.14401658],
 [-0.34770882],
 [ 0.36178368],
 [ 0.00393812],
 [-0.04269557],
 [-0.66145277],
 [-0.63752776]]

上面的代码比较简单,tf.random_uniform()生成一个均匀分布，大小为(n+1,1)，取值范围(-1,1)。至于为什么n+1，是因为考虑到\(x_0=1\)。tf.assign()是创建一个新的节点，为variable更新值

2.1使用TF自动求导

上面代码通过手动计算损失函数导数的迭代公式计算出\(\theta\)的值，一个线性回归手动算起来固然容易，但当模型为一个神经网络再进行手动求导就会很吃力了。TF提供了自动求导功能，只需要将上面那段代码的梯度部分替换成下面

gradient = tf.gradients(mse,[theta])[0]

上面的gradients()方法能够自动的将损失函数针对参数进行求导(本例分别为\(mse\)和 \(\theta\))，

2.2使用优化器

TF提供了计算梯度的方法，非常方便，不过还可以变得更加的方便。TF提供了许多优化方法，例如梯度下降优化器(Gradient Descent optimizer)。仅仅需要将gradient = 和training_op替换为以下代码：

optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
training_op = optimizer.minimize(mse)

有许多的优化方法，例如MomentumOptimizer等

3 向算法中输入数据和mini-batch求导

前面使用的是批梯度下降方法求解\(\theta\)，这种方法比较适用与较小的数据集，如果数据集很大最好使用mini-batch梯度下降方法。我们需要将上面的代码迭代部分的X和y替换为mini-batch，可以使用placeholder来实现mini-batch，顾名思义这是使用占位符的方法，它们并不参与运算，只有在你指定训练的时候才输出数据，举一个例子：

A = tf.placeholder(tf.float32,shape=(None,3))
B = A + 5
with tf.Session() as sess:
    test_b_1 = B.eval(feed_dict={A:[[1,2,3]]})
    test_b_2 = B.eval(feed_dict={A:[[4,5,6],[7,8,9]]})
print(test_b_1)  #[[ 6.  7.  8.]]
print(test_b_2) #[[  9.  10.  11.]  [ 12.  13.  14.]]

上面这段代码使用placeholder()创建一个占位符节点，并且指定其数值类型和输入形状，None表示任意长度。接着又创建一个节点为B=A+5。当计算B的值时候，使用feed_dict以字典的类型传入到eval（）中。
实现mini-batch我们只需要修改少量代码，首先我们需要先定义好参与迭代的X和y

X = tf.placeholder(tf.float32, shape=(None, n + 1), name="X")
y = tf.placeholder(tf.float32, shape=(None, 1), name="y")

然后定义需要迭代的次数、学习率、batch的大小以及batch的个数还有目标函数

learning_rate = 0.01
batch_size = 100
n_batches = int(np.ceil(m / batch_size))
theta = tf.Variable(tf.random_uniform([n + 1, 1], -1.0, 1.0, seed=42), name="theta") #X0
y_pred = tf.matmul(X, theta, name="predictions")
error = y_pred - y
mse = tf.reduce_mean(tf.square(error), name="mse")
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
training_op = optimizer.minimize(mse)
init = tf.global_variables_initializer()

最后就是计算过程，mini-batch逐个被送到训练算法中

def fetch_batch(epoch, batch_index, batch_size):
    np.random.seed(epoch * n_batches + batch_index) 
    indices = np.random.randint(m, size=batch_size)  
    X_batch = data[indices] 
    y_batch = housing.target.reshape(-1, 1)[indices] 
    return X_batch, y_batch

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(n_epochs):#迭代的次数
        for batch_index in range(n_batches):
            X_batch, y_batch = fetch_batch(epoch, batch_index, batch_size)
            sess.run(training_op, feed_dict={X: X_batch, y: y_batch})

    best_theta = theta.eval()

模型的持久化

类似sklearn，模型训练好之后我们可以将model持久化，以备以后的使用TF提供了Saver()方法，

init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as sess:
    sess.run(init)
    for epoch in range(n_epochs):
        if epoch % 100 == 0:
            print("Epoch", epoch, "MSE =", mse.eval())                                # 保存运行过程
            save_path = saver.save(sess, "/tmp/my_model.ckpt")
        sess.run(training_op)
    
    best_theta = theta.eval()
    save_path = saver.save(sess, "/tmp/my_model_final.ckpt")#保存最后的结果

模型的加载也是很简单的:

with tf.Session() as sess:
    saver.restore(sess, "/tmp/my_model_final.ckpt")
    best_theta_restored = theta.eval()