anaconda 安装tensorflow_深度学习与TensorFlow模型设计-TensorFlow入门

TensorFlow入门

随着深度学习技术的发展，已有数种深度学习框架，例如TensorFlow、Caffe、Caffe2、Theano、Torch、MXNet和CNTK，支持卷积神经网络、递归神经网络等模型结构。TensorFlow由Google Brain团队的研究员和工程师研发，已成为业界最受欢迎的机器学习项目。TensorFlow框架的优秀特性，主要包括：

• 支持异构设备的分布式计算，可有效地利用机器资源进行模型训练。
• 支持卷积、循环神经等网络结构，这些都是在计算机视觉、语音识别、自然语言处理方面最流行的深度神经网络。
• 支持模型从研究团队到生产环境的快速迁移，构建起模型研究到生产使用的桥梁。
• 支持移动端开发，及智能终端产品的嵌入式开发。
• 具备出色的版本管理和详细的官方文档，模型众多，生态系统比较完备。
• 本章主要讲解TensorFlow框架的入门知识，包括开发环境的构建、编程接口、程序架构、图及会话等知识。

TensorFlow介绍

“工欲善其事，必先利其器”，学习TensorFlow这样一个深度学习框架，需要哪些学习资源呢？读者可参考TensorFlow官方网站、源码实现和开源模型，如下所示：

• TensorFlow官方网站（https://www.tensorflow.org），如图 1-1所示。

图 1-1‑1 TensorFlow官方网站

Install介绍了Ubuntu、macOS、Windows系统下的安装流程。Develop介绍了应用开发接口及相关程序示例。Community介绍了TensorFlow社区及发展路线。API介绍了Python、C++、Java等TensorFlow编程接口。Resources介绍了TensorFlow Hub等周边生态环境。

• TensorFlow GitHub源码（https://github.com/tensorflow/tensorflow），如图 1-2所示。在2019年9月，已有64158个commit、40个branch和89个版本的release。

图 1-1‑2 TensorFlow GitHub项目首页

tensorflow是源代码目录，内核采用C/C++开发，提供了C++、Python等语言的开发接口。third_party目录是第三方软件库，包括eigen3、android、grpc、protobuf等。

• TensorFlow模型库（https://github.com/tensorflow/models），如图 1-3所示。在2019年9月，已有3746个commits、123个branch和10个release版本。

图 1-1‑3 TensorFlow模型库首页

official目录是官方的深度学习模型示例。research目录是科学家的研究模型示例，用于完善TensorFlow生态。samples目录中的程序示例用于验证TensorFlow特性。tutorials目录为官网教程的示例代码。

TensorFlow安装

TensorFlow支持Windows、Linux、macOS系统，分为GPU和CPU版本。具体安装流程参见官网中的Install部分。TensorFlow支持多种安装方法，包括pip、docker、Anaconda等。

Anaconda是Python的发行版本，包含了各种Python科学计算包。用户可根据操作系统类型，从网站（https://www.anaconda.com）下载对应的版本。图 1-4为Anaconda的Windows版本，支持Python 3.6和Python 2.7。安装好Anaconda后，在Windows的“开始”菜单中可找到Anaconda选项，如图 1-5所示。如果在国内不能访问Anaconda官网，读者可从清华镜像地址（https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive）下载。

图 1-1‑4 Anaconda的下载界面

图 1-1‑5 Windows版本的Anaconda安装结果

在国内，下载Python工具包的速度很慢，读者可在Anaconda Prompt命令行工具中配置清华大学镜像库，并安装TensorFlow，如下所示：

代码清单 1-1–1  配置Anaconda镜像和安装TensorFlow
# 设置Python的镜像地址
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/

# 显示链接地址
conda config --set show_channel_urls yes

# 安装numpy，验证镜像地址是否配置正确
conda install numpy

# 搜索当前可用的tensorflow版本
anaconda search -t conda tensorflow

# 显示aaronzs/tensorflow安装包的信息 
anaconda show aaronzs/tensorflow

# 执行安装
conda install --channel https://conda.anaconda.org/aaronzs tensorflow

在上述代码中，conda config用于配置镜像库。conda install用于安装Python包。anaconda search用于查询可安装的TensorFlow版本。anaconda show显示安装命令。conda install执行TesnorFlow的安装。

安装TensorFlow时，conda会检测依赖库，比如protobuf、mock等。安装完毕后，进入Python交互式运行环境，输入如下程序示例：

代码清单 1-1–2  输出TensorFlow版本信息
# 导入TensorFlow库
import tensorflow as tf

# 显示当前TensorFlow版本号
tf.__version__

上述代码中，tf.__version__表示TensorFlow版本号。如果程序运行不报错误，表示TensorFlow安装成功。

TensorFlow集成开发环境

PyCharm是Python开发的常用工具，用于模型代码的编写、编译、调试等。PyCharm有Professional和Community两种版本。PyCharm可从官网（https://www.jetbrains.com/pycharm）下载。安装完毕后，新建项目并配置Python解释器，如图 1-6所示。

图 1-1‑6 配置Anaconda的Python解释器

在新建的项目中，创建Python示例程序，输入如下代码：

代码清单 1-1–3  Hello TensorFlow示例
# 导入tensorflow库
import tensorflow  as tf

# 输出TensorFlow版本号
print(tf.__version__)

# 构建一个字符串常量
str = tf.constant('Hello, TensorFlow!')

# 构建TensorFlow会话
sess = tf.Session()

# 运行会话，输出字符串常量
print(sess.run(str))

上述代码中，tf.constant表示构建常量字符串str，sess.run(str)用于获取常量字符串str的值。该程序输出‘Hello，TensorFlow！’，运行结果如图 1-7所示。

图 1-1‑7 在PyCharm中运行TensorFlow示例程序

TensorFlow编程模式

TensorFlow是一种基于图（Graph）的运算引擎，包括图的构建和运行两部分。图的运行环境为Session。图中的节点称为Operation，图中的边为节点间传输的数据，称为Tensor。构建a+b功能的计算图，如下代码所示：

代码清单 1-1–4 TensorFlow图实现a+b功能
# 构建TensorFlow图，实现a+b
import numpy as np
import tensorflow as tf

# 定义常量
a = tf.constant(3.0, dtype=tf.float32)
b = tf.constant(4.0)

# 定义a+b
total = a + b

# 构建会话
sess = tf.Session()

# 运行会话，输出运行结果
print(sess.run(total))

上述代码中，tf.constant用于构建常量节点。a和b为常量节点的输出Tensor，类型为float32。运算符+号表示TensorFlow中的加法操作，返回名为total的Tensor。tf.Session用于构建运行会话。sess.run从下到上触发图中各个节点的运行，返回a+b的运算结果。

a+b的网络结构，如图 1-8所示。其中，Tensor a的名称为Const:0，Tensor b的名称为Const_1:0，Tensor total的名称为add:0。名称中的:0表示节点的第0个输出，

图 1-1‑8 a+b的网络结构

TensorFlow程序结构

TensorFlow程序主要包括模型定义、模型训练、模型评估三个方面，如图 1-9所示。模型通常需要定义参数、网络结构、损失方程等。

参数是模型内部的配置变量。如果为高斯分布模型，参数为高斯分布的平均值和标准差。如果为线性回归模型，参数为线性回归中的回归系数。如果为神经网络模型，参数为神经网络中的权重。模型结构为要实现功能的明确定义，例如神经网络结构、线性回归结构等。

损失方程表示模型预测值与目标值之间的差异程度。回归模型通常采用最小二乘法作为损失方程，分类模型通常采用交叉熵作为损失方程。

模型训练通常采用梯度下降法，沿梯度下降的方向迭代优化损失方程的值。通过不断地训练模型，得到优化后的模型参数。

图 1-1‑9 TensorFlow的程序结构

在训练阶段，首先对训练数据执行预处理操作，然后把预处理后的数据输入到网络结构中，迭代地触发训练操作。在评估阶段，首先加载训练好的模型，执行推理操作，接着计算评估指标，例如模型准确率、召回率等。为了便于理解TensorFlow程序结构，伪代码如下所示：

代码清单 1-1–5 TensorFlow程序结构的伪代码
# 定义模型参数
weights = tf.Variable()
biases = tf.Variable()

# 定义模型输入数据的占位符
images = tf.placeholder()
labels = tf.placeholder()

# 定义模型的网络结构
layer1 = tf.nn.relu(tf.matmul(images, weights) + biases)
logits = tf.matmul(layer1, weights) + biases
correct_prediction=tf.equal(tf.argmax(logits,1),tf.argmax(labels,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

# 定义损失方程，采用softmax交叉熵算法
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits( 
logits, labels, name='xentropy')
loss = tf.reduce_mean(cross_entropy, name='xentropy_mean')

# 定义优化算法及训练操作
optimizer = tf.train.GradientDescentOptimizer(learning_rate)
global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = optimizer.minimize(loss, global_step=global_step)

# 加载训练数据，训练模型
for step in xrange(train_steps):
    feed_dict = { images:images_data, labels:labels_data }
    _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict)

# 加载测试数据，计算精确率
for step in xrange(eval_steps):
    feed_dict = { images:eval_images_data, labels:eval_labels_data }
accuracy_val = sess.run(accuray, feed_dict=feed_dict)

在这段代码中，tf.Variable定义模型变量。tf.placeholder定义数据占位符，用于接收输入数据。tf.nn.relu、tf.matmul等定义网络运算操作。loss表示模型的损失值，Optimizer表示优化器，train_op为训练操作。feed_dict表示要训练的数据。sess.run用于执行模型的训练操作。loss_value表示模型的损失值。sess.run用于计算准确率，accuracy_val表示模型准确率。

TensorFlow线性回归模型

线性回归属于监督型机器学习算法，能够通过数据之间的关系找出数据之间的映射，确定变量间的依赖程度。线性回归在金融领域、经济学领域应用比较广泛，例如根据广告支出来预测产品的销售收入。

如果线性回归中只涉及两个变量，通过自变量x预测应变量y，称为一元线性回归。一元线性回归模型可表示为y = W*x + b，其中W为回归系数，b为偏置项。W为变量x对变量y的影响量，b为其它因素对变量y的影响量。性回归模型通常采用最小平方法最小化目标值与估计值的差值。使用TensorFlow实现一元线性回归模型的程序示例，如下所示：

代码清单 1-1–6 使用TensorFlow实现一元线性回归模型

import tensorflow as tf

# 定义模型变量
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)

# 定义输入数据的占位符
x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)

# 定义线性回归模型
linear_model = W*x + b

# 定义损失方程，采用最小平方法
loss = tf.reduce_sum(tf.square(linear_model - y))

# 定义优化算法及训练操作
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

# 定义训练数据
x_train = [1, 2, 3, 4]
y_train = [0, -1, -2, -3]

# 定义会话，训练模型
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
for i in range(1000):
    sess.run(train, {x: x_train, y: y_train})

# 输出模型参数及损失值
curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))

在这段代码中，w，b为模型参数。x，y为数据占位符，接收自变量与应变量的值。linear_model为一元线性回归模型，loss表示损失方程。optimizer使用梯度下降法，学习率为0.01。x_train与y_train为训练数据。init用于初始化模型参数。sess为TensorFlow会话，用于训练模型。训练1000次迭代后，参数w=-0.999，参数b=0.999。

Tensor创建及使用

TensorFlow中传递的数据称为Tensor，是一个多维矩阵。矩阵的维度大小称为rank，矩阵各维度中元素个数称为shape。Tensor表示的数据可以为标量、一维向量、二维矩阵、多维矩阵。

TensorFlow用tf.Tensor表示Tensor对象。Tensor对象主要包含dtype、name、shape、rank、op几个属性。dtype为Tensor的数据类型，例如float32、int32、string等。name为Tensor的名称。shape为多维矩阵的维度信息。op表示构建Tensor的节点信息。读取Tensor信息的程序示例，如下所示：

代码清单 1-1–7 查看Tensor对象的各个属性值
import tensorflow as tf

# 得到tensor对象
tensor=tf.ones(shape=[2,1,3])

# 显示tensor属性值
print("dtype:",tensor.dtype)
print("name:",tensor.name)
print("shape:",tensor.shape)
print("rank:",tensor.shape.ndims)

在这段代码中，tf.ones表示定义的tensor中所有数据的值为1，矩阵的维度为[2,1,3]。tensor.dtype表示数据类型，tensor.name表示名称，tensor.shape.ndims表示tensor数据的维度大小。

变量定义及使用

TensorFlow变量用来表示模型参数。有两种创建变量的方式，一种使用tf.Variable方法，另一种使用tf.get_variable方法。tf.Variable创建的变量，都是一个新的变量，不能被模型重复引用。tf.get_variable定义的变量可以在模型中被重复使用，大大简化了TensorFlow程序的开发。使用tf.get_variable创建变量的程序示例，如下所示：

代码清单 1-1–8 tf.get_variable方法的使用
# name表示变量名，shape表示变量的维度信息，my_variable的默认数据类型为float32，
# 变量初始化方法为tf.glorot_uniform_initializer，采用均匀分布
my_variable = tf.get_variable(name = "my_variable", shape = [1, 2, 3])

# initializer表示变量的初始化方法，tf.zeros_initializer表示变量的初始值为0
my_int_variable = tf.get_variable(name = "my_int_variable", 
shape = [1, 2, 3], 
dtype = tf.int32, 
initializer=tf.zeros_initializer)

# initializer = tf.constant([23, 42])表示变量的初始值为给定的常量值
other_variable = tf.get_variable(name = "other_variable", 
dtype = tf.int32, 
initializer = tf.constant([23, 42]))

在这段代码中，tf.get_variable用于创建变量，name表示变量名，shape表示变量的维度信息，initializer用于指定变量的初始化方法，默认的初始化方法为glorot_uniform_initializer。

为了更好地管理TensorFlow变量，通常把变量放到不同的集合中。GLOBAL_VARIABLES集合中的变量为全局变量，被多个设备共享。LOCAL_VARIABLES集合中的变量为局部变量，一般不参与模型的保存与恢复。METRIC_VARIABLES集合中的变量为用于做统计分析的局部变量。MODEL_VARIABLES集合中的变量为模型变量。TRAINABLE_VARIABLES集合中的变量为参与模型训练的变量。MOVING_AVERAGE_VARIABLES集合中的变量为参与滑动平均运算的变量。使用集合的程序示例，如下所示：

代码清单 1-1–9 集合的使用
# 定义变量并放到tf.GraphKeys.LOCAL_VARIABLES集合中
my_local = tf.get_variable("my_local", shape=(), 
collections=[ tf.GraphKeys.LOCAL_VARIABLES ])

# 定义变量，不参与梯度计算，该变量不放到集合TRAINABLE_VARIABLES中
my_non_trainable = tf.get_variable("my_non_trainable", 
shape=(),
trainable=False)

# 创建自定义集合，并把该变量添加到集合中
tf.add_to_collection("my_collection_name", my_local)

# 从集合中获取所有变量
tf.get_collection("my_collection_name")

# 清空GLOBAL_VARIABLES集合中的所有变量
tf.get_default_graph().clear_collection(tf.GraphKeys.GLOBAL_VARIABLES)

在这段代码中，collections表示变量要存储的集合。trainable=False表示变量不参与模型训练，变量不会被放到集合TRAINABLE_VARIABLES中。tf.add_to_collection用于把变量添加到自定义集合中。tf.get_collection表示从指定的集合中得到变量内容。clear_collection用于清空指定集合中的所有变量。

tf.variable_scope用来管理变量的上下文信息。在tf.variable_scope(name_or_scope, reuse)方法中，name_or_scope为变量命名空间名称，reuse用来指定命名空间中的变量是否可以被重复使用。tf.variable_scope和tf.get_variable方法，通常用来构建可复用的代码结构，简化模型开发，程序示例如下所示：

代码清单 1-1–10 使用tf.variable_scope和tf.get_variable
# 构建卷积层
def conv_relu(input, kernel_shape, bias_shape):
    # 创建变量 "weights".
weights = tf.get_variable("weights", 
kernel_shape,
initializer=tf.random_normal_initializer())
    # 创建变量 "biases".
biases = tf.get_variable("biases", 
bias_shape,
initializer=tf.constant_initializer(0.0))
    # 构建卷积操作
conv = tf.nn.conv2d(input, 
weights,
strides=[1, 1, 1, 1], padding='SAME')

    return tf.nn.relu(conv + biases)

# 搭建多个卷积层，共享weights和biases的变量定义
def my_image_filter(input_images):
    # 定义卷积层，变量的命名空间conv1
with tf.variable_scope("conv1"):
        # 创建变量 "conv1/weights", "conv1/biases".
        relu1 = conv_relu(input_images, [5, 5, 32, 32], [32])

    # 定义卷积层，变量的命名空间conv2
with tf.variable_scope("conv2"):
        # 创建变量"conv2/weights", "conv2/biases".
        return conv_relu(relu1, [5, 5, 32, 32], [32])


# 对输入数据input执行模型推理
with tf.variable_scope("model"):
output = my_image_filter(input)

在这段代码中，函数conv_relu为卷积操作，relu为激活函数。函数my_image_filter搭建了一个两层的卷积神经网络。output表示对输入数据执行前向推理后的输出结果。

除了使用tf.variable_scope来指定变量的命名空间外，还可以使用tf.name_scope方法来定义变量的命名空间。两者的区别在于，tf.variable_scope中的变量有相同的命名，包括tf.get_variable创建的变量和tf.Variable定义的变量。tf.name_scope只是限于tf.Variable定义的变量。在TensorFlow程序中，通常使用tf.variable_scope来控制变量的命名空间。

使用Graph

TensorFlow程序在加载的时候，会自动创建默认的图对象。TensorFlow还可通过tf.Graph()，显示地创建图对象。TensorFlow使用图来管理节点，例如在图中增加一个节点。使用Graph的程序示例，如下所示：

代码清单 1-1–11 使用TensorFlow Graph对象
import tensorflow as tf

# 在默认图中增加一个Const节点
c = tf.constant(5.0)

# 在默认图中增加一个集合setTest
tf.get_default_graph().add_to_collection("setTest", c)

# 打印图中所有节点
print(tf.get_default_graph().get_operations())

# 根据名称获取图中对应的节点
print(tf.get_default_graph().get_operation_by_name("Const"))

# 根据名称获取图中对应的Tensor
print(tf.get_default_graph().get_tensor_by_name("Const:0"))

# 根据图中集合名称，获取集合中保存的数据
print(tf.get_default_graph().get_collection("setTest"))

# 保存图的定义到文件graph.pbtxt 
tf.train.write_graph(graph_or_graph_def = tf.get_default_graph(), 
logdir = ".",
name = "graph.pbtxt")

# 保存图的定义到二进制文件model.pb
with tf.gfile.FastGFile('model.pb', mode = 'wb') as f:
f.write(tf.get_default_graph().as_graph_def().SerializeToString())

在上述代码中，tf.get_default_graph用于获取默认图对象。get_operations用于获取图中的所有节点。get_operation_by_name根据名称获取图中对应的节点。get_tensor_by_name根据名称获取图中对应的tensor对象，Const:0表示节点“Const”的输出Tensor。tf.train.write_graph把图保存成protobuff格式的文本文件。f.write把图保存成protobuf的二进制文件。

使用Session

在TensorFlow中，使用tf.Session控制图的运行。tf.Session创建会话时，可以设定三个参数，分别为target，graph和config。target表示要运行会话的设备位置。graph表示要运行的计算图。config表示会话的配置信息，例如日志配置、设备配置等。使用Session的程序示例，如下所示：

代码清单 1-1–12 使用Session
# allow_soft_placement表示是否可以动态调整计算设备的分配。
# log_device_placement表示是否要在日志信息中显示节点操作所分配的设备。
config = tf.ConfigProto(allow_soft_placement = True, 
log_device_placement = True)
sess = tf.Session(config = config)

在这段代码中，tf.ConfigProto用于设定session的配置信息。参数allow_soft_placement表示根据系统环境动态分配的硬件设备。如果变量没有找到对应的GPU执行环境，该变量会在CPU设备上运行。参数log_device_placement表示打印变量所对应的设备信息。

模型的保存及恢复

为了保证训练的稳定性，需要在训练中定时保存模型文件，防止由于意外原因中断训练，导致数据的丢失。TensorFlow使用tf.train.Saver实现模型的保存及恢复，程序示例如下所示：

代码清单 1-1–13 保存模型
import tensorflow as tf

# 创建模型变量.
v1 = tf.get_variable("v1", shape=[3], initializer = tf.zeros_initializer)
v2 = tf.get_variable("v2", shape=[5], initializer = tf.zeros_initializer)

# 模型变量赋值
inc_v1 = v1.assign(v1 + 1)
dec_v2 = v2.assign(v2 - 1)

# 模型变量初始化
init_op = tf.global_variables_initializer()

# 定义用于保存模型变量的对象
saver = tf.train.Saver()

# 保存模型到checkpoint文件中
with tf.Session() as sess:
  sess.run(init_op)

  #执行模型中的操作.
  inc_v1.op.run()
  dec_v2.op.run()

  # 保存模型变量到磁盘 
  save_path = saver.save(sess, "C:tmpckptmodel.ckpt")
  print("Model saved in path: %s" % save_path)

在这段代码中，v1和v2表示模型变量。inc_v1和dec_v2表示变量的赋值操作。init_op表示模型的初始化操作。tf.train.Saver表示模型的持久化操作对象。saver.save保存模型变量到磁盘中。

模型保存完毕后，会生成4个文件，如下图1-12所示。“.meta”为模型的元数据文件，表示网络结构。“.data”为checkpoint数据文件，为模型参数。“.index”为checkpoint数据的索引文件。“checkpoint”为检查点的文件列表信息，是一个文本文件。

图 1-12 TensorFlow模型检查点文件示例

TensorFlow可以把保存好的模型文件重新加载进来，进行持续训练，程序示例如下所示：

代码清单 1-1–14 恢复模型
import tensorflow as tf
# 重新设置默认图
tf.reset_default_graph()

# 创建模型变量
v1 = tf.get_variable("v1", shape=[3])
v2 = tf.get_variable("v2", shape=[5])

# 恢复模型变量
saver = tf.train.Saver()

with tf.Session() as sess:
  # 从磁盘恢复模型文件 
  saver.restore(sess, "C:tmpckptmodel.ckpt")
  print("Model restored.")
  # 打印模型恢复后的变量值
  print("v1 : %s" % v1.eval())
  print("v2 : %s" % v2.eval())

在这段代码中，tf.train.Saver定义了模型的持久化操作对象。saver.restore表示从磁盘恢复模型文件。

使用GPU

图形处理器（Graphics Processing Unit，GPU）已广泛地应用于图像分类、语音识别、自然语言处理、机器翻译等深度学习领域。GPU是通用并行处理器，具有数以千计的计算核心，可实现 10-100 倍的性能提升，。

支持GPU的TensorFlow版本为tensorflow-gpu，，使用前需要预先安装GPU运算平台CUDA和GPU加速库cuDNN。CUDA使GPU能够解决复杂的大规模计算问题。cuDNN是用于深度神经网络的GPU加速库，运算性能高、内存开销低，已被集成到TensorFlow中。TensorFlow中的大多数运算操作，都有CPU和GPU接口的实现。如果运算操作没有指定运行的设备，默认会采用GPU进行运算。TensorFlow使用GPU的程序示例，如下所示：

代码清单 1-1–15 使用GPU示例
# 定义使用gpu0执行a * b的矩阵运算，其中a，b，c都在gpu0上执行
with tf.device('/gpu:0'):
    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指定在日志中输出变量和操作所在的设备
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
print sess.run(c)

在这段代码中，tf.device指定运行程序的设备为GPU0。log_device_placement=True表示打印变量和操作所在设备信息。在默认配置下，会话占用GPU所有显存。用户也可以指定GPU配置项，例如，config.gpu_options.allow_growth根据程序运行情况动态分配GPU显存，config.gpu_options.per_process_gpu_memory_fraction按照百分比分配GPU显存。

小结

本章主要讲解TensorFlow的入门基础，如果读者已有TensorFlow的使用经验，可以跳过本章。首先，本章介绍了TensorFlow的学习资源和模型开发流程。然后，讲解了TensorFlow程序的工作原理和结构，需要重点理解。最后，讲解了编程的基础知识，包括Tensor、变量、Graph、Session及GPU等知识。