Tensorflow
TensorFlow 是一个开源的、基于 Python 的机器学习框架，它由 Google 开发，提供了 Python，C/C++、Java、Go、R 等多种编程语言的接口，并在图形分类、音频处理、推荐系统和自然语言处理等场景下有着丰富的应用，是目前最热门的机器学习框架。
TensorFlow基础入门十大操作总结 - 图1

一、Tensorflow的排序与张量

Tensorflow允许用户把张量操作和功能定义为计算图。张量是通用的数学符号，代表保存数据值的多维列阵，张量的维数称为阶。
TensorFlow基础入门十大操作总结 - 图2
引用相关的库

  1. import tensorflow as tf
  2. import numpy as np

获取张量的阶（从下面例子看到tf的计算过程）

  1. # 获取张量的阶（从下面例子看到tf的计算过程）
  2. g = tf.Graph()
  3. # 定义一个计算图
  4. with g.as_default():
  5.     ## 定义张量t1,t2,t3
  6.     t1 = tf.constant(np.pi)
  7.     t2 = tf.constant([1,2,3,4])
  8.     t3 = tf.constant([[1,2],[3,4]])
  10.     ## 获取张量的阶
  11.     r1 = tf.rank(t1)
  12.     r2 = tf.rank(t2)
  13.     r3 = tf.rank(t3)
  15.     ## 获取他们的shapes
  16.     s1 = t1.get_shape()
  17.     s2 = t2.get_shape()
  18.     s3 = t3.get_shape()
  19.     print("shapes:",s1,s2,s3)
  20. # 启动前面定义的图来进行下一步操作
  21. with tf.Session(graph=g) as sess:
  22.     print("Ranks:",r1.eval(),r2.eval(),r3.eval())

TensorFlow基础入门十大操作总结 - 图3

二、Tensorflow 计算图

Tensorflow 的核心在于构建计算图，并用计算图推导从输入到输出的所有张量之间的关系。
假设有0阶张量a,b,c，要评估 ，可以表示为下图所示的计算图：
TensorFlow基础入门十大操作总结 - 图4
可以看到，计算图就是一个节点网络，每个节点就像是一个操作，将函数应用到输入张量，然后返回0个或者更多个张量作为张量作为输出。
在Tensorflow编制计算图步骤如下：

  1. 初始化一个空的计算图
  2. 为该计算图加入节点（张量和操作）
  3. 执行计算图：
    1. 开始一个新的会话
    2. 初始化图中的变量
    3. 运行会话中的计算图 ```python

      初始化一个空的计算图

      g = tf.Graph()

为该计算图加入节点（张量和操作）

with g.as_default(): a = tf.constant(1,name=”a”) b = tf.constant(2,name=”b”) c = tf.constant(3,name=”c”)

  1. z = 2*(a-b)+c

执行计算图

通过调用tf.Session产生会话对象，该调用可以接受一个图为参数（这里是g），否则将启动默认的空图

执行张量操作的用sess.run(),他将返回大小均匀的列表

with tf.Session(graph=g) as sess: print(‘2*(a-b)+c =>’,sess.run(z))

  1. 2*(a-b)+c => 1
  2. <a name="Btw0U"></a>
  3. ## **三、Tensorflow中的占位符**
  4. Tensorflow有提供数据的特别机制。其中一种机制就是使用占位符，他们是一些预先定义好类型和形状的张量。<br />通过调用`tf.placeholder`函数把这些张量加入计算图中，而且他们不包括任何数据。然而一旦执行图中的特定节点就需要提供数据阵列。
  5. <a name="NZuA3"></a>
  6. ### 3.1 定义占位符
  7. ```python
  8. g = tf.Graph()
  10. with g.as_default():
  11.     tf_a = tf.placeholder(tf.int32,shape=(),name="tf_a")  # shape=[]就是定义0阶张量,更高阶张量可以用【n1,n2,n3】表示，如shape=（3,4,5）
  12.     tf_b = tf.placeholder(tf.int32,shape=(),name="tf_b")
  13.     tf_c = tf.placeholder(tf.int32,shape=(),name="tf_c")
  15.     r1 = tf_a - tf_b
  16.     r2 = 2*r1
  17.     z = r2 + tf_c

3.2 为占位符提供数据

当在图中处理节点的时候，需要产生Python字典来为占位符来提供数据阵列。

  1. with tf.Session(graph=g) as sess:
  2.     feed = {
  3.         tf_a:1,
  4.         tf_b:2,
  5.         tf_c:3
  6.     }
  8.     print('z:',sess.run(z,feed_dict=feed))

z: 1

3.3 用batch_sizes为数据阵列定义占位符

在研发神经网络模型的时候，有时会碰到大小规模不一致的小批量数据。占位符的一个功能是把大小无法确定的维度定义为None。

  1. g = tf.Graph()
  3. with g.as_default():
  4.     tf_x = tf.placeholder(tf.float32,shape=(None,2),name="tf_x")
  5.     x_mean = tf.reduce_mean(tf_x,axis=0,name="mean")
  7. np.random.seed(123)
  8. with tf.Session(graph=g) as sess:
  9.     x1 = np.random.uniform(low=0,high=1,size=(5,2))
  10.     print("Feeding data with shape",x1.shape)
  11.     print("Result:",sess.run(x_mean,feed_dict={tf_x:x1}))
  13.     x2 = np.random.uniform(low=0,high=1,size=(10,2))
  14.     print("Feeding data with shape",x2.shape)
  15.     print("Result:",sess.run(x_mean,feed_dict={tf_x:x2}))

TensorFlow基础入门十大操作总结 - 图5

四、Tensorflow 的变量

就Tensorflow而言，变量是一种特殊类型的张量对象，他允许在训练模型阶段，在tensorflow会话中储存和更新模型的参数。

4.1 定义变量

  • 方式1：tf.Variable() 是为新变量创建对象并将其添加到计算图的类。
  • 方式2：tf.get_variable()是假设某个变量名在计算图中，可以复用给定变量名的现有值或者不存在则创建新的变量，因此变量名的name非常重要！

无论采用哪种变量定义方式，直到调用tf.Session启动计算图并且在会话中具体运行了初始化操作后才设置初始值。事实上，只有初始化Tensorflow的变量之后才会为计算图分配内存。

  1. g1 = tf.Graph()
  3. with g1.as_default():
  4.     w = tf.Variable(np.array([[1,2,3,4],[5,6,7,8]]),name="w")
  5.     print(w)

TensorFlow基础入门十大操作总结 - 图6

4.2 初始化变量

由于变量是直到调用tf.Session启动计算图并且在会话中具体运行了初始化操作后才设置初始值，只有初始化Tensorflow的变量之后才会为计算图分配内存。因此这个初始化的过程十分重要，这个初始化过程包括：为 相关张量分配内存空间并为其赋予初始值。
初始化方式：

  • 方式1：tf.global_variables_initializer函数，返回初始化所有计算图中现存的变量，要注意的是：定义变量一定要造初始化之前，不然会报错！！！
  • 方式2：将tf.global_variables_initializer函数储存在init_op（名字不唯一，自己定）对象内，然后用sess.run出来
    1. with tf.Session(graph=g1) as sess:
    2.   sess.run(tf.global_variables_initializer())
    3.   print(sess.run(w))
    TensorFlow基础入门十大操作总结 - 图7 ```python

    来比较定义变量与初始化顺序的关系

    g2 = tf.Graph()

with g2.as_default(): w1 = tf.Variable(1,name=”w1”) init_op = tf.global_variables_initializer() w2 = tf.Variable(2,name=”w2”)

with tf.Session(graph=g2) as sess: sess.run(init_op) print(“w1:”,sess.run(w1))

  1. w1: 1
  2. ```python
  3. with tf.Session(graph=g2) as sess:
  4.     sess.run(init_op)
  5.     print("w2:",sess.run(w2))

TensorFlow基础入门十大操作总结 - 图8

4.3 变量范围

变量范围是一个重要的概念，对建设大型神经网络计算图特别有用。
可以把变量的域划分为独立的子部分。在创建变量时，该域内创建的操作与张量的名字都以域名为前缀，而且这些域可以嵌套。

  1. g = tf.Graph()
  3. with g.as_default():
  4.     with tf.variable_scope("net_A"):   #定义一个域net_A
  5.         with tf.variable_scope("layer-1"): # 在域net_A下再定义一个域layer-1
  6.             w1 = tf.Variable(tf.random_normal(shape=(10,4)),name="weights")   # 该变量定义在net_A/layer-1域下
  7.         with tf.variable_scope("layer-2"):
  8.             w2 = tf.Variable(tf.random_normal(shape=(20,10)),name="weights")
  9.     with tf.variable_scope("net_B"):   # 定义一个域net_B
  10.         with tf.variable_scope("layer-2"):
  11.             w3 = tf.Variable(tf.random_normal(shape=(10,4)),name="weights")
  12.     print(w1)
  13.     print(w2)
  14.     print(w3)

TensorFlow基础入门十大操作总结 - 图9

五、建立回归模型

需要定义的变量：

  1. 输入x：占位符tf_x
  2. 输入y：占位符tf_y
  3. 模型参数w：定义为变量weight
  4. 模型参数b：定义为变量bias
  5. 模型输出 ̂ y^：有操作计算得到 ```python import tensorflow as tf import numpy as np import matplotlib.pyplot as plt %matplotlib inline

g = tf.Graph()

定义计算图

with g.as_default(): tf.set_random_seed(123)

  1. ## placeholder
  2. tf_x = tf.placeholder(shape=(None),dtype=tf.float32,name="tf_x")
  3. tf_y = tf.placeholder(shape=(None),dtype=tf.float32,name="tf_y")
  5. ## define the variable (model parameters)
  6. weight = tf.Variable(tf.random_normal(shape=(1,1),stddev=0.25),name="weight")
  7. bias = tf.Variable(0.0,name="bias")
  9. ## build the model
  10. y_hat = tf.add(weight*tf_x,bias,name="y_hat")
  12. ## compute the cost
  13. cost = tf.reduce_mean(tf.square(tf_y-y_hat),name="cost")
  15. ## train the model
  16. optim = tf.train.GradientDescentOptimizer(learning_rate=0.001)
  17. train_op = optim.minimize(cost,name="train_op")
  1. ```python
  2. # 创建会话启动计算图并训练模型
  3. ## create a random toy dataset for regression
  4. np.random.seed(0)
  5. def make_random_data():
  6.     x = np.random.uniform(low=-2,high=4,size=100)
  7.     y = []
  8.     for t in x:
  9.         r = np.random.normal(loc=0.0,scale=(0.5 + t*t/3),size=None)
  10.         y.append(r)
  11.     return x,1.726*x-0.84+np.array(y)
  13. x,y = make_random_data()
  15. plt.plot(x,y,'o')
  16. plt.show()

TensorFlow基础入门十大操作总结 - 图10

  1. ## train/test splits
  2. x_train,y_train = x[:100],y[:100]
  3. x_test,y_test = x[100:],y[100:]
  5. n_epochs = 500
  6. train_costs  = []
  7. with tf.Session(graph=g) as sess:
  8.     sess.run(tf.global_variables_initializer())
  10.     ## train the model for n_epochs
  11.     for e in range(n_epochs):
  12.         c,_ = sess.run([cost,train_op],feed_dict={tf_x:x_train,tf_y:y_train})
  13.         train_costs.append(c)
  14.         if not e % 50:
  15.             print("Epoch %4d: %.4f"%(e,c))
  16. plt.plot(train_costs)
  17. plt.show()

TensorFlow基础入门十大操作总结 - 图11

六、在Tensorflow计算图中用张量名执行对象

只需要把

  1. sess.run([cost,train_op],feed_dict={tf_x:x_train,tf_y:y_train})

改为

  1. sess.run(['cost:0','train_op:0'],feed_dict={'tf_x:0':x_train,'tf_y:0':y_train})

注意：只有张量名才有：0后缀，操作是没有：0后缀的，例如train_op并没有train_op：0

  1. ## train/test splits
  2. x_train,y_train = x[:100],y[:100]
  3. x_test,y_test = x[100:],y[100:]
  5. n_epochs = 500
  6. train_costs  = []
  7. with tf.Session(graph=g) as sess:
  8.     sess.run(tf.global_variables_initializer())
  10.     ## train the model for n_epochs
  11.     for e in range(n_epochs):
  12.         c,_ = sess.run(['cost:0','train_op'],feed_dict={'tf_x:0':x_train,'tf_y:0':y_train})
  13.         train_costs.append(c)
  14.         if not e % 50:
  15.             print("Epoch %4d: %.4f"%(e,c))

TensorFlow基础入门十大操作总结 - 图12

七、在Tensorflow中储存和恢复模型

神经网络训练可能需要几天几周的时间，因此需要把训练出来的模型储存下来供下次使用。
储存的方法是在定义计算图的时候加入：saver = tf.train.Saver()，并且在训练后输入saver.save(sess,'./trained-model')

  1. g = tf.Graph()
  3. # 定义计算图
  4. with g.as_default():
  5.     tf.set_random_seed(123)
  7.     ## placeholder
  8.     tf_x = tf.placeholder(shape=(None),dtype=tf.float32,name="tf_x")
  9.     tf_y = tf.placeholder(shape=(None),dtype=tf.float32,name="tf_y")
  11.     ## define the variable (model parameters)
  12.     weight = tf.Variable(tf.random_normal(shape=(1,1),stddev=0.25),name="weight")
  13.     bias = tf.Variable(0.0,name="bias")
  15.     ## build the model
  16.     y_hat = tf.add(weight*tf_x,bias,name="y_hat")
  18.     ## compute the cost
  19.     cost = tf.reduce_mean(tf.square(tf_y-y_hat),name="cost")
  21.     ## train the model
  22.     optim = tf.train.GradientDescentOptimizer(learning_rate=0.001)
  23.     train_op = optim.minimize(cost,name="train_op")
  24.     saver = tf.train.Saver()
  25. # 创建会话启动计算图并训练模型
  26. ## create a random toy dataset for regression
  27. np.random.seed(0)
  28. def make_random_data():
  29.     x = np.random.uniform(low=-2,high=4,size=100)
  30.     y = []
  31.     for t in x:
  32.         r = np.random.normal(loc=0.0,scale=(0.5 + t*t/3),size=None)
  33.         y.append(r)
  34.     return x,1.726*x-0.84+np.array(y)
  36. x,y = make_random_data()
  38. plt.plot(x,y,'o')
  39. plt.show()
  41. ## train/test splits
  42. x_train,y_train = x[:100],y[:100]
  43. x_test,y_test = x[100:],y[100:]
  45. n_epochs = 500
  46. train_costs  = []
  47. with tf.Session(graph=g) as sess:
  48.     sess.run(tf.global_variables_initializer())
  50.     ## train the model for n_epochs
  51.     for e in range(n_epochs):
  52.         c,_ = sess.run(['cost:0','train_op'],feed_dict={'tf_x:0':x_train,'tf_y:0':y_train})
  53.         train_costs.append(c)
  54.         if not e % 50:
  55.             print("Epoch %4d: %.4f"%(e,c))
  56.     saver.save(sess,'C:/Users/Leo/Desktop/trained-model/')

TensorFlow基础入门十大操作总结 - 图13
TensorFlow基础入门十大操作总结 - 图14

  1. # 加载保存的模型g2 = tf.Graph()
  2. with tf.Session(graph=g2) as sess:
  3.     new_saver = tf.train.import_meta_graph("C:/Users/Leo/Desktop/trained-model/.meta")
  4.     new_saver.restore(sess,'C:/Users/Leo/Desktop/trained-model/')
  5.     y_pred = sess.run('y_hat:0',feed_dict={'tf_x:0':x_test})

TensorFlow基础入门十大操作总结 - 图15

  1. ## 可视化模型
  2. x_arr = np.arange(-2,4,0.1)
  3. g2 = tf.Graph()
  4. with tf.Session(graph=g2) as sess:
  5.     new_saver = tf.train.import_meta_graph("C:/Users/Leo/Desktop/trained-model/.meta")
  6.     new_saver.restore(sess,'C:/Users/Leo/Desktop/trained-model/')
  7.     y_arr = sess.run('y_hat:0',feed_dict={'tf_x:0':x_arr})
  8.     plt.figure()
  9.     plt.plot(x_train,y_train,'bo')
  10.     plt.plot(x_test,y_test,'bo',alpha=0.3)
  11.     plt.plot(x_arr,y_arr.T[:,0],'-r',lw=3)
  12.     plt.show()

TensorFlow基础入门十大操作总结 - 图16

八、把张量转换成多维数据阵列

8.1 获得张量的形状

在numpy中可以用arr.shape来获得Numpy阵列的形状，而在Tensorflow中则用tf.get_shape函数完成：
注意：在tf.get_shape函数的结果是不可以索引的，需要用as.list()换成列表才能索引。

  1. g = tf.Graph()
  3. with g.as_default():
  4.     arr = np.array([[1.,2.,3.,3.5],[4.,5.,6.,6.5],[7.,8.,9.,9.5]])
  5.     T1 = tf.constant(arr,name="T1")
  6.     print(T1)
  7.     s = T1.get_shape()
  8.     print("Shape of T1 is ",s)
  9.     T2 = tf.Variable(tf.random_normal(shape=s))
  10.     print(T2)
  11.     T3 = tf.Variable(tf.random_normal(shape=(s.as_list()[0],)))
  12.     print(T3)

TensorFlow基础入门十大操作总结 - 图17

8.2 改变张量的形状

现在来看看Tensorflow如何改变张量的形状，在Numpy可以用np.reshape或arr.reshape，在一维的时候可以用-1来自动计算最后的维度。在Tensorflow内调用tf.reshape

  1. with g.as_default():
  2.     T4 = tf.reshape(T1,shape=[1,1,-1],name="T4")
  3.     print(T4)
  4.     T5 = tf.reshape(T1,shape=[1,3,-1],name="T5")
  5.     print(T5)

TensorFlow基础入门十大操作总结 - 图18

  1. with tf.Session(graph=g) as sess:
  2.     print(sess.run(T4))
  3.     print()
  4.     print(sess.run(T5))

TensorFlow基础入门十大操作总结 - 图19

8.3 将张量分裂为张量列表

  1. with g.as_default():
  2.     tf_splt = tf.split(T5,num_or_size_splits=2,axis=2,name="T8")
  3.     print(tf_splt)

TensorFlow基础入门十大操作总结 - 图20

8.4 张量的拼接

  1. g = tf.Graph()
  3. with g.as_default():
  4.     t1 = tf.ones(shape=(5,1),dtype=tf.float32,name="t1")
  5.     t2 = tf.zeros(shape=(5,1),dtype=tf.float32,name="t2")
  6.     print(t1)
  7.     print(t2)

TensorFlow基础入门十大操作总结 - 图21

  1. with g.as_default():
  2.     t3 = tf.concat([t1,t2],axis=0,name="t3")
  3.     print(t3)
  4.     t4 = tf.concat([t1,t2],axis=1,name="t4")
  5.     print(t4)

TensorFlow基础入门十大操作总结 - 图22

  1. with tf.Session(graph=g) as sess:
  2.     print(t3.eval())
  3.     print()
  4.     print(t4.eval())

TensorFlow基础入门十大操作总结 - 图23

  1. with tf.Session(graph=g) as sess:    print(sess.run(t3))
  2.     print()
  3.     print(sess.run(t4))

TensorFlow基础入门十大操作总结 - 图24

九、利用控制流构图

这里主要讨论在Tensorflow执行像Python一样的if语句，循环while语句，if…else..语句等。

9.1 条件语句

tf.cond()语句来试试：
TensorFlow基础入门十大操作总结 - 图25

  1. x,y = 1.0,2.0
  3. g = tf.Graph()
  5. with g.as_default():
  6.     tf_x = tf.placeholder(dtype=tf.float32,shape=None,name="tf_x")
  7.     tf_y = tf.placeholder(dtype=tf.float32,shape=None,name="tf_y")
  8.     res = tf.cond(tf_x<tf_y,lambda: tf.add(tf_x,tf_y,name="result_add"),lambda: tf.subtract(tf_x,tf_y,name="result_sub"))
  9.     print("Object:",res)  #对象被命名为"cond/Merge:0"
  11. with tf.Session(graph=g) as sess:
  12.     print("x<y: %s -> Result:"%(x<y),res.eval(feed_dict={"tf_x:0":x,"tf_y:0":y}))
  13.     x,y = 2.0,1.0
  14.     print("x<y: %s -> Result:"%(x<y),res.eval(feed_dict={"tf_x:0":x,"tf_y:0":y}))

TensorFlow基础入门十大操作总结 - 图26

9.2 执行Python的if…else语句

tf.case()

  1. f1 = lambda: tf.constant(1)
  2. f2 = lambda: tf.constant(0)
  3. result = tf.case([(tf.less(x,y),f1)],default=f2)
  4. print(result)

TensorFlow基础入门十大操作总结 - 图27

9.3 执行Python的while语句

  1. i = tf.constant(0)
  2. threshold = 100
  3. c = lambda i: tf.less(i,100)
  4. b = lambda i: tf.add(i,1)
  5. r = tf.while_loop(cond=c,body=b,loop_vars=[i])
  6. print(r)

TensorFlow基础入门十大操作总结 - 图28

十、用TensorBoard可视化图

TensorBoard是Tensorflow一个非常好的工具，它负责可视化和模型学习。可视化允许看到节点之间的连接，探索它们之间的依赖关系，并且在需要的时候进行模型调试。

  2. def build_classifier(data, labels, n_classes=2):
  3.     data_shape = data.get_shape().as_list()
  4.     weights = tf.get_variable(name='weights',
  5.                               shape=(data_shape[1], n_classes),
  6.                               dtype=tf.float32)
  7.     bias = tf.get_variable(name='bias',
  8.                            initializer=tf.zeros(shape=n_classes))
  9.     print(weights)
  10.     print(bias)
  11.     logits = tf.add(tf.matmul(data, weights),
  12.                     bias,
  13.                     name='logits')
  14.     print(logits)
  15.     return logits, tf.nn.softmax(logits)
  17. def build_generator(data, n_hidden):
  18.     data_shape = data.get_shape().as_list()
  19.     w1 = tf.Variable(
  20.         tf.random_normal(shape=(data_shape[1],
  21.                                 n_hidden)),
  22.         name='w1')
  23.     b1 = tf.Variable(tf.zeros(shape=n_hidden),
  24.                      name='b1')
  25.     hidden = tf.add(tf.matmul(data, w1), b1,
  26.                     name='hidden_pre-activation')
  27.     hidden = tf.nn.relu(hidden, 'hidden_activation')
  29.     w2 = tf.Variable(
  30.         tf.random_normal(shape=(n_hidden,
  31.                                 data_shape[1])),
  32.         name='w2')
  33.     b2 = tf.Variable(tf.zeros(shape=data_shape[1]),
  34.                      name='b2')
  35.     output = tf.add(tf.matmul(hidden, w2), b2,
  36.                     name = 'output')
  37.     return output, tf.nn.sigmoid(output)
  39. batch_size=64
  40. g = tf.Graph()
  42. with g.as_default():
  43.     tf_X = tf.placeholder(shape=(batch_size, 100),
  44.                           dtype=tf.float32,
  45.                           name='tf_X')
  46.     ## build the generator
  47.     with tf.variable_scope('generator'):
  48.         gen_out1 = build_generator(data=tf_X,
  49.                                    n_hidden=50)
  51.     ## build the classifier
  52.     with tf.variable_scope('classifier') as scope:
  53.         ## classifier for the original data:
  54.         cls_out1 = build_classifier(data=tf_X,
  55.                                     labels=tf.ones(
  56.                                         shape=batch_size))
  58.         ## reuse the classifier for generated data
  59.         scope.reuse_variables()
  60.         cls_out2 = build_classifier(data=gen_out1[1],
  61.                                     labels=tf.zeros(
  62.                                         shape=batch_size))
  64.         init_op = tf.global_variables_initializer()

TensorFlow基础入门十大操作总结 - 图29

  1. with tf.Session(graph=g) as sess:
  2.     sess.run(tf.global_variables_initializer())
  3.     file_writer = tf.summary.FileWriter(logdir="C:/Users/Leo/Desktop/trained-model/logs/",graph=g)

在win+R输入cmd后输入命令：

  1. tensorboard --logdir="C:/Users/Leo/Desktop/trained-model/logs"

TensorFlow基础入门十大操作总结 - 图30
接着复制这个链接到浏览器打开：
TensorFlow基础入门十大操作总结 - 图31