【TensorFlow基础】

SunYutong_1234

已于 2022-08-11 10:15:14 修改

阅读量2.5k

点赞数

分类专栏： python学习文章标签： tensorflow python 深度学习

于 2022-08-10 15:56:50 首次发布

本文链接：https://blog.csdn.net/SunYutong_1234/article/details/126243628

版权

python学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

tenroflow是Google开源软件库，为机器学习工程中的问题提供了一整套解决方案。类比于Spark/Flink是大数据工程问题的解决方案。该软件库把机器学习中的通用功能封装成了库，并提供了简易的API，使得在构建机器学习系统时不再需要做那些纷繁复杂的数学或者工程工作，能把主要精力放在模型和业务上。这就像现在使用编程语言进行编程时，不再需要知道计算机硬件的细节，不用知道CPU的指令集。从这个意义上说，tensorflow让机器学习工程从汇编语言时代，上升到了高级语言时代。

tensor：张量

3                                       # 这个 0 阶张量就是标量，shape=[]
[1., 2., 3.]                            # 这个 1 阶张量就是向量，shape=[3]
[[1., 2., 3.], [4., 5., 6.]]            # 这个 2 阶张量就是二维数组，shape=[2, 3]
[[[1., 2., 3.]], [[7., 8., 9.]]]        # 这个 3 阶张量就是三维数组，shape=[2, 1, 3]

使用tf.Tensor表示张量，每个tf.Tensor有两个属性：

dtype Tensor 存储的数据的类型，可以为tf.float32，tf.int32，tf.string...
shape Tensor 存储的多维数组中每个维度的数组中元素的个数，如上面例子中的shape

# 定义二阶常数张量
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])))  # 对张量进行切片

张量的数据类型之间可以相互转换，tensorflow中的tensor是数据流图中的单位，可以不具有值，但在图构建完毕后可以获取其中任意张量的值（评估evualuate）。 tensorflow不能直接评估在函数内部或者控制流结构内部定义的张量，如果或张量取决于队列中的值，那么只有在某个项加入队列后才能评估

基本操作

1. 创建tensor常量以及打印

# 引入tensorflow模块
import tensorflow as tf

# 创建tensor常量 tf.constant
# 创建一个整型常量/0阶tensor/shape=[]
t0 = tf.constant(3, dtype=tf.int32)

# 创建一个一维数组/1阶tensor/shape=[3]
t1 = tf.constant([3., 4.1, 5.2], dtype=tf.int32)  

# 创建一个2*2数组/2阶tensor/shape=[2, 3]
t2 = tf.constant(['a','b','c'], ['d','e','f'], dtypr=tf.string)

# 创建一个2*3*1数组/2阶tensor/shape=[2, 3, 1]，数据类型默认为整型
t3 = tf.constant([[[5], [6], [7]], [[4], [3], [2]]])

# 打印tensor属性定义
print(t0)
print(t1)
print(t2)
print(t3)

# 以上代码输出为
>>> print(t0)
Tensor("Const:0", shape=(), dtype=int32)
>>> print(t1)
Tensor("Const_1:0", shape=(3,), dtype=float32)
>>> print(t2)
Tensor("Const_2:0", shape=(2, 3), dtype=string)
>>> print(t3)
Tensor("Const_3:0", shape=(2, 3, 1), dtype=int32)

# 打印tensor值
sess = tf.Session()
print(sess.run(t0))
print(sess.run(t1))
print(sess.run(t2))
print(sess.run(t3))

# 以上代码输出为
>>> print(sess.run(t0))
3
>>> print(sess.run(t1))
[ 3.          4.0999999   5.19999981]
>>> print(sess.run(t2))
[[b'a' b'b' b'c']
 [b'd' b'e' b'f']]
>>> print(sess.run(t3))
[[[5]
  [6]
  [7]]

 [[4]
  [3]
  [2]]]

tensor常量之间也可以进行运算

import tensorflow as tf

# 创建两个常量节点
node1 = tf.constant(3.2)
node2 = tf.constant(4.8)

# 创建一个 adder 节点，对上面两个节点执行 + 操作
adder = node1 + node2

# 打印一下 adder 节点
print(adder)

# 打印 adder 运行后的结果
sess = tf.Session()
print(sess.run(adder))

# 输出
Tensor("add:0", shape=(), dtype=float32)
8.0

2. 创建tensor变量以及计算

numpy用于在python中的计算操作，在复杂计算中使用其他语言（C/C++）实现计算逻辑，但是在分布式并行计算（计算操作可能分布在不同的CPU、GPU甚至不同的机器中）场景下频繁在多个编程语言切换造成严重耗时。因此使用python上层代码设计定义模型构建计算图graph，使用tf.Session类连接客户端程序与底层C++运行，通过tf.Session.run()传递给底层执行。

tf.constant() 创建tensor常量；
tf.placeholder() 创建占位tensor，其值可以在运行的时候输入，可用于导入训练数据；
tf.Variable() 创建tensor变量，可用于存储训练参数（变量必须先初始化后才能使用）；
tf.SparseTensor() 创建稀疏tensor；

import tensorflow as tf

# 创建两个占位 Tensor 节点
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)

# 创建一个 adder 节点，对上面两个节点执行 + 操作
adder = a + b

# 打印三个节点的属性
print(a)
print(b)
print(adder)

# 运行一下，后面的 dict 参数是为占位 Tensor 提供输入数据
# dict的key对应adder中的参数，value对应参数取值
sess = tf.Session()
print(sess.run(adder, {a: 3, b: 4.5}))
print(sess.run(adder, {a: [1, 3], b: [2, 4]}))

# 输出
Tensor("Placeholder:0", dtype=float32)
Tensor("Placeholder_1:0", dtype=float32)
Tensor("add:0", dtype=float32)
7.5
[ 3.  7.]

低阶API中定义的变量必须明确初始化，高阶API例如keras会自动对变量进行初始化。

tensorflow提供变量集合储存不同类型的变量，默认的变量集合包括：

本地变量：tf.GraphKeys.LOCAL_VARIABLES
全局变量：tf.GraphKeys.GLOBAL_VARIABLES
训练梯度变量：tf.GraphKeys.TRAINABLE_VARIABLES

3. 使用tensorflow建立模型

建立线性模型拟合数据，其中线性模型可以表示为：

$y=W\times x+b$

损失模型可以表示为：

$loss=\sum_{n=1}^{N}(y_{n}-y_{n}^{'})^{2}$

import tensorflow as tf

# 创建变量 W 和 b 节点，并设置初始值
# W 初始值为0.1，b 初始值为-0.1
# tf.Variable 的初始值不能立即使用，需要经过初始化后才能使用tensor
W = tf.Variable([.1], dtype=tf.float32)
b = tf.Variable([-.1], dtype=tf.float32)

# 创建 x 节点，用来输入实验中的输入数据
x = tf.placeholder(tf.float32)
# 创建 y 节点，用来输入实验中得到的输出数据，用于损失模型计算
y = tf.placeholder(tf.float32)

# 创建线性模型
linear_model = W*x + b
# 创建损失模型
loss = tf.reduce_sum(tf.square(linear_model - y))

# 创建 Session 用来计算模型
sess = tf.Session()

# 初始化变量
init = tf.global_variables_initializer()
sess.run(init)

# 查看W初始值
print(sess.run(W))
# 查看线性模型运行结果
print(sess.run(linear_model, {x:[1,2,3,6,8]}))
# 查看损失模型运行结果
print(sess.run(loss, {x: [1, 2, 3, 6, 8], y: [4.8, 8.5, 10.4, 21.0, 25.3]}))

# 输出
[ 0.1]
[ 0.          0.1         0.20000002  0.5         0.69999999]
1223.05

# 对变量 W 和 b 重新赋值后检验
fixW = tf.assign(W, [2.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])  # run 之后新值才会生效
print(sess.run(loss, {x: [1, 2, 3, 6, 8], y: [4.8, 8.5, 10.4, 21.0, 25.3]}))

# 输出
159.94

tf.global_variables_initializer() 初始化变量

tf.reduce_sum

tf.square 平方

tf.assign 对tensor变量重新赋值

4. 使用tensorflow训练模型

tensorflow提供了很多优化算法帮助训练模型，比如梯度下降算法，通过不断改变模型中变量的值找到最小损失值。

# 创建一个梯度下降优化器，学习率为0.001
optimizer = tf.train.GradientDescentOptimizer(0.001)
train = optimizer.minimize(loss)

# 用两个数组保存训练数据
x_train = [1, 2, 3, 6, 8]
y_train = [4.8, 8.5, 10.4, 21.0, 25.3]

# 训练10000次
for i in range(10000):
    sess.run(train, {x: x_train, y: y_train})

# 打印一下训练后的结果
print('W: %s' % sess.run(W))
print('b: %s' % sess.run(b))
print('loss: %s' % sess.run(loss, {x: x_train , y: y_train}))

# 输出
W: [ 2.98236108]
b: [ 2.07054377]
loss: 2.12941

tf.train.GradientDescentOptimizer() 创建优化器

5. 使用tf.estimator简化训练过程

tf.estimator是tensorflow提供的高级库，封装了神经网络的训练、评估、预测、导出等操作，包含很多常用的训练模型，用于简化训练过程，如：运行训练循环、运行评估循环、管理训练数据集。具有可移植性，同一个模型可以在各类终端、服务中运行并使用GPU或TPU加速无需重新编码。工作流程如下：

建立数据集导入函数：可以使用TensorFlow的数据导入工具tf.data.Dataset或从numpy数组创建数据集导入函数。
定义特征列：特征列（tf.feature_column）包含了训练数据的特征名称、特征类型和输入预处理操作。
调出预创建的Estimator模型：可用的模型包括基础统计学（baseline）、梯度提升决策树（boosting desicion tree）和深度神经网络的回归、分类器。调出模型后需提供输入特征列、检查点路径和有关模型参数（例如神经网络的隐含层结构）。
训练和评估模型：所有预创建模型都包含train和evaluate接口用于学习和评估。

前面通过构建线性模型训练得到一个训练回归方程，接下来使用tf.estimator中的线性回归训练模型tf.estimator.LinearRegressor训练并评估模型。

评估evaluation：评估模型的泛化性能，新的实验数据应用到该模型中损失值越小则泛化性能越好。

# NumPy用于处理各种训练数据
import numpy as np
import tensorflow as tf

# 创建一个特征向量列表
# 该场景中特征列表里只有一个特征向量
# 该特征向量为实数向量，只有一个元素的数组，且该元素名称为 x
feature_columns = [tf.feature_column.numeric_column("x", shape=[1])]

# 创建一个LinearRegressor训练器，并传入特征向量列表
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns)

# 保存训练用的数据
x_train = np.array([1., 2., 3., 6., 8.])
y_train = np.array([4.8, 8.5, 10.4, 21.0, 25.3])

# 保存评估用的数据
x_eavl = np.array([2., 5., 7., 9.])
y_eavl = np.array([7.6, 17.2, 23.6, 28.8])

# 用训练数据创建一个输入模型，用来进行后面的模型训练（num_epochs=None）
# 第一个参数{"x": x_train}：线性回归模型的输入数据
# 第二个参数y_train：线性回归模型损失模型的输入
# 第三个参数batch_size：表示每批训练数据的个数
# 第四个参数num_epochs：epoch的次数，将训练集的所有数据都训练一遍为1次epoch
# 第五个参数shuffle：取训练数据是顺序取还是随机取
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=2, num_epochs=None, shuffle=True)

# 用训练数据创建一个输入模型，用来进行后面的模型评估（num_epochs=1000）
train_input_fn_2 = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=2, num_epochs=1000, shuffle=False)

# 用评估数据创建一个输入模型，用来进行后面的模型评估（num_epochs=1000）
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_eavl}, y_eavl, batch_size=2, num_epochs=1000, shuffle=False)

# 使用训练数据训练1000次（在LinearRegressor训练器上）
estimator.train(input_fn=train_input_fn, steps=1000)

# 使用原来训练数据评估一下模型，目的是查看训练的结果
train_metrics = estimator.evaluate(input_fn=train_input_fn_2)
print("train metrics: %r" % train_metrics)

# 使用评估数据评估一下模型，目的是验证模型的泛化性能
eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print("eval metrics: %s" % eval_metrics)

# 输出
train metrics: {'loss': 1.0493528, 'average_loss': 0.52467638, 'global_step': 1000}
eval metrics: {'loss': 0.72186172, 'average_loss': 0.36093086, 'global_step': 1000}

tf.feature_column.numeric_column 创建特征向量列表

tf.estimator.inputs.numpy_input_fn 创建输入模型

estimator.train 使用训练数据在训练器上训练

estimator.evaluate 评估模型

如果tf.estimator库中的训练模型不能满足需求，可以通过实现tf.estimator.Estimator的子类构建自己的训练模型（LinearRegressor就是类Estimator的一个子类），也可以给Estimator基类提供一个model_fn实现，定义自己的模型训练、评估方法以及损失计算方法。

import numpy as np
import tensorflow as tf

# 定义模型训练函数，以及特征向量
def model_fn(features, labels, mode):
    # 构建线性模型
    W = tf.get_variable("W", [1], dtype=tf.float64)
    b = tf.get_variable("b", [1], dtype=tf.float64)
    y = W * features['x'] + b
    # 构建损失模型
    loss = tf.reduce_sum(tf.square(y - labels))
    # 训练模型子图
    global_step = tf.train.get_global_step()
    optimizer = tf.train.GradientDescentOptimizer(0.01)
    train = tf.group(optimizer.minimize(loss),
                     tf.assign_add(global_step, 1))
    # 通过EstimatorSpec指定我们的训练子图及其损失模型
    return tf.estimator.EstimatorSpec(
        mode=mode,
        predictions=y,
        loss=loss,
        train_op=train)

# 创建自定义的训练模型
estimator = tf.estimator.Estimator(model_fn=model_fn)

# 后面的训练逻辑与使用LinearRegressor一样
x_train = np.array([1., 2., 3., 6., 8.])
y_train = np.array([4.8, 8.5, 10.4, 21.0, 25.3])

x_eavl = np.array([2., 5., 7., 9.])
y_eavl = np.array([7.6, 17.2, 23.6, 28.8])

train_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=2, num_epochs=None, shuffle=True)

train_input_fn_2 = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=2, num_epochs=1000, shuffle=False)

eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_eavl}, y_eavl, batch_size=2, num_epochs=1000, shuffle=False)

estimator.train(input_fn=train_input_fn, steps=1000)

train_metrics = estimator.evaluate(input_fn=train_input_fn_2)
print("train metrics: %r" % train_metrics)

eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print("eval metrics: %s" % eval_metrics)

# 输出
train metrics: {'loss': 0.8984344, 'global_step': 1000}
eval metrics: {'loss': 0.48776609, 'global_step': 1000}

tf.get_variable 构建变量，指定初始化器

tf.reduce_sum 构建损失模型

tf.train.get_global_step() 步长

tf.train.GradientDescentOptimizer(0.01) 训练器

tf.group(optimizer.minimize(loss), tf.assign_add(global_step, 1)) 构建训练模型

tf.estimator.Estimator 创建自定义的训练模型

6. tensorboard可视化工具

import tensorflow as tf

# 创建节点时设置name，方便在图中识别
W = tf.Variable([0], dtype=tf.float32, name='W')
b = tf.Variable([0], dtype=tf.float32, name='b')

# 创建节点时设置name，方便在图中识别
x = tf.placeholder(tf.float32, name='x')
y = tf.placeholder(tf.float32, name='y')

# 线性模型
linear_model = W * x + b

# 损失模型隐藏到loss-model模块
with tf.name_scope("loss-model"):
    loss = tf.reduce_sum(tf.square(linear_model - y))
    # 给损失模型的输出添加scalar，用来观察loss的收敛曲线
    tf.summary.scalar("loss", loss)

optmizer = tf.train.GradientDescentOptimizer(0.001)

train = optmizer.minimize(loss)

x_train = [1, 2, 3, 6, 8]
y_train = [4.8, 8.5, 10.4, 21.0, 25.3]

sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

# 调用 merge_all() 收集所有的操作数据
merged = tf.summary.merge_all()

# 模型运行产生的所有数据保存到 /tmp/tensorflow 文件夹供 TensorBoard 使用
writer = tf.summary.FileWriter('/tmp/tensorflow', sess.graph)

# 训练10000次
for i in range(10000):
    # 训练时传入merge
    summary, _ = sess.run([merged, train], {x: x_train, y: y_train})
    # 收集每次训练产生的数据
    writer.add_summary(summary, i)

curr_W, curr_b, curr_loss = sess.run(
    [W, b, loss], {x: x_train, y: y_train})

print("After train W: %s b %s loss: %s" % (curr_W, curr_b, curr_loss))

7. Keras

Keras是一个支持TensorFlow、Thenao和Microsoft-CNTK的第三方高阶神经网络API。Keras以TensorFlow的Python API为基础提供了神经网络、尤其是深度网络的构筑模块，并将神经网络开发、训练、测试的各项操作进行封装以提升可扩展性和简化使用难度，使用hdf5文件保存神经网络的权重系数。在TensorFlow下可以直接导出Keras模块使用。并且可以将模型导入estimators利用其完善的分布式训练循环。

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

# 导入estimators
# 从文件恢复模型和学习参数
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')

keras.Sequential 构建网络结构

keras.layers 添加网络层Flatten、Dense等

model.compile 配置优化算法、损失函数

model.fit 开始学习

model.evaluate 模型评估

model.predict 模型预测

model.save_weights 保存模型

model.save 保存模式参数h5文件

model.load_model 从文件恢复模型

model.load_weights 从文件恢复学习参数

8. tf.data：数据管理的高阶API

tf.data.Dataset：一组由张量构成的组元，包含缓存（cache）、交错读取（interleave）、预读取（prefetch）、洗牌（shuffle）、投影（map）、重复（repeat）等数据预处理方法；

tf.data.Iterator：类似于Python的循环器，是从Dataset中提取组元的有效方式

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参数通常为预读取值的个数。

9. 加速器

9.1 CPU和GPU设备

TensorFlow支持CPU和GPU运行，在程序中设备使用字符串进行表示。CPU表示为"/cpu:0"；第一个GPU表示为"/device:GPU:0"；第二个GPU表示为"/device:GPU:1"，以此类推。如果TensorFlow指令中兼有CPU和GPU实现，当该指令分配到设备时，GPU设备有优先权。

TensorFlow会默认尽可能地使用GPU内存，最理想的情况是进程只分配可用内存的一个子集，或者仅根据进程需要增加内存使用量，为此，启用会话时可通过两个编译选项来进行GPU进程管理。

allow_growth 内存动态分配选项，可以根据需要分配GPU内存，该选项在开启时会少量分配内存，并随着会话的运行对占用内存区域进行扩展。TensorFlow会话默认不释放内存，以避免内存碎片问题。
per_proc ess_gpu_memory_fraction 选项决定每个进程所允许的GPU内存最大比例。

在启用会话时打开log_device_placement配置选项，可以在终端查看会话中所有操作和张量所分配的设备

# 构建数据流图.
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…

9.2 TPU设备

张量处理器TPU是为tensorflow定制的专用芯片。TPU部署于谷歌的云计算平台。TensorFlow的神经网络API Estimator拥有支持TPU下可运行的版本TPUEstimator。TPUEstimator可以在本地进行学习/调试，并上传谷歌云计算平台进行计算。使用云计算TPU设备需要快速向TPU供给数据，为此可使用tf.data.Dataset API从谷歌云存储分区中构建输入管道。小数据集可使用tf.data.Dataset.cache完全加载到内存中，大数据可转化为TFRecord格式并使用tf.data.TFRecordDataset进行读取。

9.3 设备管理tf.device

根据tf.device对变量的分配，在单一GPU的系统中，与变量有关的操作会被固定到CPU或GPU上；在多GPU的系统中，操作会在偏好设备（或多个设备同时）运行。多GPU并行处理图的节点能加快会话的运行。定义变量时可以使用tf.device指定设备名称，tf.train.replica_device_setter可以对变量的设备进行自动分配：

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

10. 优化器

模型优化工具

Tensorflow提供了模型优化工具（Model Optimization Toolkit）对模型的尺度、响应时间和计算开销进行优化。模型优化工具可以减少模型参数的使用量（pruning）、对模型精度进行量化（quantization）和改进模型的拓扑结构，适用于将模型部署到终端设备，或在有硬件局限时运行模型，因此有很多优化方案是TensorFlow Lite项目的一部分。其中量化能够在最小化精度损失的情况下显著减小模型尺度和缩短响应时间，并是优化深度学习模型的重要手段。

线性代数加速器XLA

线性代数加速器（Accelerated Linear Algebra, XLA）是一个特殊的编译器，用于优化TensorFlow中的线性代数计算，其目标是优化内存使用，提升TensorFlow的运行速度和跨平台，尤其是移动终端的可移植性。目前属于开发状态。

可视化工具

TensorFlow拥有自带的可视化工具TensorBoard，具有展示数据流图、绘制分析图、显示附加数据等功能。开源安装的TensorFlow会自行配置TensorBoard。启动TensorBoard前需要建立模型档案，低阶API使用tf.summary构建档案，Keras包含callback方法、Estimator会自行建立档案。

调试程序

python的pdb很难对tensorflow代码进行调试，tensorflow的专用调试模块TFDBG可以在学习和预测时查看会话中数据流图的内部结构和状态。TFDBG在运行时期间会拦截指令生成的错误，并向用户显示错误信息和调试说明。

11. 部署

TensorFlow支持在一个或多个系统下使用多个设备并部署分布式服务器（distributed server）和服务器集群（cluster），服务器集群是分布运行的数据流图中的任务的集合，每个任务包含一个主干用于启动会话，以及一个工作点执行图的操作。

服务器集群可以被分割为工作，每个工作包含一个或多个任务。通常每个任务分配一台机器（或者多个任务在一台机器的不同设备运行）。每个任务都包含tf.train.ClusterSpec方法以描述该服务器集群的全部任务（每个任务的ClusterSpec是相同的），tf.train.Server方法按工作名提取本地任务。

tf.train.Server.create_local_server可在本地构建简单的分布式服务器。这里提供一个例子：

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)