Tensor

tensor基本可以視作矩陣處理，如下面的程式碼就構造了一個1x2的0矩陣。

import tensorflow as tf # 在下面所有程式碼中，都去掉了這一行，預設已經匯入
a = tf.zeros(shape=[1,2])

Variable

Variable表示變數，下面的程式碼就用最簡單的方式構建了一個Variable。

      W = tf.Variable(tf.zeros(shape=[1,2]))

與Tensor不同，Variable必須初始化以後才能使用，

tensor = tf.zeros(shape=[1,2])
variable = tf.Variable(tensor)
sess = tf.InteractiveSession()

# print(sess.run(variable))  # 會報錯
 


sess.run(tf.initialize_all_variables()) # 對variable進行初始化
print(sess.run(variable))

placeholder

個人認為placeholder與Variable較為相似，區別在於placeholder常用來表示輸入及輸出，而Variable常用來表示中間變數。placeholder至少要求指定變數型別和shape。

x = tf.placeholder(tf.float32,[1, 28*28])
y = tf.placeholder(tf.float32,[None, 10])

上面x中[1,28*28]表示輸入的資料有1行，每行有28x28個值。
而y中出現了[None,10]

Session

上面構建的Tensor、Variable、placeholder都屬於抽象變數，需要通過Session控制模型執行(run)。

Session非常重要，我在學習之初一直沒有找到程式碼到底在哪裡對model進行呼叫並更新值，直到後來偶然間發現通過session.run(model.something)就可以更新該目標及所有該目標所涉及到的值。假設有以下程式碼：

class Model(object):
  def __init__(self, is_training, config, input_):
      self._input = input_

      batch_size = input_.batch_size
      num_steps = input_.num_steps
      size = config.hidden_size
      vocab_size = config.vocab_size

    # 一些相關設定
 


      output = tf.reshape(tf.concat(1, outputs), [-1, size])
      softmax_w = tf.get_variable(
          "softmax_w", [size, vocab_size], dtype=data_type())
      softmax_b = tf.get_variable("softmax_b", [vocab_size], dtype=data_type())
      logits = tf.matmul(output, softmax_w) + softmax_b
      loss = tf.nn.seq2seq.sequence_loss_by_example(
          [logits],
          [tf.reshape(input_.targets, [-1])],
          [tf.ones([batch_size * num_steps], dtype=data_type())])
      self._cost = cost = tf.reduce_sum(loss) / batch_size

上面的程式碼可以構建一個抽象模型，但是他自己是無法主動執行的。必須在外部通過session.run()對其進行呼叫：

        cost=session.run(model._cost, feed_dict={})

這個run要求更新_cost，而cost會涉及loss，loss又要用到logits等許多引數，所以model就會回溯更新所有用到的值，並且在最後將求得cost返回。

每一次run都會更新相當多的引數，那麼如果我想獲得多個引數數值應該怎麼辦？我在一開始就犯了在一個迴圈中用run獲得多個引數值的錯誤，這樣就會導致引數重複更新。正確的解決方法是：

        fetches = {
            "cost": model.cost,
            "final_state": model.final_state,
            "input_data":model._input_data,
            "targets":model._targets,
        }
        vals = session.run(fetches, feed_dict)

        cost = vals["cost"]
        state = vals["final_state"]

通過這種方式，就可以在一個run中獲取多個引數的值。

注意到有一個feed_dict變數，這個就是要提供給模型的input，留意一下稍後介紹。

mnist程式碼示例

本小節會涉及到一些softmax、交叉熵、梯度下降等知識，如有需要個人推薦憂達學城深度學習視訊結合書籍和網上資料的方式補充一下這些必要內容。

mnist中每個圖片均為28x28,共有A-J10個分類。

下面來演示如何用tf構造一個最簡單的LogisticRegression Classifier，基本公式為：

​ t=Wx+b

​ a=softmax(t)

• 構建抽象模型

  
  # 建立抽象模型
  
  x = tf.placeholder(tf.float32, [None, 784]) # 輸入佔位符
  y = tf.placeholder(tf.float32, [None, 10])  # 輸出佔位符（預期輸出）
  
  W = tf.Variable(tf.zeros([784, 10]))        
  b = tf.Variable(tf.zeros([10]))
  a = tf.nn.softmax(tf.matmul(x, W) + b)      # a表示模型的實際預測輸出
  
  
  # 定義損失函式和訓練方法
  
  cross_entropy = tf.reduce_mean(-tf.reduce_sum(y * tf.log(a), reduction_indices=[1])) # 損失函式為交叉熵
  optimizer = tf.train.GradientDescentOptimizer(0.5) # 梯度下降法，學習速率為0.5
  train = optimizer.minimize(cross_entropy)  # 訓練目標：最小化損失函式
  
  
  # 判斷a和y是否匹配，並計算accuracy
  
  correct_prediction = tf.equal(tf.argmax(a, 1), tf.argmax(y, 1))
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

  • x為輸入28*28特徵值，y為輸出的10種分類。
  • w和b要將輸入的28*28轉換為10種分類，利用softmax可以得到模型對某個圖片應該劃分哪個各類別的概率。
  • loss與交叉熵屬於套路，掌握即可。
  • 最後要判斷本次預測的精度，tf.argmax(a,1)可以找到各行a的最大值的index，將其與對應的y的index比較，得到一個Ture or False矩陣，代表本輪預測的正確與否，最後計算true的比例求得accuracy。

• 開始訓練

  from tensorflow.examples.tutorials.mnist import input_data
  
  flags = tf.app.flags
  FLAGS = flags.FLAGS
  flags.DEFINE_string('data_dir', r'C:\Users\hasee\Desktop\tempdata', 'Directory for storing data') # data_dir表示資料存放路徑
  
  mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)   # 讀取資料集
  
  session=tf.InteractiveSession()
  tf.initialize_all_variables().run()
  
  
  # fetches在session要run多個值時會用到
  
  fetches={
    'step':train_step,
    'intermediate_accuracy':accuracy
  }
  begin_time=time()
  for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(1000)    # 獲得一批100個數據
    train_step.run({x: batch_xs, y: batch_ys})   # 給訓練模型提供輸入和輸出
    # session.run(train_step, {x: batch_xs, y: batch_ys}) # 和上面這句是等效的
  
    # 如果想要把模型的中間結果輸出看看，使用方法一。
    # 方法一：fetches為想要檢視的值，已經在外部定義。此方法在我的機器上耗時7.5s
    # vals=session.run(fetches, {x: batch_xs, y: batch_ys}) # 和上面這句是等效的
    # intermediate_accuracy=vals['intermediate_accuracy']
  
    # 方法二：分別run各值。這種方法在我的機器上耗時35s，而且在很多情況下會導致model不能正常執行(我學習時遇到的大坑之一)。
    # session.run(train_step, {x: batch_xs, y: batch_ys}) # 和上面這句是等效的
    # ans=session.run(accuracy, feed_dict={x:mnist.test.images, y:mnist.test.labels})
  print(session.run(accuracy, feed_dict={x:mnist.test.images, y:mnist.test.labels}))
  print(time()-begin_time)
  

  在model外部只需要為model提供資料並通過session讓model運作起來就可以了，模型會在執行時按照預設的程式碼完成求導、計算loss等操作並更新內部數值。最後輸出accuracy，約為0.92.

• 完整程式碼：

  強烈建議和我一樣的初學者儘量透徹地理解這份程式碼的意義，然後將其裸寫一遍。之後無論是CNN還是LSTM都逃不開這種最基礎的建立模型、訓練模型的套路。

  
  # encoding:utf-8
  
  
  import tensorflow as tf
  
  
  # 建立模型
  
  x=tf.placeholder(tf.float32, [None, 28 * 28])
  y=tf.placeholder(tf.float32, [None, 10])
  
  w=tf.Variable(tf.zeros([28*28,10]))
  b=tf.Variable(tf.zeros([10]))
  a=tf.nn.softmax(tf.matmul(x, w) + b)
  
  cross_entropy=tf.reduce_mean(-tf.reduce_sum(y * tf.log(a), reduction_indices=[1]))
  optimizer=tf.train.GradientDescentOptimizer(0.5)
  train_step=optimizer.minimize(cross_entropy)
  
  correct_prediction=tf.equal(tf.argmax(a,1), tf.argmax(y, 1))
  accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
  
  
  # 輸入資料，呼叫模型
  
  
  from tensorflow.examples.tutorials.mnist import input_data
  from time import time
  
  flags = tf.app.flags
  FLAGS = flags.FLAGS
  flags.DEFINE_string('data_dir', r'C:\Users\hasee\Desktop\tempdata', 'Directory for storing data') # 把資料放在/tmp/data資料夾中
  
  mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)   # 讀取資料集
  
  session=tf.InteractiveSession()
  tf.initialize_all_variables().run()
  
  fetches={
      'step':train_step,
      'intermediate_accuracy':accuracy
  }
  begin_time=time()
  for i in range(1000):
      batch_xs, batch_ys = mnist.train.next_batch(1000)    # 獲得一批100個數據
      train_step.run({x: batch_xs, y: batch_ys})   # 給訓練模型提供輸入和輸出
      # session.run(train_step, {x: batch_xs, y: batch_ys}) # 和上面這句是等效的
  
      # 如果想要把模型的中間結果輸出看看，使用方法一。
      # 方法一：fetches為想要檢視的值，已經在外部定義。此方法在我的機器上耗時7.5s
      # vals=session.run(fetches, {x: batch_xs, y: batch_ys}) # 和上面這句是等效的
      # intermediate_accuracy=vals['intermediate_accuracy']
  
      # 方法二：分別run各值。這種方法在我的機器上耗時35s，而且在很多情況下會導致model不能正常執行(我學習時遇到的大坑之一)。
      # session.run(train_step, {x: batch_xs, y: batch_ys}) # 和上面這句是等效的
      # ans=session.run(accuracy, feed_dict={x:mnist.test.images, y:mnist.test.labels})
  print(session.run(accuracy, feed_dict={x:mnist.test.images, y:mnist.test.labels}))
  print(time()-begin_time)