1. 介紹

首先讓我們來看看TensorFlow！

但是在我們開始之前，我們先來看看Python API中的TensorFlow代碼，這樣你就可以感受到我們怎么做的。

這段很短的 Python 程序生成了一些三維數據, 然后用一個平面擬合它。

import tensorflow as tf
import numpy as np

# Create 100 phony x, y data points in NumPy, y = x * 0.1 + 0.3
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3

# Try to find values for W and b that compute y_data = W * x_data + b
# (We know that W should be 0.1 and b 0.3, but TensorFlow will
# figure that out for us.)
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))
y = W * x_data + b

# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

# Before starting, initialize the variables.  We will 'run' this first.
init = tf.global_variables_initializer()

# Launch the graph.
sess = tf.Session()
sess.run(init)

# Fit the line.
for step in range(201):
    sess.run(train)
    if step % 20 == 0:
        print(step, sess.run(W), sess.run(b))

# Learns best fit is W: [0.1], b: [0.3]

# Close the Session when we're done.
sess.close()

該代碼的第一部分構建了數據流圖。在創建會話并run 調用該函數之前，TensorFlow實際上不會運行任何計算。

為了進一步提高您的興趣，我們建議您在TensorFlow中學習常見的機器學習問題。在神經網絡的領域上，最經典的問題是MNIST手寫數字分類問題。我們在這里為機器學習新手和專業人士分別提供了兩種教程。

如果您已經確定要學習并安裝TensorFlow，可以跳過這些步驟，直接閱讀后面的章節。
不用擔心，我們會使用MNIST做為技術教程的示例來闡述TensorFlow的特性，所以您仍然可以看到MNIST。

2. 下載與安裝

您可以從我們提供的二進制包或github源安裝TensorFlow。

要求

TensorFlow支持Python 2.7和Python 3.3+。

GPU版本最好使用Cuda Toolkit 8.0和cuDNN v5。只有從源代碼安裝時，才支持其他版本（Cuda工具包> = 7.0和cuDNN> = v3）。有關詳細信息，請參閱Cuda安裝。對于Mac OS X，請參閱安裝GPU for Mac。

概述

你可以使用我們提供的 Pip, Docker, Virtualenv, Anaconda 或 源碼編譯的方法安裝 TensorFlow。

如果您熟悉Pip，Virtualenv，Anaconda或Docker，請隨時根據您的需求進行調整。
如果遇到安裝錯誤，請參閱常見問題的解決方案。

基于Pip安裝

Pip是用于安裝和管理用Python編寫的軟件包的軟件包管理系統。我們在Linux，Mac OS X和Windows上為TensorFlow提供pip軟件包。有關Windows的說明，請參閱Windows上的Pip安裝。

首先安裝 pip (或 Python3 的 pip3 )：

# Ubuntu/Linux 64-bit
$ sudo apt-get install python-pip python-dev

# Mac OS X
$ sudo easy_install pip
$ sudo easy_install --upgrade six

我們也將CPU版本的二進制文件上傳到Pypi，因此您可以簡單地在Linux，Mac或Windows上pip安裝TensorFlow：

$ pip install tensorflow

請注意，您的pip版本需要在8.1或更高版本才能讓上述命令在Linux上工作。

對于Windows用戶，您還可以使用以下方式安裝GPU版本的二進制文件： bash $ pip install tensorflow-gpu。
由于其大小超過Pypi限制，所以此命令尚不適用于在Linux或Mac安裝GPU版本的二進制文件。

如果上述命令不能在您的系統上運行，或者您想在Linux或Mac上安裝GPU版本的二進制文件，則可以按照以下步驟進行操作：

# Ubuntu/Linux 64-bit, CPU only, Python 2.7
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp27-none-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 2.7
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp27-none-linux_x86_64.whl

# Mac OS X, CPU only, Python 2.7:
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.12.0rc1-py2-none-any.whl

# Mac OS X, GPU enabled, Python 2.7:
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow_gpu-0.12.0rc1-py2-none-any.whl

# Ubuntu/Linux 64-bit, CPU only, Python 3.4
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 3.4
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, CPU only, Python 3.5
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp35-cp35m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 3.5
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp35-cp35m-linux_x86_64.whl

# Mac OS X, CPU only, Python 3.4 or 3.5:
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.12.0rc1-py3-none-any.whl

# Mac OS X, GPU enabled, Python 3.4 or 3.5:
$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow_gpu-0.12.0rc1-py3-none-any.whl

安裝TensorFlow：

# Python 2
$ sudo pip install --upgrade $TF_BINARY_URL

# Python 3
$ sudo pip3 install --upgrade $TF_BINARY_URL

注意：如果之前安裝過 TensorFlow < 0.7.1 的版本,應該先使用 pip uninstall 卸載 TensorFlow 和 protobuf ,保證獲取的是一個最新 protobuf 依賴下的安裝包。

安裝完成之后，您就可以測試您的安裝是否成功了。

在Windows上Pip安裝

TensorFlow在Windows上僅支持64位Python 3.5。我們已經使用以下Python版本測試了pip軟件包：

• 來自Anaconda的Python 3.5

• 來自python.org的Python 3.5

注意：TensorFlow要求MSVCP140.DLL文件，它可能不會安裝在您的系統上。如果當您import tensorflow as tf遇到錯誤No module named "_pywrap_tensorflow"和/或DLL load failed，請檢查MSVCP140.DLL是否在您的%PATH%，如果不是，您應該安裝Visual C ++ 2015可再發行組件 （x64版本）。

下面兩種命令進行pip安裝。

只是安裝CPU版本的TensorFlow，請在命令提示符下輸入以下命令：C:\> pip install --upgrade https://storage.googleapis.com/tensorflow/windows/cpu/tensorflow-0.12.0rc1-cp35-cp35m-win_amd64.whl

要安裝GPU版本的TensorFlow，請在命令提示符下輸入以下命令：C:\> pip install --upgrade https://storage.googleapis.com/tensorflow/windows/gpu/tensorflow_gpu-0.12.0rc1-cp35-cp35m-win_amd64.whl

安裝完成之后，您就可以測試您的安裝是否成功了。

您還可以使用Virtualenv或Anaconda環境來管理在Windows上安裝TensorFlow。

基于Virtualenv安裝

Virtualenv是為不同Python項目創建一個隔離的容器的工具。利用Virtualenv安裝TensorFlow不會影響原先存在的的Python環境。

使用Virtualenv安裝步驟如下：

• 安裝pip和Virtualenv。
• 創建一個Virtualenv環境。
• 激活Virtualenv環境并在其中安裝TensorFlow。
• 安裝完成后，您將在每次要使用TensorFlow時激活Virtualenv環境。

安裝pip和Virtualenv：

# Ubuntu/Linux 64-bit
$ sudo apt-get install python-pip python-dev python-virtualenv

# Mac OS X
$ sudo easy_install pip
$ sudo pip install --upgrade virtualenv

在目錄中創建一個Virtualenv環境~/tensorflow：

$ virtualenv --system-site-packages ~/tensorflow

激活環境：

$ source ~/tensorflow/bin/activate  # If using bash
$ source ~/tensorflow/bin/activate.csh  # If using csh
(tensorflow)$  # Your prompt should change

最后，Pip安裝TensorFlow。

首先選擇正確的二進制文件進行安裝：

# Ubuntu/Linux 64-bit, CPU only, Python 2.7
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp27-none-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 2.7
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp27-none-linux_x86_64.whl

# Mac OS X, CPU only, Python 2.7:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.12.0rc1-py2-none-any.whl

# Mac OS X, GPU enabled, Python 2.7:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow_gpu-0.12.0rc1-py2-none-any.whl

# Ubuntu/Linux 64-bit, CPU only, Python 3.4
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 3.4
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, CPU only, Python 3.5
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp35-cp35m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 3.5
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp35-cp35m-linux_x86_64.whl

# Mac OS X, CPU only, Python 3.4 or 3.5:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.12.0rc1-py3-none-any.whl

# Mac OS X, GPU enabled, Python 3.4 or 3.5:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow_gpu-0.12.0rc1-py3-none-any.whl

最后安裝TensorFlow：

# Python 2
(tensorflow)$ pip install --upgrade $TF_BINARY_URL

# Python 3
(tensorflow)$ pip3 install --upgrade $TF_BINARY_URL

在Virtualenv環境激活后，您現在可以測試您的安裝。

當您完成使用TensorFlow后，停用環境。

(tensorflow)$ deactivate

$  # Your prompt should change back

要使用TensorFlow，您將需要再次激活Virtualenv環境：

$ source ~/tensorflow/bin/activate  # If using bash.
$ source ~/tensorflow/bin/activate.csh  # If using csh.
(tensorflow)$  # Your prompt should change.
# Run Python programs that use TensorFlow.
...
# When you are done using TensorFlow, deactivate the environment.
(tensorflow)$ deactivate

基于Anaconda安裝

Anaconda是一個集成許多第三方科學計算庫的 Python 科學計算環境。Anaconda使用一個名為“conda”的包管理器，它具有與Virtualenv相似的環境系統。

與Virtualenv一樣，不同Python 工程需要的依賴包,conda 將他們存儲在不同的地方。利用Anconda安裝TensorFlow不會影響原先存在的的Python環境。

• 安裝Anaconda。
• 創建一個conda環境。
• 激活conda環境并在其中安裝TensorFlow。
• 安裝完成后，每次要使用TensorFlow時，都需要激活環境。
• 可選地將ipython和其他軟件包安裝到conda環境中。

安裝Anaconda：

按照Anaconda下載站點上的說明進行操作。

注意：如果已經通過Anaconda環境以外的pip安裝TensorFlow，但想在Anaconda環境中使用TensorFlow，就需要先卸載之前在環境以外的利用pip安裝的TensorFlow，因為Anaconda從.local更高優先級搜索系統site-packages 。

Python 2

$ pip uninstall tensorflow

Python 3

$ pip3 uninstall tensorflow 

創建一個名為tensorflow的conda環境：

# Python 2.7
$ conda create -n tensorflow python=2.7

# Python 3.4
$ conda create -n tensorflow python=3.4

# Python 3.5
$ conda create -n tensorflow python=3.5

激活環境，并在其中使用conda或pip安裝TensorFlow。

使用conda

目前只有CPU版本的TensorFlow可用，可以安裝在Python 2或Python 3的conda環境中。

$ source activate tensorflow
(tensorflow)$  # Your prompt should change

# Linux/Mac OS X, Python 2.7/3.4/3.5, CPU only:
(tensorflow)$ conda install -c conda-forge tensorflow

使用pip

如果使用pip進行安裝，請確保使用--ignore-installed選項來防止出現easy_install的錯誤提示。

$ source activate tensorflow
(tensorflow)$  # Your prompt should change

現在，像普通Pip安裝一樣安裝TensorFlow。首先選擇正確的二進制文件進行安裝：

# Ubuntu/Linux 64-bit, CPU only, Python 2.7
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp27-none-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 2.7
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp27-none-linux_x86_64.whl

# Mac OS X, CPU only, Python 2.7:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.12.0rc1-py2-none-any.whl

# Mac OS X, GPU enabled, Python 2.7:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow_gpu-0.12.0rc1-py2-none-any.whl

# Ubuntu/Linux 64-bit, CPU only, Python 3.4
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 3.4
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, CPU only, Python 3.5
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp35-cp35m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 3.5
# Requires CUDA toolkit 8.0 and CuDNN v5. For other versions, see "Installing from sources" below.
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp35-cp35m-linux_x86_64.whl

# Mac OS X, CPU only, Python 3.4 or 3.5:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.12.0rc1-py3-none-any.whl

# Mac OS X, GPU enabled, Python 3.4 or 3.5:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/gpu/tensorflow_gpu-0.12.0rc1-py3-none-any.whl

最后安裝TensorFlow：

# Python 2
(tensorflow)$ pip install --ignore-installed --upgrade $TF_BINARY_URL

# Python 3
(tensorflow)$ pip3 install --ignore-installed --upgrade $TF_BINARY_URL

使用方法

在環境環境激活后，您現在可以測試您的安裝。

當您完成使用TensorFlow后，退出環境。

(tensorflow)$ source deactivate

$  # Your prompt should change back

要使用TensorFlow，您需要重新激活conda環境：

$ source activate tensorflow
(tensorflow)$  # Your prompt should change.
# Run Python programs that use TensorFlow.
...
# When you are done using TensorFlow, deactivate the environment.
(tensorflow)$ source deactivate

安裝IPython

要使用帶有IPython的TensorFlow環境，可能需要將IPython安裝到環境中：

$ source activate tensorflow
(tensorflow)$ conda install ipython

同樣，像pandas一樣的其他Python包可能需要安裝到環境中才能與TensorFlow一起使用。

Docker安裝

Docker是一種在Linux操作系統上運行的自建版本的虛擬機。當您通過Docker安裝和運行TensorFlow時，將與機器上預先安裝存在的包完全隔離。

我們提供4個Docker鏡像：

• gcr.io/tensorflow/tensorflow：TensorFlow CPU二進制鏡像。
• gcr.io/tensorflow/tensorflow:latest-develCPU二進制鏡像加源碼。
• gcr.io/tensorflow/tensorflow:latest-gpu：TensorFlow GPU二進制鏡像。
• gcr.io/tensorflow/tensorflow:latest-devel-gpu：GPU二進制鏡像加源代碼。

我們也有標簽latest替換為已發布的版本（例如， 0.12.0-rc1-gpu）。

Docker的安裝如下：

• 在您的機器上安裝Docker。
• 創建一個Docker group以允許啟動容器。
• 啟動包含TensorFlow映像的Docker容器。首次啟動時，鏡像會自動下載。

有關在您的計算機上安裝Docker的說明，請參閱安裝Docker。

Docker安裝完成后，啟動包含TensorFlow映像的Docker容器。

$ docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow

該選項-p 8888:8888用于將Docker容器內部端口發布到主機，在這種情況下可以確保Jupyter notebook的連接。

端口映射的格式是hostPort:containerPort。您可以為主機端口指定任何有效的端口號，但必須將8888用于容器端口部分。

如果您正在使用具有GPU支持的容器，則必須傳遞一些附加選項來將GPU設備公開到容器。

NVidia GPU支持安裝最新的NVidia驅動程序和nvidia-docker。

$ nvidia-docker run -it -p 8888:8888 gcr.io/tensorflow/tensorflow:latest-gpu

如果您運行nvidia-docker有任何問題，就使用默認配置運行，我們會在安裝位置中植入一個帶選項的腳本，如下列命令行所示的。

$ path/to/repo/tensorflow/tools/docker/docker_run_gpu.sh -p 8888:8888 gcr.io/tensorflow/tensorflow:latest-gpu

有關詳細信息，請參閱TensorFlow docker readme。

您現在可以在Docker容器內測試您的安裝了。

測試TensorFlow的安裝

啟用GPU支持(LINUX，選項)

如果您安裝了TensorFlow的GPU版本，還必須安裝Cuda Toolkit 8.0和cuDNN v5。請看Cuda安裝。

您還需要設置LD_LIBRARY_PATH和CUDA_HOME環境變量。將以下命令添加到您的~/.bash_profile文件中。下面的命令假設您的CUDA安裝在/usr/local/cuda目錄下：

export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64"
export CUDA_HOME=/usr/local/cuda

從命令行運行TensorFlow

如果發生錯誤，請參閱常見問題。

打開terminal并鍵入以下內容：

$ python
...
>>> import tensorflow as tf
>>> hello = tf.constant('Hello, TensorFlow!')
>>> sess = tf.Session()
>>> print(sess.run(hello))
Hello, TensorFlow!
>>> a = tf.constant(10)
>>> b = tf.constant(32)
>>> print(sess.run(a + b))
42
>>>

從源代碼安裝

從源代碼安裝時，您將構建一個pip wheel，然后使用pip安裝。

Windows上從源代碼安裝TensorFlow，您可以在Windows上使用Bazel或TensorFlow CMake build的支持。

克隆TensorFlow倉庫

$ git clone https://github.com/tensorflow/tensorflow

請注意，上述代碼將安裝主分支上最新的TensorFlow。如果要安裝特定的分支（如發行版分支），請傳遞-b <branchname>給git clone命令和--recurse-submodules給TensorFlow所依賴的r0.8及更早版本的protobuf庫。

Linux環境準備

安裝Bazel

首先按照教程安裝bazel的依賴。然后下載適合您操作系統的最新穩定版的bazel，最后按照下面腳本執行：

$ chmod +x PATH_TO_INSTALL.SH
$ ./PATH_TO_INSTALL.SH --user

注意把 PATH_TO_INSTALL.SH 替換為你下載的安裝包的文件路徑。

安裝其他依賴

# For Python 2.7:
$ sudo apt-get install python-numpy python-dev python-wheel python-mock
# For Python 3.x:
$ sudo apt-get install python3-numpy python3-dev python3-wheel python3-mock

可選：安裝CUDA（在Linux上啟用GPU支持）

為了編譯并運行具有GPU支持的TensorFlow，需要安裝NVIDIA的Cuda Toolkit（>=7.0）和cuDNN（>=v3）。

TensorFlow GPU支持需要具有NVIDIA計算能力（> = 3.0）的GPU卡。支持的顯卡包括：

• NVidia Titan

• NVidia Titan X

• NVidia K20

• NVidia K40

...

檢查您的GPU卡的NVIDIA計算能力：https://developer.nvidia.com/cuda-gpus

下載并安裝Cuda Toolkit：https://developer.nvidia.com/cuda-downloads

如果使用的是二進制版本，請安裝8.0版。

安裝Toolkit到如下路徑：/usr/local/cuda。

下載并安裝cuDNN：https://developer.nvidia.com/cudnn

下載cuDNN v5。

解壓縮并將cuDNN文件復制到Toolkit目錄中。假設安裝了Toolkit到/usr/local/cuda，請運行以下命令（cuDNN版本設置為您下載的版本）：

tar xvzf cudnn-8.0-linux-x64-v5.1-ga.tgz
sudo cp -P cuda/include/cudnn.h /usr/local/cuda/include/
sudo cp -P cuda/lib64/libcudnn* /usr/local/cuda/lib64/
sudo chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn*

可選：安裝OpenCL（僅限實驗和Linux系統）

為了通過OpenCL支持構建或運行TensorFlow，需要安裝OpenCL（> = 1.2）和ComputeCpp（> = 0.1.1）。

TensorFlow只能利用支持OpenCL 1.2的加速器。支持的加速器包括：

• AMD Fiji

• AMD Hawaii

...

請注意，此支持目前是實驗性的，生產不應依賴于它（后去會逐漸成熟）。

下載并安裝OpenCL驅動程序

安裝所需功能的OpenCL取決于你的環境。在Unbuntu 14.04，正常按照以下步驟進行安裝：

sudo apt-get install ocl-icd-opencl-dev opencl-headers

您還需要為加速器本身安裝驅動程序。我們已經測試了在Ubuntu 14.04上安裝以下的AMD Fiji和Hawaii GPU驅動程序：

sudo apt-get install fglrx-core fglrx-dev

下載并安裝ComputeCpp編譯器

從Codeplay的網站下載編譯器，解壓縮并將文件復制到如下的路徑/usr/local/computecpp：

tar -xvzf ComputeCpp-CE-0.1.1-Ubuntu.14.04-64bit.tar.gz
sudo mkdir /usr/local/computecpp
sudo cp -R ComputeCpp-CE-0.1.1-Linux /usr/local/computecpp
sudo chmod -R a+r /usr/local/computecpp/
sudo chmod -R a+x /usr/local/computecpp/bin

Mac環境準備

我們建議使用homebrew來安裝bazel依賴項，并使用easy_install或pip安裝python依賴項。

依賴

按照這里的說明安裝bazel的依賴項。然后可以使用homebrew來安裝bazel：

$ brew install bazel

您可以使用easy_install或pip安裝python依賴項。使用easy_install。

$ sudo easy_install -U six
$ sudo easy_install -U numpy
$ sudo easy_install wheel

我們還推薦使用IPython。

$ sudo easy_install ipython

可選：為Mac設置GPU支持

如果您打算構建GPU支持，則需要確保您通過homebrew安裝GNU coreutils：

$ brew install coreutils

接下來，您將需要確保您已經安裝了CUDA Toolkit。需要從NVIDIA或使用Homebrew Cask擴展下載適用于您的OSX版本的軟件包 ：

$ brew tap caskroom/cask
$ brew cask install cuda

一旦安裝了CUDA Toolkit，您將需要添加以下內容到~/.bash_profile文件中來設置所需的環境變量：

export CUDA_HOME=/usr/local/cuda
export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:$CUDA_HOME/lib"
export PATH="$CUDA_HOME/bin:$PATH"

最后，您還將安裝CUDA Deep Neural Network （cuDNN v5）庫。一旦您下載它到本地，您可以解壓縮并將根目錄和庫移動到本地的CUDA Toolkit文件夾：

$ sudo mv include/cudnn.h /Developer/NVIDIA/CUDA-8.0/include/
$ sudo mv lib/libcudnn* /Developer/NVIDIA/CUDA-8.0/lib
$ sudo ln -s /Developer/NVIDIA/CUDA-8.0/lib/libcudnn* /usr/local/cuda/lib/

要驗證CUDA安裝，您可以構建并運行deviceQuery以確保安裝成功。

$ cp -r /usr/local/cuda/samples ~/cuda-samples
$ pushd ~/cuda-samples
$ make
$ popd
$ ~/cuda-samples/bin/x86_64/darwin/release/deviceQuery

如果需要編譯TensorFlow需要Xcode 7.3并且安裝了CUDA 7.5，但是需要注意的是，Xcode 7.3尚不兼容CUDA 7.5。所以您可以升級到CUDA 8.0，或者安裝并設置Xcode 7.2為默認值：

$ sudo xcode-select -s /Application/Xcode-7.2/Xcode.app

配置安裝

從源碼樹的根路徑運行configure腳本。配置腳本時候會詢問您的Python解釋器的路徑，并允許（可選）配置CUDA庫。

此步驟用于定位python和numpy的頭文件。如果您安裝了支持CUDA的GPU和Toolkit，則支持構建GPU支持。當提示是否構建TensorFlow的GPU支持，選擇Y選項。

例如：

$ ./configure
Please specify the location of python. [Default is /usr/bin/python]:
Do you wish to build TensorFlow with Google Cloud Platform support? [y/N] N
No Google Cloud Platform support will be enabled for TensorFlow
Do you wish to build TensorFlow with GPU support? [y/N] y
Do you wish to build TensorFlow with OpenCL support? [y/N] N
GPU support will be enabled for TensorFlow
Please specify which gcc nvcc should use as the host compiler. [Default is /usr/bin/gcc]:
Please specify the Cuda SDK version you want to use, e.g. 7.0. [Leave empty to use system default]: 8.0
Please specify the location where CUDA 8.0 toolkit is installed. Refer to README.md for more details. [Default is /usr/local/cuda]:
Please specify the cuDNN version you want to use. [Leave empty to use system default]: 5
Please specify the location where cuDNN 5 library is installed. Refer to README.md for more details. [Default is /usr/local/cuda]:
Please specify a list of comma-separated Cuda compute capabilities you want to build with.
You can find the compute capability of your device at: https://developer.nvidia.com/cuda-gpus.
Please note that each additional compute capability significantly increases your build time and binary size.

Setting up Cuda include
Setting up Cuda lib
Setting up Cuda bin
Setting up Cuda nvvm
Setting up CUPTI include
Setting up CUPTI lib64
Configuration finished

這將創建一個規范的符號鏈接到您的Cuda庫。每次您更改Cuda路徑時，您需要在調用bazel構建命令之前再次運行此步驟。對于cuDNN庫，R3使用“7.0”，R4使用“4.0.7”。

如果需要構建對OpenCL的支持，請在構建TensorFlow時選擇OpenCL支持，并提供ComputeCpp編譯器的位置（例如/usr/local/computecpp）。

已知的問題

• 盡管可以在同一個源碼樹下編譯開啟 Cuda 支持和禁用 Cuda 支持的版本, 我們還是推薦在 在切換這兩種不同的編譯配置時, 使用 "bazel clean" 清理環境.。

• 在執行 bazel 編譯前必須先運行 configure, 否則編譯會失敗并提示錯誤信息. 未來, 我們可能考慮將 configure 步驟包含在編譯過程中, 以簡化整個過程, 前提是 bazel 能夠提供新的特性支持這樣。

創建pip包并安裝

從源代碼構建時，您仍然會構建一個pip包并進行安裝。

請注意，默認情況下，源的構建需要大量內存資源，如果要限制RAM使用情況，可以在調用bazel時添加--local_resources 2048,.5,1.0。

$ bazel build -c opt //tensorflow/tools/pip_package:build_pip_package

# To build with GPU support:
$ bazel build -c opt --config=cuda //tensorflow/tools/pip_package:build_pip_package

$ bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg

# The name of the .whl file will depend on your platform.
$ sudo pip install /tmp/tensorflow_pkg/tensorflow-0.12.0rc1-py2-none-any.whl

優化CPU性能

為了與盡可能廣泛的機器兼容，TensorFlow默認僅在x86機器上使用SSE4.1 SIMD指令。大多數現代的PC和Mac支持更高級的指令，所以如果你正在構建一個只能在自己的機器上運行的二進制文件，那么你可以通過--copt=-march=native在你的bazel build命令中使用這些二進制文件 。例如：

$ bazel build --copt=-march=native -c opt //tensorflow/tools/pip_package:build_pip_package

如果您正在分發二進制文件但知道要運行的計算機的功能，則可以手動選擇正確的說明--copt=-march=avx。例如，您可能還想使用多個參數啟用多個功能 --copt=-mavx2 --copt=-mfma。

如果在不支持SIMD的計算機上運行使用SIMD指令構建的二進制文件，則執行該代碼時會發現非法指令錯誤。

設置TensorFlow的發展

如果您正在使用TensorFlow，則可以在交互式python shell中測試更改，而無需重新安裝TensorFlow。

要設置TensorFlow的所有文件從鏈接到系統目錄，請在TensorFlow根目錄下運行以下命令：

bazel build -c opt //tensorflow/tools/pip_package:build_pip_package

# To build with GPU support:
bazel build -c opt --config=cuda //tensorflow/tools/pip_package:build_pip_package

mkdir _python_build
cd _python_build
ln -s ../bazel-bin/tensorflow/tools/pip_package/build_pip_package.runfiles/org_tensorflow/* .
ln -s ../tensorflow/tools/pip_package/* .
python setup.py develop

請注意，此設置仍需要您在每次更改C ++文件時重建//tensorflow/tools/pip_package:build_pip_package目標;添加，刪除或移動任何python文件; 或者更改bazel構建規則。

還要注意，bazel test并不總是通過這些符號鏈接正確解決依賴關系，因此測試結果可能不可靠。解決方法是_python_build在運行之前刪除bazel test目錄。

訓練您的第一個TensorFlow神經網絡模型

首先從GitHub 克隆TensorFlow models repo。運行以下命令：

$ cd models/tutorials/image/mnist
$ python convolutional.py
Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
Extracting data/train-images-idx3-ubyte.gz
Extracting data/train-labels-idx1-ubyte.gz
Extracting data/t10k-images-idx3-ubyte.gz
Extracting data/t10k-labels-idx1-ubyte.gz
Initialized!
Epoch 0.00
Minibatch loss: 12.054, learning rate: 0.010000
Minibatch error: 90.6%
Validation error: 84.6%
Epoch 0.12
Minibatch loss: 3.285, learning rate: 0.010000
Minibatch error: 6.2%
Validation error: 7.0%
...
...

常見問題

GPU 相關問題

如果在嘗試運行一個 TensorFlow 程序時出現以下錯誤:

ImportError: libcudart.so.7.0: cannot open shared object file: No such file or directory

請確認你正確安裝了GPU支持。

Protobuf庫相關問題

TensorFlow的pip包依賴于protobuf 3.1.0版本的pip軟件包。可以從PyPI（運行時pip install protobuf）下載的Protobuf的pip軟件包，Python能利用它實現原型序列化/反序列化的，它比C ++實現慢10倍到50倍。Protobuf還支持包含基于快速C ++的原語解析的Python包的二進制擴展。此擴展在只有Python標準的PIP包中不可用。我們為protobuf創建了一個包含二進制擴展名的自定義二進制pip包。按照以下說明安裝自定義二進制protobuf pip軟件包：

# Ubuntu/Linux 64-bit:
$ pip install --upgrade https://storage.googleapis.com/tensorflow/linux/cpu/protobuf-3.0.0-cp27-none-linux_x86_64.whl

# Mac OS X:
$ pip install --upgrade https://storage.googleapis.com/tensorflow/mac/cpu/protobuf-3.0.0-cp27-cp27m-macosx_10_11_x86_64.whl

對于Python 3.5

# Ubuntu/Linux 64-bit:
$ pip3 install --upgrade https://storage.googleapis.com/tensorflow/linux/cpu/protobuf-3.0.0-cp35-cp35m-linux_x86_64.whl

# Mac OS X:
$ pip3 install --upgrade https://storage.googleapis.com/tensorflow/mac/cpu/protobuf-3.0.0-cp35-cp35m-macosx_10_11_x86_64.whl

如果您的系統/配置未列在上面，您可以使用以下說明來構建您自己的protobuf wheel文件。安裝之前，請參閱這里：

然后：

$ git clone https://github.com/google/protobuf.git
$ cd protobuf
$ ./autogen.sh
$ CXXFLAGS="-fPIC -g -O2" ./configure
$ make -j12
$ export PROTOC=$PWD/src/protoc
$ cd python
$ python setup.py bdist_wheel --cpp_implementation --compile_static_extension
$ pip uninstall protobuf
$ pip install dist/<wheel file name>

在安裝TensorFlow之后，通過pip安裝上面的軟件包，因為標準地進行pip安裝tensorflow，只能安裝python支持的pip軟件包。上述pip包將覆蓋現有的protobuf包。
請注意，二進制pip包最大支持已經大于64MB的protobuf，應該修復以下錯誤：

[libprotobuf ERROR google/protobuf/src/google/protobuf/io/coded_stream.cc:207] A
protocol message was rejected because it was too big (more than 67108864 bytes).
To increase the limit (or to disable these warnings), see
CodedInputStream::SetTotalBytesLimit() in google/protobuf/io/coded_stream.h.

Pip安裝問題

Cannot import name 'descriptor'

ImportError: Traceback (most recent call last):
  File "/usr/local/lib/python3.4/dist-packages/tensorflow/core/framework/graph_pb2.py", line 6, in <module>
    from google.protobuf import descriptor as _descriptor
ImportError: cannot import name 'descriptor'

如果升級到較新版本的TensorFlow時出現上述錯誤，請嘗試卸載TensorFlow和protobuf（如果已安裝）并重新安裝TensorFlow（也請安裝正確的protobuf依賴項）。

找不到setup.py

如果，在pip install，你遇到錯誤如下：

...
IOError: [Errno 2] No such file or directory: '/tmp/pip-o6Tpui-build/setup.py'

解決方案：升級您的PIP版本：

pip install --upgrade pip

這可能需要sudo，取決于以前如何安裝PIP的。

SSLError：SSL_VERIFY_FAILED

如果在從網址安裝pip的過程中遇到如下錯誤：

...
SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed

解決方案：通過curl或wget手動下載wheel文件，并在本地pip安裝。

Operation not permitted

...
Installing collected packages: setuptools, protobuf, wheel, numpy, tensorflow
Found existing installation: setuptools 1.1.6
Uninstalling setuptools-1.1.6:
Exception:
...
[Errno 1] Operation not permitted: '/tmp/pip-a1DXRT-uninstall/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/_markerlib'

解決方案：在pip命令中添加--ignore-installed選項。

Cannot remove entries from nonexistent file: easy-install.pth

Cannot remove entries from nonexistent file <path-to-anaconda-instalation>/anaconda[version]/lib/site-packages/easy-install.pth

1. 升級安裝工具：pip install --upgrade -I setuptools

2. 安裝TensorFlow再添加--ignore-installed選項：pip install --ignore-installed --upgrade <tensorflow_url>

步驟1可能已經解決了問題，但如果問題仍然存在，請執行步驟2。

在 Linux 上

如果出現錯誤:

...
 "__add__", "__radd__",
             ^
SyntaxError: invalid syntax

解決方案: 確認正在使用的 Python 版本為 Python 2.7.

在 Mac OS X 上

如果出現錯誤:

import six.moves.copyreg as copyreg
ImportError: No module named copyreg

解決方案: TensorFlow 使用的 protobuf 依賴 six-1.10.0. 但是, Apple 的默認 python 環境 已經安裝了 six-1.4.1, 該版本可能很難升級. 這里提供幾種方法來解決該問題:

• 升級全系統的 six:

$ sudo easy_install -U six

• 通過隔離環境安裝TensorFlow:

使用VIRTUALENV或者使用Docker安裝。

• 通過Homebrew或 MacPorts安裝隔離的Python環境，并在該版本的Python中重新安裝TensorFlow。

3. 基本用法

使用 TensorFlow, 你必須明白 TensorFlow:

• 使用圖(graph)來表示計算任務

• 在被稱之為會話(Session)的上下文(context)中執行圖

• 使用 tensor 表示數據

• 通過變量(Variable)維護狀態

• 使用feed和fetch可以為任意的操作(arbitrary operation)賦值或者從其中獲取數據

概述

TensorFlow是一個編程系統，使用圖(graph)來表示計算任務。圖中的節點稱為op（operation）。一個op取零個或多個Tensors來執行計算，并產生零個或多個Tensors。在TensorFlow術語中，一個Tensor是一個類型化的多維數組。例如，您可以將一小組的圖像表示為一個4維的浮點數數組，這4個維度分別是[batch, height, width, channels]。

一個TensorFlow圖(graph)描述了計算的過程。為了進行計算圖(graph)必須在會話(Session)中啟動。一個會話(Session)將圖(graph)的ops分發到諸如GPUs或者CPUs的設備上，同時提供執行op的方法。這些方法后，將產生的tensor返回。在Python中，返回的tensor是numpy的ndarry對象；在C或者C++中，返回的tensor是tensorflow::Tensor 實例。

計算圖(graph)

TensorFlow 程序通常被組織成一個構建階段和一個執行階段。 在構建階段，op的執行步驟被描述成一個圖(graph)，在執行階段, 使用會話執行執行圖中的op。

例如, 通常在構建階段創建一個圖(graph)來表示和訓練神經網絡, 然后在執行階段反復執行圖(graph)中的訓練op。

TensorFlow支持C，C++，Python編程語言。目前，TensorFlow的Python 庫更加易用，它提供了大量的輔助函數來簡化構建圖的工作，但這些函數尚未被C和C++庫支持。

三種語言的會話庫(session libraries)是一樣的。

構建圖(graph)

構建圖(graph)的第一步是創建一個不需要任何輸入的源op，力圖常量(constant)。源op的輸出傳遞給其它op進行計算。

Python庫中的op構造函數返回表示構造的ops的輸出的對象。您可以將這些作為輸入傳遞給其他op構造函數。

Python的TensorFlow庫有一個默認圖(default graph)，op構造器可以為其增加節點。這個默認圖對許多程序來說已經足夠用了。閱讀Graph類文檔來了解如何管理多個圖。

import tensorflow as tf

# Create a constant op that produces a 1x2 matrix.  The op is
# added as a node to the default graph.
#
# The value returned by the constructor represents the output
# of the constant op.
matrix1 = tf.constant([[3., 3.]])

# Create another constant that produces a 2x1 matrix.
matrix2 = tf.constant([[2.],[2.]])

# Create a matmul op that takes 'matrix1' and 'matrix2' as inputs.
# The returned value, 'product', represents the result of the matrix
# multiplication.
product = tf.matmul(matrix1, matrix2)

上述默認圖現在有三個節點：兩個常量(constant)op, 和一個矩陣乘法(matmul)op。為了真正進行矩陣相乘運算，并得到矩陣乘法的結果，你必須在會話里啟動這個圖。

在一個會話(Session)中啟動圖(graph)

構造階段完成后，才能啟動圖。啟動圖的第一步是創建一個Session對象，如果無任何創建參數，會話構造器將啟動默認圖。

欲了解完整的會話 API，請閱讀Session類。

# Launch the default graph.
sess = tf.Session()

# To run the matmul op we call the session 'run()' method, passing 'product'
# which represents the output of the matmul op.  This indicates to the call
# that we want to get the output of the matmul op back.
#
# All inputs needed by the op are run automatically by the session.  They
# typically are run in parallel.
#
# The call 'run(product)' thus causes the execution of three ops in the
# graph: the two constants and matmul.
#
# The output of the matmul is returned in 'result' as a numpy `ndarray` object.
result = sess.run(product)
print(result)
# ==> [[ 12.]]

# Close the Session when we're done.
sess.close()

Session對象在使用完后需要關閉以釋放資源。除了顯式調用close外，也可以使用with語句來自動完成關閉動作。

with tf.Session() as sess:
  result = sess.run([product])
  print(result)

在實現上，TensorFlow將圖(graph)定義轉換成分布式執行的操作，以充分利用可用的計算資源(如CPU或GPU)。一般你不需要顯式指定使用CPU還是GPU，TensorFlow能自動檢測。如果檢測到GPU，TensorFlow會盡可能地利用找到的第一個GPU來執行操作。

如果機器上有超過一個可用的GPU，除第一個外的其它GPU默認是不參與計算的。為了讓TensorFlow使用這些GPU，你必須將op明確指派給它們執行。with...Device語句用來指派特定的CPU或GPU執行操作:

with tf.Session() as sess:
  with tf.device("/gpu:1"):
    matrix1 = tf.constant([[3., 3.]])
    matrix2 = tf.constant([[2.],[2.]])
    product = tf.matmul(matrix1, matrix2)
    ...

設備用字符串進行標識。目前支持的設備包括：

• "/cpu:0"：機器的CPU
• "/gpu:0"：機器的第一個 GPU，如果有的話
• "/gpu:1"：機器的第二個 GPU，以此類推

閱讀使用GPU章節，了解TensorFlow GPU使用的更多信息。

在分布式會話(Session)中啟動圖(graph)

要創建TensorFlow集群，請啟動集群中的每臺計算機上TensorFlow服務器。當您在客戶端中實例化一個會話(Session)時，可以將其中一臺機器的網絡位置傳遞給集群：

with tf.Session("grpc://example.org:2222") as sess:
  # Calls to sess.run(...) will be executed on the cluster.
  ...

則該機器成為會話(Session)的主機。主人在集群（工作人員）中的其他機器上分發圖(graph)，就像利用本地機器的可用計算資源來實現圖(graph)。

您可以使用“with tf.device（）：”語句直接指定圖形中指定部分的工作人員：

with tf.device("/job:ps/task:0"):
  weights = tf.Variable(...)
  biases = tf.Variable(...)

有關分布式會話和集群的更多信息，請參閱TensorFlow分布式會話和集群。

交互式使用

文檔中的Python示例使用一個會話Session來啟動圖，并調用Session.run()方法執行操作。

為了便于使用諸如IPython之類的Python交互環境，可以使用InteractiveSession代替Session類, 使用Tensor.eval()和Operation.run()方法代替Session.run()。這樣就可以避免使用一個變量來保存會話。

# Enter an interactive TensorFlow Session.
import tensorflow as tf
sess = tf.InteractiveSession()

x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])

# Initialize 'x' using the run() method of its initializer op.
x.initializer.run()

# Add an op to subtract 'a' from 'x'.  Run it and print the result
sub = tf.sub(x, a)
print(sub.eval())
# ==> [-2. -1.]

# Close the Session when we're done.
sess.close()

Tensor

TensorFlow程序使用tensor數據結構來代表所有的數據，計算圖(graph)的時候，操作間傳遞的數據都是tensor。你可以把TensorFlow的tensor 看作是一個n維的數組或列表。一個tensor包含一個靜態類型rank和一個shape。想了解TensorFlow關于這些概念的信息，參見Rank，Shape和Type。

變量(Variables)

變量(Variables)保持圖(graph)執行過程中的狀態。下面的例子演示了如何使用變量(Variables)實現一個簡單的計數器。參見變量(Variables)章節了解更多細節。

# Create a Variable, that will be initialized to the scalar value 0.
state = tf.Variable(0, name="counter")

# Create an Op to add one to `state`.

one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)

# Variables must be initialized by running an `init` Op after having
# launched the graph.  We first have to add the `init` Op to the graph.
init_op = tf.global_variables_initializer()

# Launch the graph and run the ops.
with tf.Session() as sess:
  # Run the 'init' op
  sess.run(init_op)
  # Print the initial value of 'state'
  print(sess.run(state))
  # Run the op that updates 'state' and print 'state'.
  for _ in range(3):
    sess.run(update)
    print(sess.run(state))

# output:

# 0
# 1
# 2
# 3

代碼中assign()操作是圖(graph)所描繪表達式的一部分, 正如add()操作一樣。所以在調用run()執行表達式之前，它并不會真正執行賦值操作。

通常會將一個統計模型中的參數表示為一組變量。例如，你可以將一個神經網絡的權重作為某個變量存儲在一個tensor中。在訓練過程中，通過重復運行訓練圖，更新這個tensor.

Fetch

為了獲取操作的輸出內容，可以在使用Session對象的run()調用執行圖時，傳入一些tensor，這些tensor會幫助你獲取結果。在之前的例子里，我們只取回了單個節點state，但是你也可以取回多個tensor：

input1 = tf.constant([3.0])
input2 = tf.constant([2.0])
input3 = tf.constant([5.0])
intermed = tf.add(input2, input3)
mul = tf.mul(input1, intermed)

with tf.Session() as sess:
  result = sess.run([mul, intermed])
  print(result)

# output:
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]

需要獲取的多個tensor值，在op的一次運行中會一起獲得（而不是逐個去獲取tensor）。

Feed

上述示例在計算圖中引入了tensor，以常量或變量的形式存儲。TensorFlow還提供了feed機制，該機制可以臨時替代圖(graph)中的任意操作中的tensor，可以對圖(graph)中任何操作提交補丁，直接插入一個tensor。

feed使用一個tensor值臨時替換一個操作的輸出結果。你可以提供feed數據作為run()調用的參數。feed只在調用它的方法內有效。方法結束，feed就會消失。最常見的用例是將某些特殊的操作指定為feed操作，標記方法是使用tf.placeholder()為這些操作創建占位符。

input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.mul(input1, input2)

with tf.Session() as sess:
  print(sess.run([output], feed_dict={input1:[7.], input2:[2.]}))

# output:
# [array([ 14.], dtype=float32)]

如果沒有正確提供feed，placeholder()操作將會產生錯誤。MNIST完全連接feed教程(source code) 給出了一個大規模的使用feed的例子。