TensorFlow下载安装&入门教程

介绍

TensorFlow™ 是一个采用数据流图（data flow graphs），用于数值计算的开源软件库。TensorFlow 最初由Google大脑小组（隶属于Google机器智能研究机构）的研究员和工程师们开发出来，用于机器学习和深度神经网络方面的研究，但这个系统的通用性使其也可广泛用于其他计算领域。它是谷歌基于DistBelief进行研发的第二代人工智能学习系统。2015年11月9日，Google发布人工智能系统TensorFlow并宣布开源。

TensorFlow名字的来源

其命名来源于本身的原理，Tensor（张量）意味着N维数组，Flow（流）意味着基于数据流图的计算。Tensorflow运行过程就是张量从图的一端流动到另一端的计算过程。张量从图中流过的直观图像是这个工具取名为“TensorFlow”的原因。

什么是数据流图（Data Flow Graph）？

数据流图用“节点”(nodes)和“线”（edges）的有向图来描述数学计算。“节点”一般用来表示施加的数学操作，但也可以表示数据输入（feed in）的起点/输出（push out）的终点，或者是读取/写入持久变量（persistent variable）的终点。“线”表示“节点”之间的输入/输出关系。这些数据“线”可以运输“size可动态调整”的多维数组，即“张量”（tensor）。一旦输入端所有张量准备好，节点将被分配到各种计算设备完成异步并行地执行计算。

Tensorflow的特性

• 高度的灵活性： TensorFlow不是一个严格的“神经网络”库。只要你可以将你的计算表示为一个数据流图，你就可以使用TensorFlow。

• 可移植性（Portability）：Tensorflow可以运行在台式机、服务器、手机移动等等设备上。而且它可以充分使用计算资源，在多CPU和多GPU上运行。

• 多语言支持：Tensorflow提供了一套易用的Python使用接口来构建和执行graphs，也同样提供了一套易于C++使用的接口（目前训练神经网络只支持python，C++接口只能使用已经训练好的模型）。未来还会支持Go、Java、Lua、JavaScript、R等等。

• 性能最优化：TensorFlow给予了线程、队列、异步操作等最佳的支持，TensorFlow可以把你手边硬件的计算潜能全部发挥出来，它可以充分利用多CPU和多GPU。

下载及安装

既可以直接使用二进制程序包也可以从github源码库克隆源码编译安装。

要求 
TensorFlow 提供的Python API支持Python2.7和Python3.3+

GPU版本的二进制程序包只能使用Cuda Toolkit8.0 和 cuDNN v5。如果你使用的是其他版本（Cuda toolkit >= 7.0 and cuDNN >= v3），那你就必须使用源码重新编译安装。

推荐几种Linux平台的安装方式：

• Pip install： 可能会升级你之前安装过的Python包，对你机器上的Python程序造成影响。
• Anaconda install：把TensorFlow安装在Anaconda提供的环境中，不会影响其他Python程序。
• Installing from sources：把TensorFlow源码构建成一个pip wheel 文件，使用pip工具安装它。

Pip installation 
Pip是一个用来安装和管理Python软件包的包管理系统。

安装pip（如果已经安装，可以跳过） 
# Ubuntu/Linux 64-bit

$ sudo apt-get install python-pip python-dev
 
 
1
 
 
1

直接使用pip安装TensorFlow

$ pip install tensorflow
 
 
1
 
 
1

如果提示找不到对应的包，使用

pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.12.0rc1-cp27-none-linux_x86_64.whl
 
 
1
 
 
1

安装GPU支持的版本： 
# Requires CUDA toolkit 8.0 and CuDNN v5. 其他版本，参考下面的 “Installing from sources”

$ pip install tensorflow-gpu
 
 
1
 
 
1

如果提示找不到对应的包，使用

pip install --ignore-installed --upgrade TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-0.12.0rc1-cp27-none-linux_x86_64.whl
 
 
1
 
 
1

注意：如果是从一个较老的版本（TensorFlow<0.7.1）进行升级，需要首先卸载之前的TensorFlow和protobuf使用：pip uninstall

Anaconda installation 
Anaconda是一个Python发行版，包括大量的数字和科学计算包。使用“conda”来管理软件包，并且拥有自己的环境系统。安装步骤 
安装Anaconda 
创建conda环境 
激活conda环境，在其中安装TensorFlow 
每次使用TensorFlow时，激活conda环境

Anaconda具体的安装和使用可以参考：https://www.continuum.io/downloads

Installing from sources

从源码构建TensorFlow，具体的步骤参考：http://blog.csdn.net/toormi/article/details/52904551#t8

基本使用

基本概念

使用TensorFlow前必须明白的基本概念： 
图（Graph）：图描述了计算的过程，TensorFlow使用图来表示计算任务。 
张量（Tensor）：TensorFlow使用tensor表示数据。每个Tensor是一个类型化的多维数组。 
操作（op）：图中的节点被称为op（opearation的缩写），一个op获得0个或多个Tensor，执行计算，产生0个或多个Tensor。 
会话（Session）：图必须在称之为“会话”的上下文中执行。会话将图的op分发到诸如CPU或GPU之类的设备上执行。 
变量（Variable）：运行过程中可以被改变，用于维护状态。

计算图（The computation graph）

Tensorflow程序通常被组织成一个构建阶段和一个执行阶段。在构建阶段，op的执行步骤被描述成一个图。在执行阶段，使用会话执行图中的op。

构建图

构建图的第一步是创建源op（sources op）。源op不需要任何输入，例如常量（Constant）。源op的输出被传递给其他op做运算。

在TensorFlow的Python库中，op构造器的返回值代表这个op的输出。这些返回值可以作为输入传递给其他op构造器。

TensorFlow的Python库中包含了一个默认的graph，可以在上面使用添加节点。如果你的程序需要多个graph那就需要使用Graph类管理多个graph。

import tensorflow as tf

# 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点
# 加到默认图中.
#
# 构造器的返回值代表该常量 op 的返回值.
matrix1 = tf.constant([[3., 3.]])

# 创建另外一个常量 op, 产生一个 2x1 矩阵.
matrix2 = tf.constant([[2.],[2.]])

# 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
# 返回值 'product' 代表矩阵乘法的结果.
product = tf.matmul(matrix1, matrix2)
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

默认图中包含了3个节点：两个constant() op和一个matmul() op。为了真正的执行矩阵相乘运算，并得到矩阵乘法的结果，你必须在会话中启动这个图。

启动图

构造阶段完成后，才能在会话中启动图。启动图的第一步是创建一个Session对象。如果没有任何参数，会话构造器将启动默认图。

# 启动默认图.
sess = tf.Session()

# 调用 sess 的 'run()' 方法来执行矩阵乘法 op, 传入 'product' 作为该方法的参数.
# 上面提到, 'product' 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回
# 矩阵乘法 op 的输出.
#
# 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.
#
# 函数调用 'run(product)' 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.
#
# 返回值 'result' 是一个 numpy `ndarray` 对象.
result = sess.run(product)
print result
# ==> [[ 12.]]

# 任务完成, 关闭会话.
sess.close()
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Session对象在使用完成或需要关闭以释放资源。除了显示调用close外，也可以使用“with”代码块来自动完成关闭动作。

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

Tensorflow的实现上，会把图转换成可分布式执行的操作，以充分利用计算资源（例如CPU或GPU）。通常情况下，你不需要显示指使用CPU或者GPU。TensorFlow能自动检测，如果检测到GPU，TensorFlow会使用第一个GPU来执行操作。

如果机器上有多个GPU，除第一个GPU外的其他GPU是不参与计算的，为了使用这些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)
...
 
 
1
2
3
4
5
6
 
 
1
2
3
4
5
6

设备用字符串进行标识. 目前支持的设备包括: 
“/cpu:0”: 机器的 CPU. 
“/gpu:0”: 机器的第一个 GPU, 如果有的话. 
“/gpu:1”: 机器的第二个 GPU, 以此类推.

Tensor

Tensorflow使用tensor数据结构来代表所有的数据。计算图的操作之间仅能传递tensor。你可以把tensor当作多维数组或列表。每一个tensor包含有一个静态类型，一个rank和一个shape。想了解更多TensorFlow是如何操作这些概念的，参考Rank, Shape, and Type

变量

变量维持图计算过程中的状态信息。下面的例子演示了如何使用变量作为一个简单的计数器。

# 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

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

通常可以将一个统计模型中的参数表示为一组变量。例如，你可以将一个神经网络的权重当作一个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

# 输出:
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]
 
 
1
2
3
4
5
6
7
8
9
10
11
12
 
 
1
2
3
4
5
6
7
8
9
10
11
12

需要获取的多个 tensor 值，在 op 的一次运行中一起获得（而不是逐个去获取 tensor）。

Feed

上面的例子中展示了在计算图中引入tensor，以常量和变量的形式存储。TensorFlow还提供了feed机制，该机制可以临时替换图中的tensor。

feed使用一个tensor值临时替换一个操作的输出。可以把feed数据作为参数提供给run()方法。标记的方法是使用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.]})

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

机器学习的敲门砖：手把手教你TensorFlow初级入门
摘要： 在开始使用机器学习算法之前，我们应该首先熟悉如何使用它们。而本文就是通过对TensorFlow的一些基本特点的介绍，让你了解它是机器学习类库中的一个不错的选择。
本文由北邮@爱可可-爱生活 老师推荐，阿里云云栖社区组织翻译。
以下为译文：

在开始使用机器学习算法之前，我们应该首先熟悉如何使用它们。 而本文就是通过对TensorFlow的一些基本特点的介绍，让你了解它是机器学习类库中的一个不错的选择。
让我们设想一下，当我们用Python写代码时，没有那些方便的类库会是怎样一种窘境。 这就好比你有一个新的智能手机，而不安装任何应用程序。 虽然它仍然可以打电话，发短信，但如果有了那些更方便的应用程序，这部智能手机才更有价值。

设想一下这个场景...你作为一名业务负责人，需要负责跟踪销售流程。 你希望计算销售产品的收入。 现在有100个不同的产品在你的仓库中，你需要用一个向量表示每个产品的价格。 另一个大小为100的向量表示每个产品的库存量。 以下的Python代码是用来计算销售所有产品的收入。注意了， 这里没有调用任何类库。
 
 
revenue = 0
for price,amount in zip(prices, amounts):
    revenue += price * amount
代码列表1.不使用任何Python类库计算两个向量的内积

这段代码只是计算两个向量（也称为点积）的内积。 想象一下，对于更复杂的问题，需要多少代码。例如求解线性方程或计算两个向量之间的距离。
 
当你安装TensorFlow类库的同时，其中还包括了非常知名的NumPy类库，对Python编程中的数学操作非常有用。用Python编程时，不使用类库（例如NumPy和TensorFlow）就像使用没有自动对焦的相机：你虽然获得了更多的灵活性，但你可能很容易犯错。在机器学习的过程中已经很容易犯错误了，所以就让我们使用TensorFlow来提高化软件开发的效率吧。
 
代码列表2展示了如何使用NumPy简洁地编写相同的内积运算。
 
import numpy asnp
revenue =np.dot(prices, amounts)
代码列表2.用NumPy类库计算内积

Python是一种简洁的语言，这意味着你不会看到冗长的代码。另一方面，Python语言的简洁意味着许多处理都在后台进行，因此我们应该熟悉它背后的原理。

关于TensorFlow的Python和C ++ API的各种函数的详细文档，请参见https://www.tensorflow.org/api_docs/index.html。
 
机器学习主要依赖于很多数学公式，本文将对使用TensorFlow进行这类数学运算做一个初步的介绍。通过示例和代码，大家可以对TensorFlow有一个初步了解。例如如何运用TensorFlow计算大数据的统计信息。 因此本文的重点将完全是关于如何使用TensorFlow，而不是一般的机器学习算法运用。
机器学习算法需要大量的数学运算。 通常，某个算法可以归结为简单函数组合的迭代，直到它收敛为止。 当然，也可以使用任何标准编程语言来执行这些计算。但是使用像TensorFlow这样已经非常完善了的类库是提高代码可控性和性能的关键。
1．确保TensorFlow工作
首先，为我们的第一段代码创建一个名为test.py的新文件。 通过运行以下代码导入TensorFlow：
importtensorflow as tf

在导入TensorFlow后，如果Python解释器没有报错，那么我们就可以开始使用TensorFlow了。

遇到了错误？ 在这里，常见错误的原因是你可能安装了GPU版本，并且类库无法搜索CUDA驱动程序。 请记住，如果使用CUDA编译库，则需要使用CUDA的路径更新环境变量。 你需要检查TensorFlow上的CUDA指令。 （有关详情，请参阅https://www.tensorflow.org/versions/master/get_started/os_setup.html#optional-linux-enable-gpu-support）。
2．使用TensorFlow中的规则
TensorFlow库通常使用tf限定名称来进行导入。 一般来说，使用tf限定名称是一个不错的方法，以便与其他开发人员和开源TensorFlow项目保持一致。 你也可以选择不使用这个限定名称，但这会影响你在自己的项目中重用别人的TensorFlow代码。
3．表示张量
在现实世界中描述对象的一个简便方法就是通过罗列出它的属性或特征。例如，我们可以通过颜色，型号，发动机类型和里程数描述一辆汽车。这些特征的有序列表被称为特征向量，这正是我们要在TensorFlow代码中所表示的。
特征向量是机器学习中最有用的方法之一，（它们就是一个数字列表）。每个数据项通常有一个特征向量，而一个好的数据集则具有数千个特征向量。 毫无疑问，你会经常一次处理多个向量。 矩阵简明地表示了向量列表，其中矩阵的每列表示一个特征向量。
在TensorFlow中用向量的向量表示矩阵，每个向量具有相同的长度。 图1是一个两行三列的矩阵的示例，例如[[1,2,3]，[4,5,6]]。 注意，这是一个包含两个元素的向量，每个元素对应一个矩阵行。
 
图1.图上半部分是计算机对矩阵的表示，下半部分是我们日常生活中对矩阵的表示。 这种形式的符号是大多数科学计算类库中的常见范例。
我们通过指定其行和列索引来定位矩阵中的元素。 例如，第一行和第一列来表示左上角第一个元素。 有时，我们需要使用两个以上的索引，这样来表示一个元素会很方便。例如，在表示一个图片中的像素时，我们不仅通过其行和列值来描述它，而且还使用红，绿，蓝通道来对其进行描述。 张量是通过任意数量的索引指定矩阵中元素的一般化。
一个张量的例子...假设一所小学为每个学生分配座位。 而你是这个学校的校长，并且你记不住这些学生的名字。 幸运的是，每个教室都有一个座位网格，可以通过学生的行和列来指定某个学生。
 
因为有多个教室，所以你不能简单的说“早上好，4排10列！”你还需要指定教室，比如说“你好， 教室2的4排10列”。不像矩阵只需要两个索引就能指定一个元素，这所学校的学生需要三个数字。 这三个数字都是三阶张量的一部分！
 
张量是更多的嵌套向量。例如，一个2×3×2的张量为[[[1,2]，[3,4]，[5,6]]，[[7,8]，[9,10]11,12]]]，它可以被认为是两个矩阵，每个大小为3×2。 因此，我们说这个张量的秩是3.一般来说，张量的秩是指定一个元素所需的索引的数量。 TensorFlow中的机器学习算法是作用于张量上的，理解如何使用它们是关键。
 
图2.该张量可以被认为是堆叠在彼此之上的多个矩阵。 要指定其中的某个元素，必须指明行和列，以及要访问的矩阵。 因此，该张量的秩为三。

你可能会对如何表示张量产生疑惑。下面三行代码试图表示相同的2×2矩阵。 该矩阵表示两个维度的两个特征向量。 例如，它可以表示两个人对两部电影的评价。 每个人，由矩阵的行索引表示，分配一个数字来描述每个人的电影评价值，由列索引表示。 运行代码以了解如何在TensorFlow中生成矩阵。
importtensorflow as tf
# We’ll useNumPy matrices in TensorFlow
import numpy asnp  
# Define a 2x2matrix in 3 different ways
m1 = [[1.0,2.0],
      [3.0, 4.0]]
m2 =np.array([[1.0, 2.0],
               [3.0, 4.0]], dtype=np.float32)
m3 =tf.constant([[1.0, 2.0],
                  [3.0, 4.0]])
 
# Print the typefor each matrix
print(type(m1))
print(type(m2))
print(type(m3))
 
# Create tensorobjects out of the different types
t1 =tf.convert_to_tensor(m1, dtype=tf.float32)
t2 =tf.convert_to_tensor(m2, dtype=tf.float32)
t3 =tf.convert_to_tensor(m3, dtype=tf.float32)
 
# Notice thatthe types will be the same now
print(type(t1))
print(type(t2))
print(type(t3))
代码列表3.表示张量的不同方式

 
第一个变量m1是一个列表，第二个变量m2是NumPy类库中的一个ndarray，最后一个变量m3是TensorFlow的Tensor对象。TensorFlow中所有运算符（如neg）都设计为对张量对象进行操作。tf.convert_to_tensor（...）这个方法，我们可以用在任何地方，以确保我们处理张量而不是其他类型。TensorFlow类库中的大多数方法都已经调用了它。使用tf.convert_to_tensor（...）并不是必须的，在这里使用它，是因为它有助于我们理解隐式类型的跨类库处理。
 
<class‘tensorflow.python.framework.ops.Tensor’>
 
让我们再来看看如何中定义张量。 导入TensorFlow类库之后，我们可以使用常量运算符，如代码列表4所示。


importtensorflow as tf
# Define a 2x1matrix
matrix1 =tf.constant([[1., 2.]])
# Define a 1x2matrix
matrix2 =tf.constant([[1],
                       [2]])
# Define a rank3 tensor
myTensor =tf.constant([ [[1,2],
                          [3,4],
                          [5,6]],
                         [[7,8],
                          [9,10],
                          [11,12]] ])
# Try printingthe tensors
print(matrix1)
print(matrix2)
print(myTensor)
代码列表4。创建张量

代码4的运行结果：
 
Tensor(“Const:0”,
        shape=TensorShape([Dimension(1),
                           Dimension(2)]),
        dtype=float32 )
Tensor(“Const_1:0”,
        shape=TensorShape([Dimension(2),
                           Dimension(1)]),
        dtype=int32 )
Tensor(“Const_2:0”,
         shape=TensorShape([Dimension(2),
                            Dimension(3),
                            Dimension(2)]),
         dtype=int32 )

从运行结果中可以看出，每个张量都由已命名的Tensor对象表示。每个Tensor对象都有一个唯一的标签（名称），一个用于定义其结构的维度（shape），以及用于指定我们要操作的数据类型（dtype）。因为我们并没有显示指定名称，所以他们被自动命名为：“Const：0”，“Const_1：0”和“Const_2：0”。

4．张量类型
需要注意的是matrix1的每个元素以小数点结束，这是为了告诉Python该元素的数据类型不是整数，而是浮点数。 我们可以传递显式dtype值。 和NumPy数组一样，张量可以接受我们指定的类型。
 
TensorFlow也提供了一些构造函数用于一些简单的张量。例如，tf.zeros（shape）创建了一个包涵所有值都被初始化为零的特定形态的张量。类似地，tf.ones（shape）创建了一个所有元素值为1的张量。 shape参数是描述张量的维度的一维张量，它的类型是int32。
 
5．创建运算符
我们已经有了几个初始的张量，现在我们可以用运算符对他们进行操作，比如加减乘除。 假设现在有一个矩阵，它的行表示货币交易，收款金额（正值）和收款金额（负值）。 矩阵取反是表示某个人的货币流历史记录的一种方式。 我们现在对代码列表4中的matrix1进行取反操作neg（negation的缩写）。矩阵取反将正数转换为绝对值相同的负数，反之亦然。
取反操作是最简单的操作之一。 如代码列表5所示，取反只需将一个张量作为输入，得出另一个张量，每个元素取反。现在，尝试自己运行代码。 如果你已经掌握了如何使用取反，那就可以推广到所有其他TensorFlow的操作。
 
这里需要指出，定义操作（如取反操作）和运行它是不一样的。
 
importtensorflow as tf
 
# Define anarbitrary tensor
x =tf.constant([[1, 2]])
 
# Negate thetensor
neg_x =tf.neg(x)
 
# Print theobject
print(neg_x)
代码列表5. 取反运算符的使用
 
代码列表5的输出：
 
Tensor(“Neg:0”,shape=(1, 2), dtype=int32)
 
更多TensorFlow的运算符
 
官方文档详细地列出了所有可用的数学操作：
https：//www.tensorflow.org/api_docs/Python/math_ops.html。

常用操作符的示例包括：

tf.add(x, y)
Add two tensorsof the same type, x + y
tf.sub(x, y)
Subtract tensorsof the same type, x — y
tf.mul(x, y)
Multiply twotensors element-wise
tf.pow(x, y)
Take theelement-wise power of x to y
tf.exp(x)
Equivalent topow(e, x), where e is Euler’s number (2.718…)
tf.sqrt(x)
Equivalent topow(x, 0.5)
tf.div(x, y)
Take theelement-wise division of x and y
tf.truediv(x, y)
Same as tf.div,except casts the arguments as a float
tf.floordiv(x,y)
Same as truediv,except rounds down the final answer into an integer
tf.mod(x, y)
Takes theelement-wise remainder from division
我们可以这些TensorFlow运算符来产生高斯分布（也称为正态分布）。参见图3提示。你可以参考wiki，找到正态分布的概率密度：
https：//en.wikipedia.org/wiki/Normal_distribution。
为了简洁起见，诸如“*”，“ - ”，“+”等大多数数学表达式是其TensorFlow运算符的快捷方式。高斯函数包括许多运算，如下所示：
from math importpi
mean = 1.0
sigma = 0.0
(tf.exp(tf.neg(tf.pow(x— mean, 2.0) /
               (2.0 * tf.pow(sigma, 2.0) ))) *
(1.0 / (sigma *tf.sqrt(2.0 * pi) )))



 
 
图3.该图表示产生高斯分布所需的操作。 节点之间的链接表示数据如何从一个操作进入下一个操作。 操作本身很简单，但是它们如何相互作用是相对复杂的。
 
TensorFlow算法很容易可视化。 它们可以用流程图来进行描述。 流程图就是一种图表。 流程图中的每个箭头都称为图形的边。 而它的每个状态被称为节点。
 
6．在会话中执行运算符
会话(session)是描述代码应该如何运行的软件系统环境。在TensorFlow中，会话设置了硬件设备（如CPU和GPU）如何相互通信。这样，你只要关心如何设计机器学习算法，而不必担心底层硬件设备的运行。当然，你也可以配置会话以更改其底层硬件设备交互行为，而不更改上层代码。
要在TensorFlow中运行程序计算数值是需要一个会话的。 只有在已创建的会话才可以对Tensor对象进行赋值。 为此，我们必须使用tf.Session（）创建一个会话类，并由它来运行一个运算符（代码列表6）。
importtensorflow as tf
 
# Define anarbitrary matrix
matrix = tf.constant([[1.,2.]])
 
# Run thenegation operator on it
neg_matrix =tf.neg(matrix)
 
# Start asession to be able to run operations
withtf.Session() as sess:
    # Tell the session to evaluate negMatrix
    result = sess.run(neg_matrix)
 
# Print the resultingmatrix
print(result)
代码列表6.使用会话
恭喜！ 你刚刚写了第一个完整的TensorFlow代码。 尽管它所做的是只是对一个矩阵进行取反，但它已经能充分体现TensorFlow中的核心概念与框架了。
 
7．会话配置
在创建tf.Session类时，我们可以向构造函数传递一些参数。例如，TensorFlow会根据可用的内容自动确定为指定GPU或CPU设备的最佳方式。在创建会话时，我们可以设置log_device_placements = True，如代码列表7所示。
importtensorflow as tf
 
# Define amatrix and negate it
matrix =tf.constant([[1., 2.]])
negMatrix =tf.neg(matrix)
 
# Start thesession with a special config passed into the constructor to enable logging
withtf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
    # Evaluate negMatrix
    result = sess.run(negMatrix)
 
# Print theresulting value
print(result)
代码列表7 登录一个会话
这将输出有关每个操作的会话中使用哪些CPU / GPU设备的信息。 例如，执行代码列表6中的程序会有以下输出，它显示了用于运行取反操作的设备：
Neg:/job:localhost/replica:0/task:0/cpu:0
 
会话在TensorFlow中是必不可少的。 我们需要调用一个会话来执行数学操作。 图4描述了TensorFlow上的不同组件如何与机器学习管道的交互。 会话不仅执行图像操作，而且还可以使用占位符，变量和常量作为输入。 到目前为止，我们已经使用了常量，但在后面的部分，我们将开始使用变量和占位符。 以下是这三种类型值的简要概述。
•占位符：未分配的值，但将由运行的会话初始化。
•变量：可以更改的值，例如机器学习模型的参数。
•常数：不更改的值，例如超参数或设置。
 
图4.会话指示如何使用硬件来最有效地处理图形。 当会话开始时，它将CPU和GPU设备分配给每个节点。 在处理之后，会话用可用格式（例如NumPy数组）输出数据。 会话可以接受占位符，变量和常量。
 
我希望你通过本文已经熟悉了一些TensorFlow编程的基本方法。 如果这篇文章让你对TensorFlow 产生了兴趣，请下载Machine Learning with TensorFlow的第一章，从中了解更多内容。
 
文章原标题《Getting to Know TensorFlow》，作者：Nishant Shukla
文章为简译，更为详细的内容，请查看原文