tensorflow

谷歌研發的第二代人工智慧學習系統

TensorFlow是谷歌基於DistBelief進行研發的第二代人工智慧學習系統，其命名來源於本身的運行原理。Tensor（張量）意味著N維數組，Flow（流）意味著基於數據流圖的計算，TensorFlow為張量從流圖的一端流動到另一端計算過程。TensorFlow是將複雜的數據結構傳輸至人工智慧神經網中進行分析和處理過程的系統。 TensorFlow可被用於語音識別或圖像識別等多項機器學習和深度學習領域，對2011年開發的深度學習基礎架構DistBelief進行了各方面的改進，它可在小到一部智能手機、大到數千台數據中心伺服器的各種設備上運行。TensorFlow將完全開源，任何人都可以用。

目錄
1支持演算法 2開源意義 3中文文檔 4背景 5安裝 語言與系統支持
版本兼容性 6組件工作原理 核心組件 低階API 高階API 加速器
優化器 可視化工具 調試程序 7部署 8安全性 9生態系統 社區
項目 應用開發 研究

支持演演算法

tensorflow
tensorflow
TensorFlow 表達了高層次的機器學習計算，大幅簡化了第一代系統，並且具備更好的靈活性和可延展性。TensorFlow一大亮點是支持異構設備分散式計算，它能夠在各個平台上自動運行模型，從手機、單個CPU / GPU到成百上千GPU卡組成的分散式系統。
從目前的文檔看，TensorFlow支持CNN、RNN和LSTM演演算法，這都是目前在Image，Speech和NLP最流行的深度神經網路模型。

開源意義

這一次的Google開源深度學習系統TensorFlow在很多地方可以應用，如語音識別，自然語言理解，計算機視覺，廣告等等。但是，基於以上論點，我們也不能過分誇大TensorFlow這種通用深度學習框架在一個工業界機器學習系統里的作用。在一個完整的工業界語音識別系統里，除了深度學習演演算法外，還有很多工作是專業領域相關的演演算法，以及海量數據收集和工程系統架構的搭建。
不過總的來說，這次谷歌的開源很有意義，尤其是對於中國的很多創業公司來說，他們大都沒有能力理解並開發一個與國際同步的深度學習系統，所以TensorFlow會大大降低深度學習在各個行業中的應用難度。

中文文檔

官方文檔中文版通過協同翻譯，現已上線，國內的愛好者可以通過GitHub協作的方式查看並完善此中文版文檔。

背景

谷歌大腦自2011年成立起開展了面向科學研究和谷歌產品開發的大規模深度學習應用研究，其早期工作即是TensorFlow的前身DistBelief 。DistBelief的功能是構建各尺度下的神經網路分散式學習和交互系統，也被稱為“第一代機器學習系統” 。DistBelief在谷歌和Alphabet旗下其它公司的產品開發中被改進和廣泛使用。2015年11月，在DistBelief的基礎上，谷歌大腦完成了對“第二代機器學習系統”TensorFlow的開發並對代碼開源。相比於前作，TensorFlow在性能上有顯著改進、構架靈活性和可移植性也得到增強。此後TensorFlow快速發展，截至穩定API版本1.12，已擁有包含各類開發和研究項目的完整生態系統。在2018年4月的TensorFlow開發者峰會中，有21個TensorFlow有關主題得到展示。

安裝

語言與系統支持

TensorFlow支持多種客戶端語言下的安裝和運行。截至版本1.12.0，綁定完成並支持版本兼容運行的語言為C和Python，其它（試驗性）綁定完成的語言為JavaScript、C++、Java、Go和Swift，依然處於開發階段的包括C#、Haskell、Julia、Ruby、Rust和Scala 。
Python
TensorFlow提供Python語言下的四個不同版本：CPU版本（tensorflow）、包含GPU加速的版本（tensorflow-gpu），以及它們的每日編譯版本（tf-nightly、tf-nightly-gpu）。TensorFlow的Python版本支持Ubuntu 16.04、Windows 7、macOS 10.12.6 Sierra、Raspbian 9.0及對應的更高版本，其中macOS版不包含GPU加速。安裝Python版TensorFlow可以使用模塊管理工具pip/pip3 或anaconda並在終端直接運行。
1
2
pip install tensorflow
conda install -c conda-forge tensorflow
此外Python版TensorFlow也可以使用Docker安裝：
1
2
3
4
5
6
7
docker pull tensorflow/tensorflow:latest
# 可用的tag包括latest、nightly、version等
# docker鏡像文件：https://hub.docker.com/r/tensorflow/tensorflow/tags/
docker run -it -p 8888:8888 tensorflow/tensorflow:latest
# dock下運行jupyter notebook
docker run -it tensorflow/tensorflow bash
# 啟用編譯了tensorflow的bash環境
C
TensorFlow提供C語言下的API用於構建其它語言的API，支持x86-64下的Linux類系統和macOS 10.12.6 Sierra或其更高版本，macOS版不包含GPU加速。安裝過程如下：
下載TensorFlow預編譯的C文件到本地系統路徑（通常為/usr/local/lib）並解壓縮。
1sudo tar -xz libtensorflow.tar.gz -C /usr/local
使用ldconfig編譯鏈接
1sudo ldconfig
此外用戶也可在其它路徑解壓文件並手動編譯鏈接。
1
2
3
4
5
6
# Linux
export LIBRARY_PATH=$LIBRARY_PATH:~/mydir/lib
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:~/mydir/lib
# MacOS
export LIBRARY_PATH=$LIBRARY_PATH:~/mydir/lib
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:~/mydir/lib
編譯C介面時需確保本地的C編譯器（例如gcc）能夠訪問TensorFlow庫。
配置GPU
TensorFlow支持在Linux和Window系統下使用統一計算架構（Compute Unified Device Architecture, CUDA）高於3.5的NVIDIA GPU 。配置GPU時要求系統有NVIDIA GPU驅動384.x及以上版本、CUDA Toolkit和CUPTI（CUDA Profiling Tools Interface）9.0版本、cuDNN SDK7.2以上版本。可選配置包括NCCL 2.2用於多GPU支持、TensorRT 4.0用於TensorFlow模型優化。
在Linux下配置GPU時，將CUDA Toolkit和CUPTI的路徑加入$LD_LIBRARY_PATH環境變數即可。對於CUDA為3.0或其它版本的NVIDIA程序，需要從源文件編譯TensorFlow 。對Windows下的GPU配置，需要將CUDA、CUPTI和cuDNN的安裝路徑加入%PATH%環境變數，在DOS終端有如下操作：
1
2
3
C:\> SET PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.0\bin;%PATH%
C:\> SET PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.0\extras\CUPTI\libx64;%PATH%
C:\> SET PATH=C:\tools\cuda\bin;%PATH%
Linux系統下使用docker安裝的Python版TensorFlow也可配置GPU加速且無需CUDA Toolkit ：
1
2
3
4
5
6
7
8
# 確認GPU狀態
lspci | grep -i nvidia
# 導入GPU加速的TensorFlow鏡像文件
docker pull tensorflow/tensorflow:latest-gpu
# 驗證安裝
docker run --runtime=nvidia --rm nvidia/cuda nvidia-smi
# 啟用bash環境
docker run --runtime=nvidia -it tensorflow/tensorflow:latest-gpu bash

版本兼容性

TensorFlow的公共API版本號使用語義化版本2.0標準，包括主版本號。次版本號。修訂號，其中主版本號的更改不是向下兼容的，已保存的TensorFlow工作可能需遷移到新的版本；次版本號的更改包含向下兼容的性能提升；修訂號的更改是向下兼容的問題修正。
TensorFlow支持版本兼容的部分包括協議緩衝區文件、所有的C介面、Python介面中的tensorflow模塊以及除tf.contrib和其它私有函數外的所有子模塊、Python函數和類。更新不支持版本兼容的部分為：包含“試驗性（experimental）”欄位的組件、使用除C和Python外其它語言開發的TensorFlow API、以GraphDef形式保存的工作、浮點數值特定位的計算精度、隨機數、錯誤和錯誤消息。其中GraphDef擁有與TensorFlow相獨立的版本號，當TensorFlow的更新放棄對某一GraphDef版本的支持后，可能有相關工具幫助用戶將GraphDef轉化為受支持的版本。需要指出，儘管 GraphDef的版本機制與TensorFlow相獨立，但對GraphDef的更改仍受限於語義版本控制，即只能在TensorFlow主版本號之間移除或更改功能。此外，修訂版本之間實施GraphDef的向前兼容。

組件工作原理

核心組件

分散式TensorFlow的核心組件（core runtime）包括：分發中心（distributed master）、執行器（dataflow executor/worker service）、內核應用（kernel implementation）和最底端的設備層（device layer）/網路層（networking layer） 。
分發中心從輸入的數據流圖中剪取子圖（subgraph），將其劃分為操作片段並啟動執行器。分發中心處理數據流圖時會進行預設定的操作優化，包括公共子表達式消去（common subexpression elimination）、常量摺疊（constant folding）等。
執行器負責圖操作（graph operation）在進程和設備中的運行、收發其它執行器的結果。分散式TensorFlow擁有參數器（parameter server）以匯總和更新其它執行器返回的模型參數。執行器在調度本地設備時會選擇進行并行計算和GPU加速。
內核應用負責單一的圖操作，包括數學計算、數組操作（array manipulation）、控制流（control flow）和狀態管理操作（state management operations）。內核應用使用Eigen執行張量的并行計算、cuDNN庫等執行GPU加速、gemmlowp執行低數值精度計算，此外用戶可以在內核應用中註冊註冊額外的內核（fused kernels）以提升基礎操作，例如激勵函數和其梯度計算的運行效率。
單進程版本的TensorFlow沒有分發中心和執行器，而是使用特殊的會話應用（Session implementation）聯繫本地設備。TensorFlow的C語言API是核心組件和用戶代碼的分界，其它組件/API均通過C語言API與核心組件進行交互。

低階API

張量（tf.Tensor）
張量是TensorFlow的核心數據單位，在本質上是一個任意維的數組。可用的張量類型包括常數、變數、張量佔位符和稀疏張量。這裡提供一個對各類張量進行定義的例子：
1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np
import tensorflow as tf
# tf.constant(value, dtype=None, name='Const', verify_shape=False)
tf.constant([0, 1, 2], dtype=tf.float32) # 定義常數
# tf.placeholder(dtype, shape=None, name=None)
tf.placeholder(shape=(None, 2), dtype=tf.float32) # 定義張量佔位符
#tf.Variable(, name=)
tf.Variable(np.random.rand(1, 3), name='random_var', dtype=tf.float32) # 定義變數
# tf.SparseTensor(indices, values, dense_shape)
tf.SparseTensor(indices=[[0, 0], [1, 2]], values=[1, 2], dense_shape=[3, 4]) # 定義稀疏張量
# tf.sparse_placeholder(dtype, shape=None, name=None)
tf.sparse_placeholder(dtype=tf.float32)
張量的秩是它的維數，而它的形狀是一個整數元組，指定了數組中每個維度的長度。張量按NumPy數組的方式進行切片和重構。這裡提供一個進行張量操作的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
# 定義二階常數張量
a = tf.constant([[0, 1, 2, 3], [4, 5, 6, 7]], dtype=tf.float32)
a_rank = tf.rank(a) # 獲取張量的秩
a_shape = tf.shape(a) # 獲取張量的形狀
b = tf.reshape(a, [4, 2]) # 對張量進行重構
# 運行會話以顯示結果
with tf.Session() as sess:
print('constant tensor: {}'.format(sess.run(a)))
print('the rank of tensor: {}'.format(sess.run(a_rank)))
print('the shape of tensor: {}'.format(sess.run(a_shape)))
print('reshaped tensor: {}'.format(sess.run(b)))
# 對張量進行切片
print("tensor's first column: {}".format(sess.run(a[:, 0])))
張量有23種數據類型，包括4類浮點實數、2類浮點複數、13類整數、邏輯、字元串和兩個特殊類型，數據類型之間可以互相轉換。TensorFlow中的張量是數據流圖中的單位，可以不具有值，但在圖構建完畢后可以獲取其中任意張量的值，該過程被稱為“評估（evaluate） ”：
1
2
3
4
5
constant = tf.constant([1, 2, 3]) # 定義常數張量
square = constant*constant # 操作（平方）
# 運行會話
with tf.Session() as sess:
print(square.eval()) # “評估”操作所得常數張量的值
TensorFlow無法直接評估在函數內部或控制流結構內部定義的張量。如果張量取決於隊列中的值，那麼只有在某個項加入隊列后才能評估。
變數（tf.Variable）
變數是可以通過操作改變取值的特殊張量。變數必須先初始化后才可使用，低階API中定義的變數必須明確初始化，高階API例如Keras會自動對變數進行初始化。TensorFlow可以在tf.Session開始時一次性初始化所有變數，對自行初始化變數，在tf.Variable上運行的tf.get_variable可以在定義變數的同時指定初始化器。這裡提供兩個變數初始化的例子：
1
2
3
4
5
6
7
8
9
10
11
12
# 例1：使用TensorFlow的全局隨機初始化器
a = tf.get_variable(name='var5', shape=[1, 2])
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
print(a.eval())
# 例2：自行定義初始化器
# tf.get_variable(name, shape=None, dtype=None, initializer=None, trainable=None, ...)
var1 = tf.get_variable(name="zero_var", shape=[1, 2, 3], dtype=tf.float32,
 initializer=tf.zeros_initializer) # 定義全零初始化的三維變數
var2 = tf.get_variable(name="user_var", initializer=tf.constant([1, 2, 3], dtype=tf.float32)) 
# 使用常數初始化變數，此時不指定形狀shape
Tensorflow提供變數集合以儲存不同類型的變數，默認的變數集合包括：
● 本地變數：tf.GraphKeys.LOCAL_VARIABLES
● 全局變數：tf.GraphKeys.GLOBAL_VARIABLES
● 訓練梯度變數：tf.GraphKeys.TRAINABLE_VARIABLES
用戶也可以自行定義變數集合：
1var3 = tf.get_variable(name="local_var", shape=(), collections=[tf.GraphKeys.LOCAL_VARIABLES])
在對變數進行共享時，可以直接引用tf.Variables，也可以使用 tf.variable_scope 進行封裝：
1
2
3
4
5
6
7
8
9
10
11
12
13
def toy_model():
定義包含變數的操作
var1 = tf.get_variable(name="user_var5", initializer=tf.constant([1, 2, 3], dtype=tf.float32))
var2 = tf.get_variable(name="user_var6", initializer=tf.constant([1, 1, 1], dtype=tf.float32))
return var1+var2
with tf.variable_scope("model") as scope:
output1 = toy_model()
# reuse語句后二次利用變數
scope.reuse_variables()
output2 = toy_model()
# 在variable_scope程序塊內啟用reuse
with tf.variable_scope(scope, reuse=True):
output3 = toy_model()
數據流圖（tf.Graph）和會話（tf.Session）
TensorFlow在數據流編程下運行，具體地，使用數據流圖（tf.Graph）表示計算指令間的依賴關係，隨後依據圖創建會話（tf.Session）並運行圖的各個部分。tf.Graph包含了圖結構與圖集合兩類相關信息，其中圖結構包含圖的節點（tf.Operation）和邊緣（張量）對象，表示各個操作組合在一起的方式，但不規定它們的使用方式，類似於彙編代碼；圖集合是在tf.Graph中存儲元數據集合的通用機制，即對象列表與鍵（tf.GraphKeys）的關聯。例如當用戶創建變數時，系統將其加入變數集合，並在後續操作中使用變數集合作為默認參數。
構建tf.Graph時將節點和邊緣對象加入圖中不會觸發計算，圖構建完成後將計算部分分流給tf.Session實現計算。tf.Session擁有物理資源，通常與Python的with代碼塊中使用，在離開代碼塊后釋放資源。在不使用with代碼塊的情況下創建tf.Session，應在完成會話時明確調用tf.Session.close結束進程。調用Session.run創建的中間張量會在調用結束時或結束之前釋放。tf.Session.run是運行節點對象和評估張量的主要方式，tf.Session.run需要指定fetch並提供供給數據（feed）字典，用戶也可以指定其它選項以監督會話的運行。這裡使用低階API以批量梯度下降的線性回歸為例展示tf.Graph的構建和tf.Session的運行：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 導入模塊
import numpy as np
import tensorflow as tf
# 準備學習數據
train_X = np.random.normal(1, 5, 200) # 輸入特徵
train_Y = 0.5*train_X+2+np.random.normal(0, 1, 200) # 學習目標
L = len(train_X) # 樣本量
# 定義學習超參數
epoch = 200 # 紀元數（使用所有學習數據一次為1紀元）
learn_rate = 0.005 # 學習速度
# 定義數據流圖
temp_graph = tf.Graph()
with temp_graph.as_default():
X = tf.placeholder(tf.float32) # 定義張量佔位符
Y = tf.placeholder(tf.float32)
k = tf.Variable(np.random.randn(), dtype=tf.float32)
b = tf.Variable(0, dtype=tf.float32) # 定義變數
linear_model = k*X+b # 線性模型
cost = tf.reduce_mean(tf.square(linear_model - Y)) # 代價函數
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learn_rate) # 梯度下降演演算法
train_step = optimizer.minimize(cost) # 最小化代價函數
init = tf.global_variables_initializer() # 使用變數全局初始化選項
train_curve = [] # 定義列表存儲學習曲線
with tf.Session(graph=temp_graph) as sess:
sess.run(init) # 變數初始化
for i in range(epoch):
sess.run(train_step, feed_dict={X: train_X, Y: train_Y}) # 運行“最小化代價函數”
temp_cost = sess.run(cost, feed_dict={X: train_X, Y: train_Y}) # 代價函數
train_curve.append(temp_cost) # 學習曲線
kt_k = sess.run(k); kt_b = sess.run(b) # 運行“模型參數”
Y_pred = sess.run(linear_model, feed_dict={X: train_X}) # 運行“模型”得到學習結果
# 繪製學習結果
ax1 = plt.subplot(1, 2, 1); ax1.set_title('Linear model fit');
ax1.plot(train_X, train_Y, 'b.'); ax1.plot(train_X, Y_pred, 'r-')
ax2 = plt.subplot(1, 2, 2); ax2.set_title('Training curve');
ax2.plot(train_curve, 'r--')
保存和恢復
TensorFlow的低階API可以保存模型和學習得到的變數，對其進行恢復后可以無需初始化直接使用。對張量的保存和恢復使用tf.train.Saver 。里提供一個應用於變數的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import tensorflow as tf
# 保存變數
var = tf.get_variable("var_name", [5], initializer = tf.zeros_initializer) # 定義
saver = tf.train.Saver({"var_name": var}) # 不指定變數字典時保存所有變數
with tf.Session() as sess:
var.initializer.run() # 變數初始化
# 在當前路徑保存變數
saver.save(sess, "./model.ckpt")
# 讀取變數
tf.reset_default_graph() # 清空所有變數
var = tf.get_variable("var_name", [5], initializer = tf.zeros_initializer)
saver = tf.train.Saver({"var_name": var}) # 使用相同的變數名
with tf.Session() as sess:
# 讀取變數（無需初始化）
saver.restore(sess, "./model.ckpt")
使用檢查點工具tf.python.tools.inspect_checkpoint可以查看文件中保存的張量，這裡提供一個例子：
1
2
3
from tensorflow.python.tools import inspect_checkpoint as chkp
# 顯示所有張量（指定tensor_name=''可檢索特定張量）
chkp.print_tensors_in_checkpoint_file("./model.ckpt", tensor_name='', all_tensors=True)
TensorFlow保存的模型使用SavedModel文件包，該文件包含是一種獨立於語言（language-neutral）且可恢復的序列化格式，使較高級別的系統和工具可以創建、使用和轉換 TensorFlow模型為SavedModel 。tf.saved_model API可以直接與SavedModel進行交互，tf.saved_model.simple_save用於保存模型，tf.saved_model.loader.load用於導入模型。其一般用法如下：
1
2
3
4
5
6
7
8
from tensorflow.python.saved_model import tag_constants
export_dir = '' # 定義保存路徑
# ...（略去）定義圖...
with tf.Session(graph=tf.Graph()) as sess:
# ...（略去）運行圖...
# 保存圖
tf.saved_model.simple_save(sess, export_dir, inputs={"x": x, "y": y}, outputs={"z": z})
tf.saved_model.loader.load(sess, [tag_constants.TRAINING], export_dir) # tag默認為SERVING
上述保存方法適用於大部分圖和會話，但具體地，用戶也可使用構建器（builder API）手動構建SavedModel。

高階API

Estimators
Estimators是TensorFlow自帶的高階神經網路API 。Estimators封裝了神經網路的訓練、評估、預測、導出等操作。Estimators的特點是具有完整的可移植性，即同一個模型可以在各類終端、服務中運行並使用GPU或TPU加速而無需重新編碼。Estimators模型提供分散式訓練循環，包括構建圖、初始化變數、載入數據、處理異常、創建檢查點（checkpoint）並從故障中恢復、保存TensorBoard的摘要等。Estimators包含了預創建模型，其工作流程如下：
● 建立數據集導入函數：可以使用TensorFlow的數據導入工具tf.data.Dataset或從NumPy數組創建數據集導入函數。
● 定義特徵列：特徵列（tf.feature_column）包含了訓練數據的特徵名稱、特徵類型和輸入預處理操作。
● 調出預創建的Estimator模型：可用的模型包括基礎統計學（baseline）、梯度提升決策樹（boosting desicion tree）和深度神經網路的回歸、分類器。調出模型后需提供輸入特徵列、檢查點路徑和有關模型參數（例如神經網路的隱含層結構）。
● 訓練和評估模型：所有預創建模型都包含train和evaluate介面用於學習和評估。
這裡提供一個使用Estimator預創建的深度神經網路分類器對MNIST數據進行學習的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
import tensorflow as tf
from tensorflow import keras
# 讀取google fashion圖像分類數據
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
# 轉化像素值為浮點數
train_images = train_images / 255.0
test_images = test_images / 255.0
# 使用NumPy數組構建數據集導入函數
train_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"pixels": train_images}, y=train_labels.astype(np.int32), shuffle=True)
test_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"pixels": test_images}, y=test_labels.astype(np.int32), shuffle=False)
# 定義特徵列（numeric_column為數值型）
feature_columns = [tf.feature_column.numeric_column("pixels", shape=[28, 28])]
# 定義深度學習神經網路分類器，新建文件夾estimator_test保存檢查點
classifier = tf.estimator.DNNClassifier(
feature_columns=feature_columns, hidden_units=[128, 128], 
optimizer=tf.train.AdamOptimizer(1e-4), n_classes=10, model_dir = './estimator_test')
classifier.train(input_fn=train_input_fn, steps=20000) # 學習
model_eval = classifier.evaluate(input_fn=test_input_fn) # 評估
Estimator提供“層函數（tf.layer） ”和其它有關工具以支持用戶自定義新模型，這些工具也被視為“中層API”。由於自定義完整模型過程繁瑣，因此可首先使用預構建模型並完成一次訓練循環，在分析結果之後嘗試自定義模型。這裡提供一個自定義神經網路分類器的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 導入模塊和數據集的步驟與前一程序示例相同
def my_model(features, labels, mode, params):
# 仿DNNClassifier構建的自定義分類器
# 定義輸入層-隱含層-輸出層
net = tf.feature_column.input_layer(features, params['feature_columns'])
for units in params['hidden_units']:
net = tf.layers.dense(net, units=units, activation=tf.nn.relu)
logits = tf.layers.dense(net, params['n_classes'], activation=None)
# argmax函數轉化輸出結果
predicted_classes = tf.argmax(logits, 1)
# （學習完畢后的）預測模式
if mode == tf.estimator.ModeKeys.PREDICT:
predictions = {'class_ids': predicted_classes[:, tf.newaxis]}
return tf.estimator.EstimatorSpec(mode, predictions=predictions)
# 定義損失函數
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
# 計算評估指標（以分類精度為例）
accuracy = tf.metrics.accuracy(labels=labels, predictions=predicted_classes, name='acc_op')
metrics = {'accuracy': accuracy}
tf.summary.scalar('accuracy', accuracy[1])
if mode == tf.estimator.ModeKeys.EVAL:
# 評估模式
return tf.estimator.EstimatorSpec(mode, loss=loss, eval_metric_ops=metrics)
else:
# 學習模式
assert mode == tf.estimator.ModeKeys.TRAIN
optimizer = tf.train.AdagradOptimizer(learning_rate=0.1) # 定義優化器
train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step()) # 優化損失函數
return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)
# 調用自定義模型，使用前一程序示例中的 1.構建數據集導入函數 和 2. 特徵列
classifier = tf.estimator.Estimator(model_fn=my_model, params={
'feature_columns': feature_columns,
'hidden_units': [64, 64],
'n_classes': 10})
# 學習（後續的評估/預測步驟與先前相同）
classifier.train(input_fn=train_input_fn, steps=20000)
Estimators的模型參數無需另外保存，在使用模型時提供檢查點的路徑即可調出上次學習獲得的參數重新初始化模型。Estimators也支持用戶自定義檢查點規則。這裡提供一個例子：
1
2
3
4
5
6
# 每20分鐘保存一次檢查點/保留最新的10個檢查點
my_checkpoint = tf.estimator.RunConfig(save_checkpoints_secs = 20*60, keep_checkpoint_max = 10)
# 使用新的檢查點規則重新編譯先前模型（保持模型結構不變）
classifier = tf.estimator.DNNClassifier(
feature_columns=feature_columns, hidden_units=[128, 128], 
model_dir = './estimator_test', config=my_checkpoint)
除使用檢查點作為對模型進行自動保存的工具外，用戶也可使用低階API將模型保存至SavedModel文件。
Keras
Keras是一個支持TensorFlow、Thenao和Microsoft-CNTK的第三方高階神經網路API 。Keras以TensorFlow的Python API為基礎提供了神經網路、尤其是深度網路的構築模塊，並將神經網路開發、訓練、測試的各項操作進行封裝以提升可擴展性和簡化使用難度。在TensorFlow下可以直接導出Keras模塊使用。這裡提供一個使用tensorflow.keras構建深度神經網路分類器對MNIST數據進行學習的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import tensorflow as tf
from tensorflow import keras
# 讀取google fashion圖像分類數據
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
# 轉化像素值為浮點數
train_images = train_images / 255.0
test_images = test_images / 255.0
# 構建輸入層-隱含層-輸出層
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation=tf.nn.relu),
keras.layers.Dense(10, activation=tf.nn.softmax)
])
# 設定優化演演算法、損失函數
model.compile(optimizer=tf.keras.optimizers.Adam(lr=0.001),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 開始學習（epochs=5）
model.fit(train_images, train_labels, epochs=5)
# 模型評估
test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Test accuracy:', test_acc)
# 預測
predictions = model.predict(test_images)
# 保存模式和模式參數
model.save_weights('./keras_test') # 在當前路徑新建文件夾
model.save('my_model.h5')
Keras可以將模型導入Estimators以利用其完善的分散式訓練循環，對上述例子，導入方式如下：
1
2
3
4
5
# 從文件恢復模型和學習參數
model = keras.models.load_model('my_model.h5')
model.load_weights('./keras_test')
# 新建文件夾存放Estimtor檢查點
est_model = tf.keras.estimator.model_to_estimator(keras_model=model, model_dir='./estimtor_test')
使用tensorflow.keras可以運行所有兼容Keras的代碼而不損失速度，但在Python的模塊管理工具中，tensorflow.keras的最新版本可能落後於Keras的官方版本。tensorflow.keras使用HDF5文件保存神經網路的權重係數。
Eager Execution
Eager Execution是基於TensorFlow Python API的命令式編程環境，幫助用戶跳過數據流編程的圖操作，直接獲取結果，便於TensorFlow的入門學習和模型調試，在機器學習應用中可以用於快速迭代小模型和小型數據集。Eager Execution環境只能在程序的開始，即導入tensorflow模塊時啟用 :
1
2
import tensorflow as tf
tf.enable_eager_execution()
Eager Execution使用Python控制流，支持標準的Python調試工具，狀態對象的生命周期也由其對應的Python對象的生命周期，而不是tf.Session決定。Eager Execution支持大多數TensorFlow操作和GPU加速，但可能會使某些操作的開銷增加。
Data
tf.data是TensorFlow中進行數據管理的高階API 。在圖像處理問題中，tf.data可以對輸入圖像進行組合或疊加隨機擾動，增大神經網路的訓練收益；在文字處理問題中，tf.data負責字元提取和嵌入（embedding），後者將文字轉化為高維向量，是進行機器學習的重要步驟。tf.data包含兩個類：tf.data.Dataset和tf.data.Iterator，Dataset自身是一系列由張量構成的組元，並包含緩存（cache）、交錯讀取（interleave）、預讀取（prefetch）、洗牌（shuffle）、投影（map）、重複（repeat）等數據預處理方法、Iterator類似於Python的循環器，是從Dataset中提取組元的有效方式。tf.data支持從NumPy數組和TFRecord中導入數據，在字元數據處理時時，tf.data.TextLineDataset可以直接輸入ASCII編碼文件。
tf.data可用於構建和優化大規機器學習的輸入管道（input pipline），提升TensorFlow性能。一個典型的輸入管道包含三個部分：
● 提取（Extract）：從本地或雲端的數據存儲點讀取原始數據
● 轉化（Transform）：使用計算設備（通常為CPU）對數據進行解析和后處理，例如解壓縮、洗牌（shuffling）、打包（batching）等
● 載入（Load）：在運行機器學習演演算法的高性能計算設備（GPU和TPU）載入經過後處理的數據
在本地的同步操作下，當GPU/TPU進行演演算法迭代時，CPU處於閑置狀態，而當CPU分發數據時，GPU/TPU處於閑置狀態。tf.data.Dataset.prefetch在轉化和載入數據時提供了預讀取技術，可以實現輸入管道下演演算法迭代和數據分發同時進行，在當前學習迭代完成時能更快地提供下一個迭代的輸入數據。tf.data.Dataset.prefetch的buffer_size參數通常為預讀取值的個數。
tf.data支持輸入管道的并行，tf.contrib.data.parallel_interleave可以并行提取數據；映射函數tf.data.Dataset.map能夠并行處理用戶的指定操作。對於跨CPU并行，用戶可以通過num_parallel_calls介面指定并行操作的等級。一般而言，并行等級與設備的CPU核心數相同，即在四核處理器上可定義num_parallel_calls=4 。在大數據問題中，可使用tf.contrib.data.map_and_batch并行處理用戶操作和分批操作。這裡提供一個構建和優化輸入管道的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import tensorflow as tf
# 使用FLAG統一管理輸入管道參數
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_integer('num_parallel_readers', 0, 'doc info')
tf.app.flags.DEFINE_integer('shuffle_buffer_size', 0, 'doc info')
tf.app.flags.DEFINE_integer('batch_size', 0, 'doc info')
tf.app.flags.DEFINE_integer('num_parallel_calls', 0, 'doc info')
tf.app.flags.DEFINE_integer('prefetch_buffer_size', 0, 'doc info')
# 自定義操作（map）
def map_fn(example):
# 定義數據格式（圖像、分類標籤）
example_fmt = {"image": tf.FixedLenFeature((), tf.string, ""),
"label": tf.FixedLenFeature((), tf.int64, -1)}
# 按格式解析數據
parsed = tf.parse_single_example(example, example_fmt)
image = tf.image.decode_image(parsed["image"]) # 圖像解碼操作
return image, parsed["label"]
# 輸入函數
def input_fn(argv):
# 列出路徑的所有TFRData文件（修改路徑后）
files = tf.data.Dataset.list_files("/path/TFRData*")
# 并行交叉讀取數據
dataset = files.apply(
tf.contrib.data.parallel_interleave(
tf.data.TFRecordDataset, cycle_length=FLAGS.num_parallel_readers))
dataset = dataset.shuffle(buffer_size=FLAGS.shuffle_buffer_size) # 數據洗牌
# map和batch的并行操作
dataset = dataset.apply(
tf.contrib.data.map_and_batch(map_func=map_fn,
batch_size=FLAGS.batch_size,
num_parallel_calls=FLAGS.num_parallel_calls))
dataset = dataset.prefetch(buffer_size=FLAGS.prefetch_buffer_size) # 數據預讀取設置
return dataset
# argv的第一個字元串為說明
tf.app.run(input_fn, argv=['pipline_params',
'--num_parallel_readers', '2',
'--shuffle_buffer_size', '50',
'--batch_size', '50',
'--num_parallel_calls, 4'
'--prefetch_buffer_size', '50'])
在輸入管道的各項操作中，交叉讀取、預讀取和洗牌能降低內存佔用，因此具有高優先順序。數據的洗牌應在重複操作前完成，為此可使用兩者的組合方法tf.contrib.data.shuffle_and_repeat 。

加速器

CPU和GPU設備
TensorFlow支持CPU和GPU運行，在程序中設備使用字元串進行表示。CPU表示為"/cpu:0"；第一個GPU表示為"/device:GPU:0"；第二個GPU表示為"/device:GPU:1"，以此類推。如果TensorFlow指令中兼有CPU和GPU實現，當該指令分配到設備時，GPU設備有優先權。TensorFlow僅使用計算能力高於3.5的GPU設備。
在啟用會話時打開log_device_placement配置選項，可以在終端查看會話中所有操作和張量所分配的設備，這裡提供一個例子：
1
2
3
4
5
6
7
8
# 構建數據流圖.
a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name='a')
b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name='b')
c = tf.matmul(a, b)
# 啟用會話並設定log_device_placement=True.
with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
print(sess.run(c))
# 終端中可見信息：MatMul: (MatMul): /job:localhost/replica:0/task:0/device:CPU:0…
默認地，TensorFlow會儘可能地使用GPU內存，最理想的情況是進程只分配可用內存的一個子集，或者僅根據進程需要增加內存使用量，為此，啟用會話時可通過兩個編譯選項來進行GPU進程管理。
● 內存動態分配選項allow_growth可以根據需要分配GPU內存，該選項在開啟時會少量分配內存，並隨著會話的運行對佔用內存區域進行擴展。TensorFlow會話默認不釋放內存，以避免內存碎片問題。
● per_process_gpu_memory_fraction 選項決定每個進程所允許的GPU內存最大比例。
這裡提供一個在會話中編譯GPU進程選項的例子：
1
2
3
4
5
config = tf.ConfigProto()
config.gpu_options.allow_growth = True # 開啟GPU內存動態分配
config.gpu_options.per_process_gpu_memory_fraction = 0.4 # 內存最大佔用比例為40%
with tf.Session(config=config) as sess:
# ...（略去）會話內容 ...
TPU設備
張量處理器（Tensor Processing Unit, TPU）是谷歌為TensorFlow定製的專用晶元。TPU部署於谷歌的雲計算平台，並作為機器學習產品開放研究和商業使用。TensorFlow的神經網路API Estimator擁有支持TPU下可運行的版本TPUEstimator 。TPUEstimator可以在本地進行學習/調試，並上傳谷歌雲計算平台進行計算。
使用雲計算TPU設備需要快速向TPU供給數據，為此可使用tf.data.Dataset API從谷歌雲存儲分區中構建輸入管道。小數據集可使用tf.data.Dataset.cache完全載入到內存中，大數據可轉化為TFRecord格式並使用tf.data.TFRecordDataset進行讀取。
設備管理（tf.device）
TensorFlow使用tf.device對設備進行管理，tf.device的設備規範具有以下形式：
1/job:/task:/device::
其中 是一個字母數字字元串，並且不以數字開頭。 是一種註冊設備類型（例如 GPU 或 CPU）。 是一個非負整數，表示名為 的作業中的任務的索引。 是一個非負整數，表示設備索引，例如用於區分同一進程中使用的不同GPU設備。
定義變數時可以使用tf.device指定設備名稱，tf.train.replica_device_setter可以對變數的設備進行自動分配，這裡提供一個在不同設備定義變數和操作的例子：
1
2
3
4
5
6
7
8
9
# 手動分配
with tf.device("/device:GPU:1"):
 var = tf.get_variable("var", [1])
# 自動分配
cluster_spec = {
"ps": ["ps0:2222", "ps1:2222"],
"worker": ["worker0:2222", "worker1:2222", "worker2:2222"]}
with tf.device(tf.train.replica_device_setter(cluster=cluster_spec)):
 v = tf.get_variable("var", shape=[20, 20])
根據tf.device對變數的分配，在單一GPU的系統中，與變數有關的操作會被固定到CPU或GPU上；在多GPU的系統中，操作會在偏好設備（或多個設備同時）運行。多GPU并行處理圖的節點能加快會話的運行，這裡提供一個例子：
1
2
3
4
5
6
7
8
9
10
11
12
c = [] # 在GPU:1和GPU:2定義張量（運行該例子要求系統存在對應GPU設備）
for d in ['/device:GPU:1', '/device:GPU:2']:
with tf.device(d):
a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3])
b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2])
c.append(tf.matmul(a, b))
# 在CPU定義相加運算
with tf.device('/cpu:0'):
my_sum = tf.add_n(c)
# 啟用會話
with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
print(sess.run(my_sum))

優化器

模型優化工具
Tensorflow提供了模型優化工具（Model Optimization Toolkit）對模型的尺度、響應時間和計算開銷進行優化。模型優化工具可以減少模型參數的使用量（pruning）、對模型精度進行量化（quantization）和改進模型的拓撲結構，適用於將模型部署到終端設備，或在有硬體局限時運行模型，因此有很多優化方案是TensorFlow Lite項目的一部分。其中量化能夠在最小化精度損失的情況下顯著減小模型尺度和縮短響應時間，並是優化深度學習模型的重要手段。這裡提供一個使用使用模型優化工具的例子：
1
2
3
4
5
import tensorflow as tf
converter = tf.contrib.lite.TocoConverter.from_saved_model(path) # 從路徑導入模型
converter.post_training_quantize = True # 開啟學習后量化
tflite_quantized_model = converter.convert() # 輸出量化后的模型
open("quantized_model.tflite", "wb").write(tflite_quantized_model) # 寫入新文件
XLA
線性代數加速器（Accelerated Linear Algebra, XLA）是一個特殊的編譯器，用於優化TensorFlow中的線性代數計算，其目標是優化內存使用，提升TensorFlow的運行速度和跨平台，尤其是移動終端的可移植性。
XLA工作的前端輸入為“高層優化器（High Level Optimizer, HLO）”定義的數據流圖，隨後XLA使用多種獨立於計算設備的演演算法優化方案對圖進行分析，並將HLO計算送入後端。後端會進一步進行基於特定設備，例如GPU的優化。截至TensorFlow的1.12版本，XLA依然處於早期開發狀態，暫不能提供顯著的性能優化，其硬體支持包括JIT和AOT編譯的x86-64 CPU、NVIDIA GPU 。

可視化工具

TensorFlow擁有自帶的可視化工具TensorBoard，TensorBoard具有展示數據流圖、繪製分析圖、顯示附加數據等功能。開源安裝的TensorFlow會自行配置TensorBoard。啟動TensorBoard前需要建立模型檔案，低階API使用tf.summary構建檔案，Keras包含callback方法、Estimator會自行建立檔案。這裡提供兩個例子：
1
2
3
4
5
6
7
8
9
10
11
12
# 為低層API構建檔案
my_graph = tf.Graph()
with my_graph.as_default():
# 構建數據流圖
with tf.Session(graph=my_graph) as sess:
# 會話操作
file_writer = tf.summary.FileWriter('/user_log_path', sess.graph) # 輸出文件
# 為Keras模型構建檔案
import tensorflow.keras as keras
tensorboard = keras.callbacks.TensorBoard(log_dir='./logs')
# … （略去）用戶自定義模型 ...
model.fit(callbacks=[tensorboard]) # 調用fit時載入callback
檔案建立完畢后在終端可依據檔案路徑運行TensorBoard主程序：
1tensorboard --logdir=/user_log_path
當終端顯示TensorBoard 1.12.0 at http://your_pc_name:6006 (Press CTRL+C to quit)時，跳轉至localhost:6006可使用TensorFlow界面。

調試程序

由於通用調試程序，例如Python的pdb很難對TensorFlow代碼進行調試，因此TensorFlow團隊開發了專用的調試模塊TFDBG，該模塊可以在學習和預測時查看會話中數據流圖的內部結構和狀態。TFDBG在運行時期間會攔截指令生成的錯誤，並向用戶顯示錯誤信息和調試說明。TFDBG使用文本交互系統curses，在不支持curses的Windows操作系統，可以下載非官方的Windows curses軟體包或使用readline作為代替。使用TFDBG調試會話時，可以直接將會話進行封裝，具體有如下例子：
1
2
3
4
from tensorflow.python import debug as tf_debug
with tf.Session() as sess:
sess = tf_debug.LocalCLIDebugWrapperSession(sess)
print(sess.run(c))
封裝容器與會話具有相同界面，因此調試時無需修改代碼。封裝容器在會話開始時調出命令行界面（Command Line Interface, CLI），CLI包含超過60條指令，用戶可以在使用指令控制會話、檢查數據流圖、列印及保存張量。
TFDBG可以調試神經網路API Estimator和Keras，對Estimator，TFDBG創建調試掛鉤（LocalCLIDebugHook）作為Estimator中的fit和evaluate方法下monitor的參數。對Keras，TFDBG提供Keras後端會話的封裝對象，這裡提供一些調試例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
# 調試Estimator
Import tensorflow as tf
from tensorflow.python import debug as tf_debug
hooks = [tf_debug.LocalCLIDebugHook()] # 創建調試掛鉤
# classifier = tf.estimator. … 調用Estimator模型
classifier.fit(x, y, steps, monitors=hooks) # 調試fit
classifier.evaluate(x, y, hooks=hooks) # 調試evaluate
# 調試Keras
from keras import backend as keras_backend
# 在程序開始時打開後端會話封裝
keras_backend.set_session(tf_debug.LocalCLIDebugWrapperSession(tf.Session()))
# 構建Keras模型
model.fit(...) # 使用模型學習時進入調試界面（CLI）
TFDBG支持遠程和離線會話調試，可應用於在沒有終端訪問許可權的遠程機器（例如雲計算）運行Tensorflow的場合。除CLI外，TFDBG在TensorBoard擁有擁有圖形界面的調試程序插件，該插件提供了計算圖檢查、張量實時可視化、張量連續性和條件性斷點以及將張量關聯到圖源代碼等功能。

部署

TensorFlow支持在一個或多個系統下使用多個設備並部署分散式伺服器（distributed server）和伺服器集群（cluster）。tf.train.Server.create_local_server可在本地構建簡單的分散式伺服器。這裡提供一個例子：
1
2
3
4
5
6
7
import tensorflow as tf
c = tf.constant("Hello, distributed TensorFlow!")
# 建立伺服器
server = tf.train.Server.create_local_server()
# 在伺服器運行會話
with tf.Session(server.target) as sess
sess.run(c)
TensorFlow伺服器集群是分佈運行的數據流圖中的“任務（task）”集合，每個任務都會被分配至一個TensorFlow服務，其中包含一個“主幹（master）”以啟動會話和一個“工作點（worker）”執行圖的操作。伺服器集群可以被分割為“工作（job）”，每個工作包含一或多個任務。
部署伺服器集群時，通常每個任務分配一台機器，但也可在一台機器的不同設備運行多個任務。每個任務都包含tf.train.ClusterSpec方法以描述該伺服器集群的全部任務（每個任務的ClusterSpec是相同的）和tf.train.Server方法按工作名提取本地任務。tf.train.ClusterSpec要求輸入一個包含所有工作名和地址的字典；而tf.train.Server對象包含一系列本地設備、與tf.train.ClusterSpec中其它任務的鏈接和一個使用鏈接進行分散式計算的會話。每個任務都是一個特定工作名的成員，並有一個任務編號（task index）。任務可以通過編號與其它任務相聯繫。這裡提供一個部署兩個任務於兩台伺服器的例子：
1
2
3
4
5
6
7
# 假設有區域網內伺服器localhost:2222和localhost:2223
# 在第一台機器建立任務
cluster = tf.train.ClusterSpec({"local": ["localhost:2222", "localhost:2223"]})
server = tf.train.Server(cluster, job_name="local", task_index=0)
# 在第二台機器建立任務
cluster = tf.train.ClusterSpec({"local": ["localhost:2222", "localhost:2223"]})
server = tf.train.Server(cluster, job_name="local", task_index=1)
分散式TensorFlow支持亞馬遜簡易存儲服務（Amazon Simple Storage Service, S3）和開源的Hadoop分散式文件系統（Hadoop Distributed File System,HDFS） 。

安全性

TensorFlow的模型文件是代碼，在執行數據流圖計算時可能的操作包括讀寫文件、從網路發送和接收數據、生成子進程，這些過程對系統會造成影響。在運行由未知第三方提供的TensorFlow模型、計算流圖（GraphDef和SavedModel）和檢查點文件時，一個推薦的做法是使用沙盒（sand box）以監測其行為。安全的TensorFlow模型在引入未知輸入數據時，也可能觸發TensorFlow內部或系統的錯誤。
TensorFlow的分散式計算平台和伺服器介面（tf.train.Server）不包含授權協議和信息加密選項，任何具有網路許可權的訪問者都可以運行tf.train.Server上的任何代碼，因此TensorFlow不適用於不信任的網路。在區域網或雲計算平台部署TensorFlow計算集群時，需要為其配備獨立網路（isolated networks） 。
TensorFlow作為一個使用大量第三方庫（NumPy、libjpeg-turbo等）的複雜系統，容易出現漏洞。用戶可以使用電子郵件向TensorFlow團隊報告漏洞和可疑行為，對於高度敏感的漏洞，其GitHub頁面提供了郵件的SSH密鑰。以下列出截至2018年7月12日的已知漏洞：
編號內容版本報告方
TFSA-2018-006惡意構造編譯文件引起非法內存訪問1.7及以下Tencent Blade Team
TFSA-2018-005（原文）“Old Snappy Library Usage Resulting in Memcpy Parameter Overlap”1.7及以下Tencent Blade Team
TFSA-2018-004檢查點源文件越界讀取1.7及以下Tencent Blade Team
TFSA-2018-003TensorFlow Lite TOCO FlatBuffer庫解析漏洞1.7及以下Tencent Blade Team
TFSA-2018-002（原文）“GIF File Parsing Null Pointer Dereference Error”1.5及以下Tencent Blade Team
TFSA-2018-001BMP文件解析越界讀取1.6及以下Tencent Blade Team

生態系統

社區

TensorFlow位於GitHub的三個代碼庫負責處理事件和提供技術支持，一般性的求助也可發送至StackOverflow的TensorFlow板塊。TensorFlow使用公共郵箱發布主要版本和重要公告，其官方網站的“路線圖”頁面匯總了其近期的開發計劃。TensorFlow團隊擁有推特賬戶和博客以發布項目的新聞和動態。TensorFlow的YouTube頻道介紹了TensorFlow在機器學習和人工智慧領域的應用，並定期推送節目，包括“TensorFlow Meets”、“Ask TensorFlow”和“Coding TensorFlow” 。

項目

TensorFlow Hub
TensorFlow Hub是一個允許用戶發布、共享和使用TensorFlow模塊的庫開發項目。用戶可以將TensorFlow數據流圖或其部分使用Hub進行封裝並移植到其它問題中再次利用。TensorFlow Hub頁面列出了由谷歌和DeepMind提供的封裝模型，其主題包括字元嵌入、視頻分類和圖像處理。
TensorFlow Extended (TFX)
TFX是谷歌基於TensorFlow開發的產品級機器學習平台，其目標是是對產品開發中的模型實現、分析驗證和業務化操作進行整合，在實時數據下完成機器學習產品的標準化生產。TFX包含三個演演算法庫：TensorFlow Data Validation對機器學習數據進行統計描述和驗證、TensorFlow Transform對模型數據進行預處理、TensorFlow Model Analysis對機器學習模型進行分析，提供表現評分。另有TensorFlow Serving作為模型業務化的高性能系統，提供模型介面和管理。
TensorFlow Probability (TFP)
TFP是在TensorFlow Python API基礎上開發的統計學演演算法庫，其目標是方便用戶將概率模型和深度學習模型相結合使用。TFP包含大量概率分佈的生成器、支持構建深度網路的概率層（probabilistic layers）、提供變分貝葉斯推斷（Variational inference）和馬爾可夫鏈蒙特卡羅方法（Markov chain Monte Carlo）和一些特殊的優化器，包括Nelder-Mead方案、BFGS演演算法（Broyden-Fletcher-Goldfarb-Shanno algorithm）和SGLD（Stochastic Gradient Langevin Dynamics） 。

應用開發

TensorFlow.js
TensorFlow.js是TensorFlow的JavaScript API，主要用於網頁端的機器學習應用開發。TensorFlow.js可以在瀏覽器和Node.js下轉化和運行TensorFlow構建的機器學習模型，並使用網頁端數據對模型進行訓練。截至2018年9月18日，TensorFlow.js的版本號為0.13 。
TensorFlow Lite
TensorFlow Lite是為移動和嵌入式設備運行機器學習代碼的問題提供解決方案。TensorFlow Lite包含優化演演算法以提升Android、iOS等系統下機器學習模型的響應時間並降低文件大小。谷歌內部的許多移動端產品，包括谷歌相冊、谷歌郵箱客戶端、谷歌鍵盤等都使用TensorFlow Lite部署了人工智慧演演算法。
Swift for TensorFlow
Swift for TensorFlow是開源版Swift的TensorFlow API開發項目。Swift for TensorFlow類似於Eager Execution可以直接執行數據流圖且性能更高。截至10月13日，Swift for TensorFlow處於早期開發狀態。

研究

TensorFlow Research Cloud
谷歌雲計算服務中的TPU計算集群
TensorFlow Research Cloud是面向科學研究的機器學習TPU雲計算平台。該項目擁有1000個雲TPU和總計180千萬億次計算力，每個TPU擁有64 GB的高帶寬內存。TensorFlow Research Cloud項目在2018年2月進入Beta版，可以申請使用，在官方聲明中，其發起目的是“為確保全世界優秀的研究人員擁有足夠的計算資源以規劃、使用和發表下個機器學習浪潮的革命性突破”
（原文） “Our goal is to ensure that the most promising researchers in the world have access to enough compute power to imagine, implement, and publish the next wave of ML breakthroughs.”
除面向研究的TPU服務外，谷歌也提供商用的Cloud TPU項目以支持企業的Tensorflow開發。
Magenta
Magenta是在藝術領域使用機器學習的研究項目，該項目使用深度學習網路和強化學習演演算法學習生成音樂、繪畫和其它藝術作品，以幫助藝術人員拓展其創作過程。Magenta項目的研究成果包括音樂創作工具NSynth和混音工具MusicVAE。
Nucleus
Nucleus是將TensorFlow應用於基因組文件，例如SAM和VCF格式文件的讀寫和分析的庫開發項目。Nucleus使用Python和C++進行開發，截至2018年9月已發布0.2.0版本。

基本信息

外文名
TensorFlow
運行系統
Linux、macOS、Windows iOS、Android、Web
支持語言
Python、C++、CUDA
原版名稱
神經網路演算法庫DistBelief
使用類型
機器學習庫
開發者
谷歌大腦
屬性
第二代人工智慧學習系統
研發基礎
DistBelie
研發
發布屬性
計算機科學軟體
初始版本
beta/2015年11月9日
穩定版本
1.12.0/2018年10月9日
許可協議
Apache 2.0 open source license