TensorFlow

（符號數學系統）

鎖定

pip install tensorflow
conda install -c conda-forge tensorflow

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環境

sudo tar -xz libtensorflow.tar.gz -C /usr/local

sudo ldconfig

# 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:\> 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%

# 確認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的代碼結構 ^[13]

分佈式TensorFlow的核心組件（core runtime）包括：分發中心（distributed master）、執行器（dataflow executor/worker service）、內核應用（kernel implementation）和最底端的設備層（device layer）/網絡層（networking layer） ^[13]  。

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(<initial-value>, name=<optional-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)

# 定義二階常數張量
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])))

constant = tf.constant([1, 2, 3]) # 定義常數張量
square = constant*constant # 操作（平方）
# 運行會話
with tf.Session() as sess:
   print(square.eval()) # “評估”操作所得常數張量的值

# 例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

• 本地變量：tf.GraphKeys.LOCAL_VARIABLES
• 全局變量：tf.GraphKeys.GLOBAL_VARIABLES
• 訓練梯度變量：tf.GraphKeys.TRAINABLE_VARIABLES

var3 = tf.get_variable(name="local_var", shape=(), collections=[tf.GraphKeys.LOCAL_VARIABLES])

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()

一個前饋神經網絡的拓撲結構（左）和TensorFlow數據流圖（右） ^[22]

TensorFlow在數據流編程下運行，具體地，使用數據流圖（tf.Graph）表示計算指令間的依賴關係，隨後依據圖創建會話（tf.Session）並運行圖的各個部分 ^[23]  。tf.Graph包含了圖結構與圖集合兩類相關信息，其中圖結構包含圖的節點（tf.Operation）和邊緣（張量）對象，表示各個操作組合在一起的方式，但不規定它們的使用方式，類似於彙編代碼；圖集合是在tf.Graph中存儲元數據集合的通用機制，即對象列表與鍵（tf.GraphKeys）的關聯 ^[24]  。例如當用户創建變量時，系統將其加入變量集合，並在後續操作中使用變量集合作為默認參數 ^[23]  。

# 導入模塊
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--')

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")

from tensorflow.python.tools import inspect_checkpoint as chkp
# 顯示所有張量（指定tensor_name=''可檢索特定張量）
chkp.print_tensors_in_checkpoint_file("./model.ckpt", tensor_name='', all_tensors=True)

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

• 建立數據集導入函數：可以使用TensorFlow的數據導入工具tf.data.Dataset或從NumPy數組創建數據集導入函數。
• 定義特徵列：特徵列（tf.feature_column）包含了訓練數據的特徵名稱、特徵類型和輸入預處理操作。
• 調出預創建的Estimator模型：可用的模型包括基礎統計學（baseline）、梯度提升決策樹（boosting desicion tree）和深度神經網絡的迴歸、分類器。調出模型後需提供輸入特徵列、檢查點路徑和有關模型參數（例如神經網絡的隱含層結構）。
• 訓練和評估模型：所有預創建模型都包含train和evaluate接口用於學習和評估。

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) # 評估

# 導入模塊和數據集的步驟與前一程序示例相同
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)

# 每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)

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')

# 從文件恢復模型和學習參數
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')

import tensorflow as tf
tf.enable_eager_execution()

TensorFlow輸入管道的設備佔用策略 ^[36]

tf.data是TensorFlow中進行數據管理的高階API ^[37]  。在圖像處理問題中，tf.data可以對輸入圖像進行組合或疊加隨機擾動，增大神經網絡的訓練收益；在文字處理問題中，tf.data負責字符提取和嵌入（embedding），後者將文字轉化為高維向量，是進行機器學習的重要步驟 ^[38]  。tf.data包含兩個類：tf.data.Dataset和tf.data.Iterator，Dataset自身是一系列由張量構成的組元，幷包含緩存（cache）、交錯讀取（interleave）、預讀取（prefetch）、洗牌（shuffle）、投影（map）、重複（repeat）等數據預處理方法、Iterator類似於Python的循環器，是從Dataset中提取組元的有效方式 ^[39]  。tf.data支持從NumPy數組和TFRecord中導入數據，在字符數據處理時時，tf.data.TextLineDataset可以直接輸入ASCII編碼文件 ^{[37]  [40]}  。

• 提取（Extract）：從本地或雲端的數據存儲點讀取原始數據
• 轉化（Transform）：使用計算設備（通常為CPU）對數據進行解析和後處理，例如解壓縮、洗牌（shuffling）、打包（batching）等
• 加載（Load）：在運行機器學習算法的高性能計算設備（GPU和TPU）加載經過後處理的數據

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'])

# 構建數據流圖.
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…

• 內存動態分配選項allow_growth可以根據需要分配GPU內存，該選項在開啓時會少量分配內存，並隨着會話的運行對佔用內存區域進行擴展。TensorFlow會話默認不釋放內存，以避免內存碎片問題。
• per_process_gpu_memory_fraction 選項決定每個進程所允許的GPU內存最大比例。

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:
   # ...（略去）會話內容 ...

/job:<JOB_NAME>/task:<TASK_INDEX>/device:<DEVICE_TYPE>:<DEVICE_INDEX>

# 手動分配
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])

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))

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工作流程 ^[53]

線性代數加速器（Accelerated Linear Algebra, XLA）是一個特殊的編譯器，用於優化TensorFlow中的線性代數計算，其目標是優化內存使用，提升TensorFlow的運行速度和跨平台，尤其是移動終端的可移植性 ^[53]  。

# 為低層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 --logdir=/user_log_path

from tensorflow.python import debug as tf_debug
with tf.Session() as sess:
   sess = tf_debug.LocalCLIDebugWrapperSession(sess)
   print(sess.run(c))

# 調試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）

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)

# 假設有局域網內服務器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)

谷歌雲計算服務中的TPU計算集羣 ^[75]

TensorFlow Research Cloud是面向科學研究的機器學習TPU雲計算平台。該項目擁有1000個雲TPU和總計180千萬億次計算力，每個TPU擁有64 GB的高帶寬內存 ^[75-76]  。TensorFlow Research Cloud項目在2018年2月進入Beta版，可以申請使用，在官方聲明中，其發起目的是“為確保全世界優秀的研究人員擁有足夠的計算資源以規劃、使用和發表下個機器學習浪潮的革命性突破”

參考資料

• 1.    Abadi, M., Barham, P., Chen, J., Chen, Z., Davis, A., Dean, J., et al. (2016). Tensorflow: a system for large-scale machine learning. In OSDI (Vol. 16, pp. 265-283).
• 2.    TensorFlow HomePage  ．TensorFlow[引用日期2018-10-17]
• 3.    Jack Clark. Google turning its lucrative web search over to AI machines  ．Bloomberg News．2015-10-26[引用日期2018-10-17]
• 4.    Collobert, R., Bengio, S., & Mariéthoz, J. (2002). Torch: a modular machine learning software library (No. EPFL-REPORT-82802). Idiap.
• 5.    TensorFlow - 編程人員指南 - TensorFlow 版本兼容性  ．TensorFlow．2018-7-9[引用日期2018-10-17]
• 6.    TensorFlow - Install TensorFlow  ．Tensorflow．2018-9-10[引用日期2018-10-17]
• 7.    TensorFlow - Install - Install TensorFlow with pip  ．TensoFlow．2018-9-10[引用日期2018-10-17]
• 8.    TensorFlow - Install - Docker  ．TensorFlow．2018-9-27[引用日期2018-10-17]
• 9.    TensorFlow - Install - Install TensorFlow for C  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 10.    TensorFlow - Install - GPU Support  ．TensorFlow．2018-10-09[引用日期2018-10-18]
• 11.    TensorFlow - 編程人員指南 - 常見問題解答  ．TensorFlow．2018-9-7[引用日期2018-10-17]
• 12.    語義化版本 2.0.0  ．semver.org[引用日期2018-10-17]
• 13.    TensorFlow - Extend - TensorFlow Architecture  ．TensorFlow．2018-9-28[引用日期2018-10-26]
• 14.    TensorFlow - 編程人員指南 - 張量  ．TensorFlow．2018-9-7[引用日期2018-10-17]
• 15.    TensorFlow - API r1.11 - tf.Tensor  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 16.    TensorFlow - API r1.11 - tf.Dtype  ．TensorFlow．2018-9-27[引用日期2018-10-17]
• 17.    TensorFlow - Guide - Variables  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 18.    TensorFlow - API r1.11 - tf.Variable  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 19.    TensorFlow - API r1.11 - tf.get_variable  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 20.    TensorFlow - API r 1.11 - tf.GraphKey  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 21.    TensorFlow - API r1.11 - tf.variable_scope  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 22.    Rampasek, L., & Goldenberg, A. (2016). Tensorflow: Biology’s gateway to deep learning?. Cell systems, 2(1), 12-14.
• 23.    TensorFlow - 編程人員指南 - 圖和會話  ．TensorFlow．2018-9-7[引用日期2018-10-17]
• 24.    TensorFlow - API r1.11 - tf.Graph  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 25.    TensorFlow - API r1.11 - tf.Session   ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 26.    TensorFlow - API r1.11 - tf.train.Saver  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 27.    TenorFlow - 編程人員指南 - 保存和恢復  ．TensorFlow．2018-9-7[引用日期2018-10-17]
• 28.    TensorFlow - API r1.11 - Module: tf.saved_model  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 29.    TensorFlow - 編程人員指南 - Estimators  ．TensorFlow．2018-9-7[引用日期2018-10-17]
• 30.    TensorFlow - API r1.11 - Module: tf.layers  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 31.    TesorFlow - API r1.11 - Creating Custom Estimators  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 32.    TensorFlow - Guide - Checkpoints  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 33.    Keras: The Python Deep Learning library  ．Keras．2018-10-17[引用日期2018-10-17]
• 34.    TensorFlow - Guide - Keras  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 35.    TensorFlow - Guide - Eager Execution  ．TensorFlow．2018-9-6[引用日期2018-10-18]
• 36.    TensorFlow - Performance - Input Pipeline Performance Guide  ．TensorFlow．2018-10-10[引用日期2018-10-18]
• 37.    TensorFlow - Guide - Importing Data  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 38.    TensorFlow - Guide - Embeddings  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 39.    TensorFlow - API r1.11 - Module: tf.data  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 40.    TensorFlow - API r1.11 - tf.data.TextLineDataset  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 41.    TensorFlow - API r1.11 - tf.contrib.data.parallel_interleave  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 42.    TensorFlow - API r1.11 - tf.data.Dataset  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 43.    TensorFlow - API r1.11 - tf.contrib.data.map_and_batch  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 44.    TensorFlow - API r1.11 - tf.contrib.data.shuffle_and_repeat  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 45.    TensorFlow - Guide - Using GPUs  ．TensorFlow．2018-9-28[引用日期2018-10-17]
• 46.    TensorFlow - API r1.11 - tf.ConfigProto  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 47.    Cloud TPU - 適用於TensorFlow的機器學習加速器  ．Google[引用日期2018-10-17]
• 48.    TensorFlow - Guide - Using TPUs  ．TensorFlow．2018-9-28[引用日期2018-10-18]
• 49.    TensorFlow - API r1.11 - tf.device  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 50.    TensorFlow - API r1.11 - tf.train.replica_device_setter  ．TensorFlow．2018-9-27[引用日期2018-10-18]
• 51.    TensorFlow - Performance - Model optimization  ．TensorFlow．2018-9-10[引用日期2018-10-17]
• 52.    TensorFlow - Performance - Post-training quantization  ．TensorFlow．2018-9-10[引用日期2018-10-17]
• 53.    TensorFlow - Extend - XLA  ．TensorFlow．2018-10-25[引用日期2018-10-25]
• 54.    TensorFlow - Guide - TensorBoard: Visualizing Learning  ．TensorFlow．2018-9-28[引用日期2018-10-17]
• 55.    TensorFlow - Guide - Debugger  ．TensorFlow．2018-9-28[引用日期2018-10-17]
• 56.    TensorFlow - Deploy  ．TensorFlow．2018-9-10[引用日期2018-10-17]
• 57.    TensorFlow - Deploy - Distributed TensorFlow  ．TensorFlow．2018-10-10[引用日期2018-10-17]
• 58.    TensorFlow - Deploy - TensorFlow on S3  ．TensorFlow．2018-9-10[引用日期2018-10-17]
• 59.    TensorFlow - Deploy - TensorFlow on Hadoop  ．TensorFlow．2018-10-09[引用日期2018-10-17]
• 60.    Using TensorFlow Securely  ．GitHub Inc．2018-6-14[引用日期2018-10-17]
• 61.    TensorFlow Security Advisories  ．GitHub Inc．2018-7-12[引用日期2018-10-17]
• 62.    Stack Overflow - TensorFlow  ．Stack Overflow[引用日期2018-10-17]
• 63.    TensorFlow Announcements  ．Google[引用日期2018-10-17]
• 64.    TensorFlow - 社區 - 路線圖  ．TensorFlow．2018-6-20[引用日期2018-10-17]
• 65.    TensorFlow - 社區  ．TensorFlow．2018-6-20[引用日期2018-10-17]
• 66.    TensorFlow Hub HomePage  ．TensorFlow[引用日期2018-10-18]
• 67.    TensorFlow Hub - Modules  ．TensorFlow[引用日期2018-10-18]
• 68.    Baylor, D., Breck, E., Cheng, H. T., Fiedel, N., Foo, C. Y., Haque, Z., et al. (2017). TFX: A tensorflow-based production-scale machine learning platform. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (pp. 1387-1395). ACM.
• 69.    TensorFlow Extended HomePage  ．TensorFlow[引用日期2018-10-18]
• 70.    TensorFlow Probability HomePage  ．TensorFlow[引用日期2018-10-18]
• 71.    TensorFlow.js HomePage  ．TensorFlow[引用日期2018-10-18]
• 72.    tensorflow/tfjs  ．GitHub Inc．2018-10-12[引用日期2018-10-18]
• 73.    TensorFlow Lite HomePage  ．TensorFlow[引用日期2018-10-18]
• 74.    Swift forTensorFlow HomePage  ．TensorFlow[引用日期2018-10-18]
• 75.    TensorFlow Research Cloud HomePage  ．TensorFlow[引用日期2018-10-18]
• 76.    Jouppi, N. P., Young, C., Patil, N., Patterson, D., Agrawal, G., Bajwa, R., et al. (2017). In-datacenter performance analysis of a tensor processing unit. In Computer Architecture (ISCA), 2017 ACM/IEEE 44th Annual International Symposium on (pp. 1-12). IEEE.
• 77.    TensorFlow - Magenta  ．TensorFlow[引用日期2018-10-17]
• 78.    Nucleus  ．GitHub Inc．2018-9-21[引用日期2018-10-17]
• 79.    tf.test.is_built_with_rocm  ．TensorFlow[引用日期2021-07-30]
• 80.    AMD 發佈新版 ROCm 成為 GPU 計算方面最通用的開源平台  ．AMD[引用日期2021-07-30]
• 81.    TensorFlow2.8.0正式上線，修復眾多Bug，發佈50多個漏洞補丁  ．機器之心[引用日期2022-02-12]

展開全部 收起