TensorFlow入門

這是關於如何開始tensorFlow的指南。開始之前，你需要先安裝TensorFlow。除此之外，你應該了解：

• 知道如何使用Python編程。
• 懂一點點數組

如果具有機器學習的知識則更好。當然，如果你沒有學習過機器學習，也應該先學習這個指引。

TensorFlow提供了很多的API。底層的API，是TensorFlow的核心，可以提供完整的控制功能，推薦希望對自己的模型進行更加細粒度控制的機器學習研究人員使用。高層次的API，建立在底層核心API之上，比底層核心API更加容易學習和使用，使用高層次的API可以更容易實現目標，並且適合不同水平的用戶。高層的API比如 tf.estimator ，可以幫助你管理數據集，實現評估、訓練、和推理。

本指南先是提供了一個TensorFlow 核心API的教程。然後，我們使用tf.estimator實現相同的模型。學習如何使用高層次API實現強大的功能。

Tensors – 張量

TensorFlow的核心數據單元式Tensor（張量），Tensor是存放基礎類型數據的任意維度的數組。Rank（等級）即Tensor的維度數。以下是一些例子：

3 #一個等級為0的tensor，是一個標量其造型為[]
[1., 2., 3.] #等級為1的tensor，是一個矢量其造型為[3]
[[1., 2., 3.], [4., 5., 6.]] #等級為2的tensor,一個矩陣其造型為[2, 3]
[[[1., 2., 3.]], [[7., 8., 9.]]] #等級為3等tensor其造型為[2, 1, 3]

核心教程

導入TensorFlow

標準的導入TensorFlow庫方式：

import tensorflow as tf

使得Python可以使用TensorFlow的類、方法和標識符。

The Computational Graph 計算圖

你可能會認為TensorFlow核心程序包含兩個獨立兩個部分：

1. 構建計算圖
2. 運行計算圖

計算圖，即使用圖形和節點的方式來標誌TensorFlow系列操作安排。我們構建這樣一個計算圖，每個節點要麽是0，要麽是使用tensor數據為輸入，tensor數據為輸出。有一種節點的類型是常量，就像全部的TensorFlow的常量一樣，它沒有輸入，並且他的輸出內部存儲的值。我們可以創建連個浮點型的，具體實現如下：

node1 = tf.constant(3.0, dtype=tf.float32)
node2 = tf.constant(4.0) # also tf.float32 implicitly
print(node1, node2)

最後打印出來的結果是：

Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

註意打印出來的節點並沒有輸出你期望的3.0和4.0數值，而是產生3.0和4.0的計算方式。如果想計算節點的值，需要使用session運行計算圖。Session封裝了TensorFlow運行時候的邏輯和狀態。

下面的代碼創建了session對象，並且調用了run方法執行計算圖邏輯來計算node1和node2。運行代碼如下：

sess = tf.Session()
print(sess.run([node1, node2]))

we see the expected values of 3.0 and 4.0:
這個時候你會看到你期望的數值3.0和4.0：

[3.0, 4.0]

我們可以組合tensor階段來構造更加復雜的計算，比如，我們可以讓兩個常量節點相加，得到的新的計算圖：

node3 = tf.add(node1, node2)
print("node3:", node3)
print("sess.run(node3):", sess.run(node3))

最後兩行打印的結果是：

node3: Tensor("Add:0", shape=(), dtype=float32)
sess.run(node3): 7.0

TensorFlow 的工具TensorBoard能夠顯示計算圖，這是一個TensorBoard的圖形的例子：

正如其表達的那樣，計算圖總是輸出常量結果。使用占位符，計算圖可以接收外部輸入的參數。占位符是的我們可以在運行(run)時候提供具體的值。

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b # 函數ft.add(a,b)的簡寫

這三行代碼有點像一個函數或者lambda表達式，我們定義了兩個參數（a和b），然後對其執行運算。我們輸入不同的參數來執行運算，通過feed_dict 將參數傳入實際值到占位符。

print(sess.run(adder_node, {a: 3, b: 4.5}))
print(sess.run(adder_node, {a: [1, 3], b: [2, 4]}))

結果如下

7.5
[ 3. 7.]

在TensorBoard中的圖形是這樣的：

通過增加其他操作，我們可以讓計算圖更加復雜，比如：

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b: 4.5}))

結果如下

22.5

顯示在TensorBoard中的計算圖是這樣的：

在機器學習中，我模型希望能夠得到不同的輸入，就如上面的例子。為了能夠訓練模型，我們需要修改計算圖，使得在相同的輸入情況下能夠獲取不同的輸出。變量(variables) 允許我們增加訓練參數到計算圖中。構造變量時候需要提供類型和一個初始值：

W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b

常量在調用tf.constant時候初始化，常量的值不能被修改。相反的，變量在調用tf.Variable時候沒有初始化。如果要初始化變量，你要調用一個特別的操作：

init = tf.global_variables_initializer()
sess.run(init)

要記住init方法是將初始化全部的全局變量的操作增加到TensorFlow的計算圖中，並沒有馬上初始化變量。初始化的操作時在調用session.run時候進行的。

因為x是一個占位符，我們可以同時計算linear_mode的幾個值：

print(sess.run(linear_model, {x: [1, 2, 3, 4]}))

輸出如下：

[ 0. 0.30000001 0.60000002 0.90000004]

我們創建了model，但不知道模型有多好。為了使用訓練數據評估模型，我們需要一個y 占位符去提供期望的值，並且要寫一個損失函數。

損失函數計算當前的模型和實際的數據的差距情況。我們將使用一個標準的損失模型來做線性回歸，計算當前模型和提供的數據之間的方差。Linear_model – y創建一個矢量，包含了每個樣本和數據之間的偏差。調用ft.square得到偏差的平方值，使用tf.reduce_sum將全部的偏差的平方值加和存放到一個標量中。

y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]}))

得到和方差為：

23.66

進一步改進，分別設置w和b的值為1和-1。變量開始時沒有初始化的，除非調了用tf.variable時候進行的。但你也可以使用ft.assign來初始化了，比如，w=1和b=1是我們模型的優化參數，我們可以這樣來修改w和b的值：

fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]}))

最後輸出的偏差是0：

0.0

完美的w和b的值是猜測出來的，但是我們希望機器學習能夠自動的找出正確的參數，我們將會在下一個環節介紹。

tf.train API

完整的討論機器學習已經超出了我們教程的範圍。然而TensorFlow提供的優化器可以逐步的調整每個變量，來降低偏差。最簡單的優化器是梯度下降優化器（gradient descent），它據該變量的導數的偏差量級來調整每個變量。通常，手工計算導數非常無聊且容易出錯。而使用tf.radients函數，TensorFlow能夠幫你自動的計算導數。範例如下所示：

optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

sess.run(init) # 重置其值為默認的值
for i in range(1000):
sess.run(train, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]})

print(sess.run([W, b]))

模型的參數最終如下：

[array([-0.9999969], dtype=float32), array([ 0.99999082],
dtype=float32)]

雖然這個簡單的線性回歸不需要多少TensorFlow核心的代碼，但現在我們正在真正的機器學習的事情。更復雜的模型和方法要用更多的代碼來提供數據。因為，為了便於使用，TensorFlow進一步抽象了通用的模式、架構和功能。我們會在下一個環節學習這些抽象。

Complete program 完整的代碼

完整的線性回歸模型訓練如下：

import tensorflow as tf

# Model parameters 模型的參數
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
# Model input and output 模型的輸入和輸出
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)

# loss 偏差
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares方差合計
# optimizer優化器
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

# training data訓練數據
x_train = [1, 2, 3, 4]
y_train = [0, -1, -2, -3]
# training loop循環訓練
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
sess.run(train, {x: x_train, y: y_train})

# evaluate training accuracy評估訓練準確度
curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))

運行後，結果如下：

W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11

註意到偏差已經是非常小的了（幾乎等於0）。假如你運行這個程序，偏差可能會不一樣，因為模型在初始化時候使用了偽隨機的數值。

這個復雜的計算圖仍然可以顯示在TensorBoard中。

tf.estimator

tf.estimator是一個高階的TensorFlow庫，可以簡化機器學習過程，包括：

• 循環訓練的運行
• 循環評估的運行
• 管理數據集

tf.estimator定義了很多通用的模型。.

Basic usage 基本用法

註意，使用tf.estimator大大的簡化了線性回歸的過程：

import tensorflow as tf
# Numpy經常用來加載、控制和和預處理數據
import numpy as np

#聲明變量，只要有一個數字類型的變量
feature_columns = [tf.feature_column.numeric_column("x", shape=[1])]

#評估器在前端負責啟動訓練（裝配）和評估（推論）。有許多預定義類型，如線性回歸、線性分類、神經元網絡分類器和回歸器。
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns)


# TensorFlow提供很多協助函數來讀取和設置數據集，在這裏我們使用了2個數據集：一個用來訓練，另一個用來做評估。我們要通知函數有幾批數據（num_epochs）以及每批有多少的數據
x_train = np.array([1., 2., 3., 4.])
y_train = np.array([0., -1., -2., -3.])
x_eval = np.array([2., 5., 8., 1.])
y_eval = np.array([-1.01, -4.1, -7, 0.])
input_fn = tf.estimator.inputs.numpy_input_fn(
{"x": x_train}, y_train, batch_size=4, num_epochs=None, shuffle=True)
train_input_fn = tf.estimator.inputs.numpy_input_fn(
{"x": x_train}, y_train, batch_size=4, num_epochs=1000, shuffle=False)
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
{"x": x_eval}, y_eval, batch_size=4, num_epochs=1000, shuffle=False)

#在調用方法時候，傳入訓練訓練數據集進行1000次的訓練。
estimator.train(input_fn=input_fn, steps=1000)

# 在這裏評估模型的執行情況
train_metrics = estimator.evaluate(input_fn=train_input_fn)
eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print("train metrics: %r"% train_metrics)
print("eval metrics: %r"% eval_metrics)

運行的結果如下：

train metrics: {‘loss‘: 1.2712867e-09, ‘global_step‘: 1000}
eval metrics: {‘loss‘: 0.0025279333, ‘global_step‘: 1000}

註意運算結果顯示更高的偏差，但是仍然接近0。意味著我們的機器學習是恰當的。

A custom model 自定義模型

tf.estimator並沒有把你限制在定義好的模型中。加入你要創建一個自定義的、TensorFlow沒有的模型。我們仍然可以使用tf.estimator的高級別的抽象，進行數據傳送、訓練等。比如，我們仍然可以通過低級別的TensorFlow的API，實現自己的和LinearRegressor一樣的模型，

自定義的模型需要依賴tf.estimator來實現，我們要使用tf.estimator.Estimator。而tf.estimator.LinearRegressor實際是tf.estimator.Estimator的一個子類。我們使用Estimator的函數mode_fn通知ft.estimator 怎樣的評估計算結果、訓練步驟以及偏差。

代碼如下：

import numpy as np
import tensorflow as tf

# Declare list of features, we only have one real-valued feature
def model_fn(features, labels, mode):
# Build a linear model and predict values
W = tf.get_variable("W", [1], dtype=tf.float64)
b = tf.get_variable("b", [1], dtype=tf.float64)
y = W * features[‘x‘] + b
# Loss sub-graph
loss = tf.reduce_sum(tf.square(y - labels))
# Training sub-graph
global_step = tf.train.get_global_step()
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = tf.group(optimizer.minimize(loss),
tf.assign_add(global_step, 1))
# EstimatorSpec connects subgraphs we built to the
# appropriate functionality.
return tf.estimator.EstimatorSpec(
mode=mode,
predictions=y,
loss=loss,
train_op=train)

estimator = tf.estimator.Estimator(model_fn=model_fn)
# define our data sets
x_train = np.array([1., 2., 3., 4.])
y_train = np.array([0., -1., -2., -3.])
x_eval = np.array([2., 5., 8., 1.])
y_eval = np.array([-1.01, -4.1, -7, 0.])
input_fn = tf.estimator.inputs.numpy_input_fn(
{"x": x_train}, y_train, batch_size=4, num_epochs=None, shuffle=True)
train_input_fn = tf.estimator.inputs.numpy_input_fn(
{"x": x_train}, y_train, batch_size=4, num_epochs=1000, shuffle=False)
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
{"x": x_eval}, y_eval, batch_size=4, num_epochs=1000, shuffle=False)

# train
estimator.train(input_fn=input_fn, steps=1000)
# Here we evaluate how well our model did.
train_metrics = estimator.evaluate(input_fn=train_input_fn)
eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print("train metrics: %r"% train_metrics)
print("eval metrics: %r"% eval_metrics)

運行結果：

train metrics: {‘loss‘: 1.227995e-11, ‘global_step‘: 1000}
eval metrics: {‘loss‘: 0.01010036, ‘global_step‘: 1000}

請註意自定義的model_fn函數的內容，和指南上的低層API的模型循環訓練是很類似的。

Next steps 下一步驟

現在你具備TensorFlow的知識可以做一點事情了。我們還有好幾個教程等著你去學習。假如你是機器學習的小白，可以先從MNIST for beginners開始學習，如果不是則可以直接學習 Deep MNIST for experts.。

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 3.0 License, and code samples are licensed under the Apache 2.0 License. For details, see our Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 八月 17, 2017.

TensorFlow文檔翻譯-01-TensorFlow入門