從前面的學習筆記中，筆者和大家一起使用了 numpy 一步一步從感知機開始到兩層網絡以及最后實現了深度神經網絡的算法搭建。而后我們又討論了改善深度神經網絡的基本方法，包括神經網絡的正則化、參數優化和調參等問題。這一切工作我們都是基于numpy 完成的，沒有調用任何深度學習框架。在學習深度學習的時候，一開始不讓大家直接上手框架可謂良苦用心，旨在讓大家能夠跟筆者一樣，一步一步通過 numpy 搭建神經網絡的過程就是要讓你能夠更加深入的理解神經網絡的架構、基本原理和工作機制，而不是黑箱以視之。

但學習到這個階段，你已充分理解了神經網絡的工作機制，馬上就要接觸更深層次的卷積神經網絡（CNN）和遞歸神經網絡（RNN)，依靠純手工去搭建這些復雜的神經網絡恐怕并不現實。這時候就該深度學習框架出場了。針對深度學習，目前有很多優秀的學習框架，比如說筆者馬上要講的 Tensorflow，微軟的 CNTK，伯克利視覺中心開發的 caffe，以及別具一格的 PyTorch 和友好易用的 keras，本系列深度學習筆記打算從 Tensorflow 開始，對三大主流易用的深度學習框架 Tensorflow、PyTorch 和 keras 進行學習和講解。選擇這三個框架的原因在于其簡單易用、方便編程和運行速度相對較快。

作為谷歌的深度學習框架， Tensorflow 在深度學習領域可謂風頭無二。其中 Tensor 可以理解為類似于 numpy 的 N 維數組，名為張量； flow 則意味著 N 維數組的流計算，而 Tensor 的數據流計算形式則為一個計算圖的形式進行計算。這里重點提一下，如果大學本科期間的線性代數忘記了的話，我勸你趕緊回去翻一翻，線性代數和矩陣論是深度學習的基礎，希望你能熟練掌握。

先看個簡單的例子。

importtensorflowastf#Definey_hatconstant.Setto36.y_hat=tf.constant(36,name='y_hat')
#Definey.Setto39y=tf.constant(39,name='y')#Createavariableforthelossloss=tf.Variable((y-y_hat)**2,name='loss')#Wheninitisrunlater(session.run(init)),thelossvariablewillbeinitializedandreadytobecomputedinit=tf.global_variables_initializer()#Createasessionandprinttheoutputwithtf.Session()assession:
#Initializesthevariables
session.run(init)
#Printstheloss
print(session.run(loss))

9

在上述代碼中，我們首先定義了兩個常量，然后定義了一個 loss Tensor（變量），之后對變量進行初始化，創建計算會話，最后執行會話計算并打印結果。所以我們可以看到運行 Tensorflow 的基本機制：
創建一些尚未被執行的張量——定義這些張量之間的運算操作——初始化這些張量——創建會話——執行會話

需要注意的一點是，創建會話后一定要執行這個會話，且看下面示例：

a=tf.constant(2)
b=tf.constant(10)
c=tf.multiply(a,b)
print(c)

Tensor("Mul:0",shape=(),dtype=int32)

在上面的示例中，我們創建了兩個 Tensor 和 Tensor 之間的乘積運算，但直接打印的結果卻不是我們想要看到的 20. 原因則在于這里我們沒有創建會話并執行，只是打印了兩個張量運算之后的張量。創建會話并執行操作如下：

sess=tf.Session()
print(sess.run(c))

20

除了直接定義變量之外，我們還可以通過創建占位符變量來稍后為之賦值，然后在運行會話中傳入一個 feed_dict ，示例如下：

x=tf.placeholder(tf.int64,name='x')
print(sess.run(2*x,feed_dict={x:3}))
sess.close()

6

相信你已經大致明白了基于張量運算的 Tensorflow 的底層運行機制了。總結而言就是：創建張量、初始化張量、創建會話并執行。

下面展示幾個 Tensorflow 的神經網絡計算的基礎函數示例。

線性函數

def linear_function():  
  """
  Implements a linear function: 
      Initializes W to be a random tensor of shape (4,3)
      Initializes X to be a random tensor of shape (3,1)
      Initializes b to be a random tensor of shape (4,1)
  Returns: 
  result -- runs the session for Y = WX + b 
  """

  np.random.seed(1)


  X = tf.constant(np.random.randn(3,1), name='X')
  W = tf.constant(np.random.randn(4,3), name='W')
  b = tf.constant(np.random.randn(4,1), name='b')
  Y = tf.add(tf.matmul(W, X), b)  # Create the session using tf.Session() and run it with sess.run(...) on the variable you want to calculate

  init = tf.global_variables_initializer() 
  sess = tf.Session()
  sess.run(init)
  result = sess.run(Y)  # close the session 
  sess.close()  
  return result

計算sigmoid函數

def sigmoid(z):  
  """
  Computes the sigmoid of z

  Arguments:
  z -- input value, scalar or vector

  Returns: 
  results -- the sigmoid of z
  """

  x = tf.placeholder(tf.float32, name='x')
  sigmoid = tf.sigmoid(x)  
  with tf.Session() as sess:
    result = sess.run(sigmoid, feed_dict={x: z})  
  return result

計算損失函數

def cost(logits, labels):  
  """
  Computes the cost using the sigmoid cross entropy

  Arguments:
  logits -- vector containing z, output of the last linear unit (before the final sigmoid activation)
  labels -- vector of labels y (1 or 0) 

  Note: What we've been calling "z" and "y" in this class are respectively called "logits" and "labels" 
  in the TensorFlow documentation. So logits will feed into z, and labels into y. 

  Returns:
  cost -- runs the session of the cost (formula (2))
  """

  # Create the placeholders for "logits" (z) and "labels" (y) (approx. 2 lines)
  z = tf.placeholder(tf.float32, name='z')
  y = tf.placeholder(tf.float32, name='y')  # Use the loss function (approx. 1 line)
  cost = tf.nn.sigmoid_cross_entropy_with_logits(logits=z, labels=y)  # Create a session (approx. 1 line). See method 1 above.
  sess = tf.Session()  # Run the session (approx. 1 line).
  sess.run(cost, feed_dict={z: logits, y: labels})  # Close the session (approx. 1 line). See method 1 above.
  sess.close()  
  return cost

one hot 編碼

def one_hot_matrix(labels, C):  
  """
  Creates a matrix where the i-th row corresponds to the ith class number and the jth column
           corresponds to the jth training example. So if example j had a label i. Then entry (i,j) 
           will be 1. 

  Arguments:
  labels -- vector containing the labels 
  C -- number of classes, the depth of the one hot dimension

  Returns: 
  one_hot -- one hot matrix
  """
  # Create a tf.constant equal to C (depth), name it 'C'. (approx. 1 line)
  C = tf.constant(C)  # Use tf.one_hot, be careful with the axis (approx. 1 line)
  one_hot_matrix = tf.one_hot(labels, C, axis=0)  # Create the session (approx. 1 line)
  sess = tf.Session()
  one_hot = sess.run(one_hot_matrix)  # Close the session (approx. 1 line). See method 1 above.
  sess.close()  
  return one_hot

參數初始化

def ones(shape):  """
  Creates an array of ones of dimension shape
  Arguments:
  shape -- shape of the array you want to create

  Returns: 
  ones -- array containing only ones
  """
  # Create "ones" tensor using tf.ones(...). (approx. 1 line)
  ones = tf.ones(shape)  # Create the session (approx. 1 line)
  sess = tf.Session()  # Run the session to compute 'ones' (approx. 1 line)
  ones = sess.run(ones)  # Close the session (approx. 1 line). See method 1 above.
  sess.close()  
  return ones

一頓操作之后，我們已經將神經網絡的一些基礎運算利用 Tensorflow 定義好了。在下一期筆記中，我們將學習如何使用 Tensorflow 搭建神經網絡。

本文由《自興動腦人工智能》項目部 凱文 投稿。