互联网+

选自GitHub

作者：Matthew Rahtz

通过多 GPU 并行的方式可以有很好的加速效果，然而一台机器上所支持的 GPU 是有限的，因此本文介绍了分布式 TensorFlow。分布式 TensorFlow 允许我们在多台机器上运行一个模型，所以训练速度或加速效果能显著地提升。本文简要概述了分布式 TensorFlow 的原理与实践，希望能为准备入坑分布式训练的读者提供一些介绍。

不幸的是，关于分布式 TensorFlow 的官方文档过于简略。我们需要一个稍微易懂的介绍，即通过 Jupyter 运行一些基本例子。

如果你想交互式地使用 Jupyter，可以在 GitHub 上找到源代码。此外，本文的一些解释是作者自己对实证结果或 TensorFlow 文档的解释，因此可能会有一些小误差。

GitHub 地址：https://github.com/mrahtz/distributed_tensorflow_a_gentle_introduction

简介

1. importtensorflow astf

比方说，我们希望多个进程共享一些共同的参数。为了简单起见，假设这只是一个单一的变量：

1. var = tf.Variable(initial_value=0.0)

第一步，我们需要为每个进程创建自己的会话。（假设 sess1 在一个进程中创建，而 sess2 会在另一个进程中创建）。

1. sess1 = tf.Session()

2. sess2 = tf.Session()

4. sess1.run(tf.global_variables_initializer())

5. sess2.run(tf.global_variables_initializer())

每次调用 tf.Session() 都会创建一个单独的「执行引擎」，然后将会话句柄连接到执行引擎。执行引擎是实际存储变量值并运行操作的东西。且 Python 天生是面向对象的编程，它里面的元素都是类或对象，因此更正式地说，tf.Seesio() 是 TensorFlow 中的一个方法，它会打开一个会话并运行计算图。

通常，不同进程中的执行引擎是不相关的。在一个会话中更改变量（在一个执行引擎上）不会影响其他会话中的变量。

1. print("Initial value of var in session 1:", sess1.run(var))

2. print("Initial value of var in session 2:", sess2.run(var))

4. sess1.run(var.assign_add(1.0))

5. print("Incremented var in session 1")

7. print("Value of var in session 1:", sess1.run(var))

8. print("Value of var in session 2:", sess2.run(var))

上面代码块的输出结果为：

1. Initialvalue of var insession 1: 0.0

2. Initialvalue of var insession 2: 0.0

3. Incrementedvar insession 1

4. Valueof var insession 1: 1.0

5. Valueof var insession 2: 0.0

对于分布式 TensorFlow，我们首先需要了解它的基本原理。以下代码展示了如何构建一个最简单 TensorFlow 集群，以帮助我们理解它的基本原理。

1. importtensorflow astf

2. c =tf.constant("Hello, Distributed TensorFlow!")

3. # 创建一个本地TensorFlow集群

4. server =tf.train.Server.create_local_server()

5. # 在集群上创建一个会话

6. sess =tf.Session(server.target)

7. print(sess.run(c)）

在以上代码中，我们先通过 tf.train.Server.create_local_server 在本地创建一个只有一台机器的 TensorFlow 集群。然后在集群上生成一个会话，通过该对话，我们可以将创建的计算图运行在 TensorFlow 集群上。虽然这只是一个单机集群，但它基本上反映了 TensorFlow 集群的工作流程。

TensorFlow 集群会通过一系列任务（task）来执行计算图中的运算，一般来说不同的任务会在不同的机器上运行。TensorFlow 集群中的任务也会被聚集为工作（job）。例如在训练深度模型时，一台运行反向传播的机器是一个任务，而所有运行反向传播的集合是一个工作。上面简单的案例只是一个任务的集群，若一个 TensorFlow 集群有多个任务时，我们需要使用 tf.train.ClusterSpec 来指定每一个任务的机器。

使用分布式 TensorFlow 训练深度学习模型一般有两种方式，即 in-graph replication 和 between-graph replication。第一种计算图内的分布式会令所有任务都使用一个 TensorFlow 计算图中的变量，而只是将计算部分分配到不同的服务器上。而另一种计算图间的分布式会在每一个计算服务器上创建一个独立的 TensorFlow 计算图，但不同计算图中的相同参数需要以一种固定的方式存放到同一个参数服务器中。以上大概就是分布式 TensorFlow 的基本概念，随后我们将通过具体的案例与代码加深这一部分的理解。

分布式 TensorFlow

为了在进程之间共享变量，我们需要将不同的执行引擎连接在一起，并输入分布式张量流。

若使用分布式 TensorFlow，每个进程会运行一个特殊的执行引擎：一个 TensorFlow 服务器。服务器作为集群的一部分链接在一起。（群集中的每个服务器也称为任务。）

第一步是定义集群的规模。我们从最简单的集群开始：即两台服务器（两个任务），它们都在同一台机器上，一个在 2222 端口，一个在 2223 端口。

1. tasks = ["localhost:2222", "localhost:2223"]

每个任务都与「工作」（job）相关联，该工作是相关任务的集合。我们将这两个任务与一个称为「local」的工作相关联。

1. jobs = {"local": tasks}

所有这些即定义为一个集群。

1. cluster = tf.train.ClusterSpec(jobs)

我们现在可以启动服务器，指定每个服务器对应为集群定义中的哪个服务器。立即启动各服务器，监听集群设置中指定的端口。

1. # "This server corresponds to the the first task (task_index=0)

2. # of the tasks associated with the 'local' job."

3. server1 = tf.train.Server(cluster, job_name="local", task_index=0)

5. server2 = tf.train.Server(cluster, job_name="local", task_index=1)

将服务器连接在同一个集群中，我们现在可以体验到分布式 TensorFlow 的强大功能：任何具有相同名称的变量都将在所有服务器之间共享。

最简单的例子是在所有的服务器上运行同一张静态计算图，且每个图只有一个变量：

1. tf.reset_default_graph()

2. var = tf.Variable(initial_value=0.0, name='var')

3. sess1 = tf.Session(server1.target)

4. sess2 = tf.Session(server2.target)

现在，在一台服务器上对变量所作的修改将在第二台服务器上作镜像处理。

1. sess1.run(tf.global_variables_initializer())

2. sess2.run(tf.global_variables_initializer())

4. print("Initial value of var in session 1:", sess1.run(var))

5. print("Initial value of var in session 2:", sess2.run(var))

7. sess1.run(var.assign_add(1.0))

8. print("Incremented var in session 1")

10. print("Value of var in session 1:", sess1.run(var))

11. print("Value of var in session 2:", sess2.run(var))

1. Initialvalue of var insession 1: 0.0

2. Initialvalue of var insession 2: 0.0

3. Incrementedvar insession 1

4. Valueof var insession 1: 1.0

5. Valueof var insession 2: 1.0

请注意，因为我们只有一个变量且该变量由两个会话共享，第二个会话再调用 global_variables_initializer 就有些多余。

存放

现在我们可能会想：变量究竟存储在哪个服务器上？又是哪个服务器在运行操作？

按经验来说，变量和操作都默认存储在集群的第一个任务上。

1. defrun_with_location_trace(sess, op):

2. # From https://stackoverflow.com/a/41525764/7832197

3. run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)

4. run_metadata = tf.RunMetadata()

5. sess.run(op, options=run_options, run_metadata=run_metadata)

6. fordevice inrun_metadata.step_stats.dev_stats:

7. print(device.device)

8. fornode indevice.node_stats:

9. print(" ", node.node_name)

例如，如果我们使用连接到第一个任务的会话来处理变量 var，那么所有操作都会运行在这个任务上：

1. run_with_location_trace(sess1, var)

1. /job:local/replica:0/task:0/device:CPU:0

2. _SOURCE

3. var

1. run_with_location_trace(sess1, var.assign_add(1.0))

1. /job:local/replica:0/task:0/device:CPU:0

2. _SOURCE

3. AssignAdd_1/value

4. var

5. AssignAdd_1

但是，如果我们尝试使用连接到第二个任务的会话处理变量 var，那么图节点仍然会在第一个任务上运行。

1. run_with_location_trace(sess2, var)

1. /job:local/replica:0/task:1/device:CPU:0

2. _SOURCE

3. /job:local/replica:0/task:0/device:CPU:0

4. _SOURCE

5. var

要将一个变量或操作固定到特定任务上，我们可以使用 tf.device：

1. withtf.device("/job:local/task:0"):

2. var1 = tf.Variable(0.0, name='var1')

3. withtf.device("/job:local/task:1"):

4. var2 = tf.Variable(0.0, name='var2')

6. # (This will initialize both variables)

7. sess1.run(tf.global_variables_initializer())

现在，var1 像之前一样运行在第一个任务上。

1. run_with_location_trace(sess1, var1)

1. /job:local/replica:0/task:0/device:CPU:0

2. _SOURCE

3. var1

但是 var2 运行在第二个任务上。即使我们尝试使用连接到第一个任务的会话来评估它，它仍然在第二个任务上运行。

1. run_with_location_trace(sess1, var2)

1. /job:local/replica:0/task:0/device:CPU:0

2. _SOURCE

3. /job:local/replica:0/task:1/device:CPU:0

4. _SOURCE

5. var2

变量 2 亦是如此。

1. run_with_location_trace(sess2, var2)

1. /job:local/replica:0/task:1/device:CPU:0

2. _SOURCE

3. var2

1. run_with_location_trace(sess2, var1)

1. /job:local/replica:0/task:1/device:CPU:0

2. _SOURCE

3. /job:local/replica:0/task:0/device:CPU:0

4. _SOURCE

5. var1

计算图

分布式 TensorFlow 处理图的过程有几点需要注意。

谁构建了这个图？

首先，尽管在整个集群中共享变量值，但图并不会自动共享。

我们用两台服务器创建一个新的集群，然后用显式创建的图设置第一台服务器。

1. cluster = tf.train.ClusterSpec({"local": ["localhost:2224", "localhost:2225"]})

2. server1 = tf.train.Server(cluster, job_name="local", task_index=0)

3. server2 = tf.train.Server(cluster, job_name="local", task_index=1)

1. graph1 = tf.Graph()

2. withgraph1.as_default():

3. var1 = tf.Variable(0.0, name='var')

4. sess1 = tf.Session(target=server1.target, graph=graph1)

5. print(graph1.get_operations())

1. [<tf.Operation'var/initial_value'type=Const>, <tf.Operation'var'type=VariableV2>, <tf.Operation'var/Assign'type=Assign>, <tf.Operation'var/read'type=Identity>]

如果我们创建连接到第二台服务器的会话，请注意图不会自动获取镜像。

1. graph2 = tf.Graph()

2. sess2 = tf.Session(target=server2.target, graph=graph2)

3. print(graph2.get_operations())

4. ————————————————————————————

   []

要访问共享变量，我们必须手动添加一个同名的变量到第二个图中。

1. withgraph2.as_default():

2. var2 = tf.Variable(0.0, name='var')

只有如此我们才可以访问它。

1. sess1.run(var1.assign(1.0))

2. sess2.run(var2)

3. ————————————————————————————

4. 1.0

关键是：每个服务器负责创建自己的图。

所有服务器上的图都必须一样吗？

到目前为止，我们所有的例子都是在两台服务器上运行相同的图。这被称为图内复制（in-graph replication）。

例如，假设我们有一个包含三台服务器的集群。服务器 1 保存共享参数，而服务器 2 和服务器 3 是工作站节点，每个都有本地变量。在图内复制中，每台服务器的图如下所示：

图内复制的问题在于每个服务器都必须具有整个图的副本，包括可能只与其他服务器相关的子图。这可能会导致图变得非常大。

另一种方法是图间复制（between-graph replication）。在这里，每个服务器都运行一个只包含共享参数的图，而且任何变量和操作都与单个服务器相关。

这种方法缩减了图的大小，因此我们推荐使用图间复制。

实践细节

在介绍完整示例之前，有几个实践中遇到的细节问题需要讨论一下。

如果在所有服务器互联之前尝试在集群上运行某些程序，会发生什么？

我们再次创建一个双任务集群。

1. cluster = tf.train.ClusterSpec({

2. "local": ["localhost:2226", "localhost:2227"]

3. })

这一次，让我们在隔离进程中启动每个服务器。（这允许我们随时关闭服务器，以便再次启动它们进行后续的实验。除了关闭启动服务器的进程之外，目前没有其它办法关闭服务器。）

1. frommultiprocessing importProcess

2. fromtime importsleep

4. defs1():

5. server1 = tf.train.Server(cluster,

6. job_name="local",

7. task_index=0)

8. sess1 = tf.Session(server1.target)

9. print("server 1: running no-op...")

10. sess1.run(tf.no_op())

11. print("server 1: no-op run!")

12. server1.join() # Block

14. defs2():

15. fori inrange(3):

16. print("server 2: %d seconds left before connecting..."

17. % (3- i))

18. sleep(1.0)

19. server2 = tf.train.Server(cluster,

20. job_name="local",

21. task_index=1)

22. print("server 2: connected!")

23. server2.join() # Block

25. # daemon=True so that these processes will definitely be killed

26. # when the parent process restarts

27. p1 = Process(target=s1, daemon=True)

28. p2 = Process(target=s2, daemon=True)

服务器 1 即刻加入集群，但服务器 2 在连接之前等待了一会儿。结果如下所示：

1. p1.start()

2. p2.start()

1. server 2: 3seconds left before connecting...

2. server 1: running no-op...

3. server 2: 2seconds left before connecting...

4. server 2: 1seconds left before connecting...

5. server 2: connected!

6. server 1: no-op run!

可以看出，每个服务器都试图在集群上运行一个操作，直到所有的服务器都加入。

1. p1.terminate()

2. p2.terminate()

当服务器脱离集群会怎样？

我们用两台服务器建立一个集群。服务器 1 只是反复尝试和运行位于服务器 1 上的 no-op 操作。服务器 2 将在两秒钟后宕机。

1. defs1():

2. server1 = tf.train.Server(cluster,

3. job_name="local",

4. task_index=0)

6. withtf.device("/job:local/task:0"):

7. no_op = tf.no_op()

9. sess1 = tf.Session(server1.target)

10. for_ inrange(6):

11. print("Server 1: about to run no-op...", end="")

12. sess1.run(no_op)

13. print("success!")

14. sleep(1.0)

16. defs2():

17. server2 = tf.train.Server(cluster,

18. job_name="local",

19. task_index=1)

20. sleep(2.0)

21. print("Server 2 dieing...")

23. p1 = Process(target=s1, daemon=True)

24. p2 = Process(target=s2, daemon=True)

26. p1.start()

27. p2.start()

29. ————————————————————————————————

30. Server1: about to run no-op...success!

31. Server1: about to run no-op...success!

32. Server2dieing...

33. Server1: about to run no-op...success!

34. Server1: about to run no-op...success!

35. Server1: about to run no-op...success!

36. Server1: about to run no-op...success!

短期内，只要我们试图运行的操作不在脱离的服务器上，似乎不会出现问题。（我没有测试过长期运行会发生什么。）

如果操作是在脱离的服务器上……

1. defs1():

2. server1 = tf.train.Server(cluster,

3. job_name="local",

4. task_index=0)

6. # This time, we place the no-op on server 2,

7. # which is going to leave

8. withtf.device("/job:local/task:1"):

9. no_op = tf.no_op()

11. sess1 = tf.Session(server1.target)

12. for_ inrange(5):

13. print("Server 1: about to run no-op...", end="")

14. sess1.run(no_op)

15. print("success!")

16. sleep(1.0)

18. p1 = Process(target=s1, daemon=True)

19. p2 = Process(target=s2, daemon=True)

21. p1.start()

22. p2.start()

24. ——————————————————————————————————

—

1. Server1: about to run no-op...success!

2. Server1: about to run no-op...success!

3. Server2dieing...

然后尝试运行操作代码。

1. p1.terminate()

2. p2.terminate()

如果服务器又加入集群会怎样？

1. p1 = Process(target=s1, daemon=True)

2. p2 = Process(target=s2, daemon=True)

3. p1.start()

4. p2.start()

5. sleep(3.0)

6. # At this point, server 1 is blocked, and server 2 is dead.

7. print("Restarting server 2...")

8. p2 = Process(target=s2, daemon=True)

9. p2.start()

11. ————————————————————————————

12. Server1: about to run no-op...success!

13. Server1: about to run no-op...success!

14. Server2dieing...

15. Restartingserver 2...

1. ProcessProcess-7:

2. Traceback(most recent call last):

3. File"/Users/matthew/tensorflow/lib/python3.6/site-packages/tensorflow/python/client/session.py", line 1323, in_do_call

4. returnfn(*args)

5. File"/Users/matthew/tensorflow/lib/python3.6/site-packages/tensorflow/python/client/session.py", line 1302, in_run_fn

6. status, run_metadata)

7. File"/Users/matthew/tensorflow/lib/python3.6/site-packages/tensorflow/python/framework/errors_impl.py", line 473, in__exit__

8. c_api.TF_GetCode(self.status.status))

9. tensorflow.python.framework.errors_impl.AbortedError: Graphhandle isnotfound: 0000000000000001

10. Server1: about to run no-op...Server2dieing...

系统报了一个 Graph handle is not found 的错误。

因此分布式 TensorFlow 不会自动恢复服务器故障。（如果您对容错有兴趣，请查看 https://www.youtube.com/watch?v=la_M6bCV91M。）

谁负责初始化共享变量？

一种方法是让所有工作站运行 tf.global_variables_initializer()。

但是如果我们想保持代码整洁并且只用一个服务器进行初始化，那么如果有其他服务器在初始化之前尝试使用这些变量，可能会遇到问题。一个解决方案就是让其他工作站等待，直到使用 tf.report_uninitialized_variables 的初始化开始。

1. defs1():

2. server1 = tf.train.Server(cluster,

3. job_name="local",

4. task_index=0)

5. var = tf.Variable(0.0, name='var')

6. sess1 = tf.Session(server1.target)

8. print("Server 1: waiting for connection...")

9. sess1.run(tf.report_uninitialized_variables())

10. whilelen(sess1.run(tf.report_uninitialized_variables())) > 0:

11. print("Server 1: waiting for initialization...")

12. sleep(1.0)

13. print("Server 1: variables initialized!")

15. defs2():

16. server2 = tf.train.Server(cluster,

17. job_name="local",

18. task_index=1)

19. var = tf.Variable(0.0, name='var')

20. sess2 = tf.Session(server2.target)

22. fori inrange(3):

23. print("Server 2: waiting %d seconds before initializing..."

24. % (3- i))

25. sleep(1.0)

26. sess2.run(tf.global_variables_initializer())

28. p1 = Process(target=s1, daemon=True)

29. p2 = Process(target=s2, daemon=True)

30. p1.start()

31. p2.start()

33. —————————————————————————————————

35. Server1: waiting forconnection...

36. Server2: waiting 3seconds before initializing...

37. Server1: waiting forinitialization...

38. Server2: waiting 2seconds before initializing...

39. Server1: waiting forinitialization...

40. Server2: waiting 1seconds before initializing...

41. Server1: waiting forinitialization...

42. Server1: variables initialized!

1. p1.terminate()

2. p2.terminate()

示例

让我们把所学的知识融合到最后一个使用多进程的例子中。

我们将创建：

• 一个存储单个变量 var 的参数服务器。

• 两个工作站任务（worker task），每个工作站将多次增加变量 var 的值。

我们将让参数服务器多输出几次 var 的值，以便查看其变化。

1. importtensorflow astf

2. frommultiprocessing importProcess

3. fromtime importsleep

5. cluster = tf.train.ClusterSpec({

6. "worker": [

7. "localhost:3333",

8. "localhost:3334",

9. ],

10. "ps": [

11. "localhost:3335"

12. ]

13. })

15. defparameter_server():

16. withtf.device("/job:ps/task:0"):

17. var = tf.Variable(0.0, name='var')

19. server = tf.train.Server(cluster,

20. job_name="ps",

21. task_index=0)

22. sess = tf.Session(target=server.target)

24. print("Parameter server: waiting for cluster connection...")

25. sess.run(tf.report_uninitialized_variables())

26. print("Parameter server: cluster ready!")

28. print("Parameter server: initializing variables...")

29. sess.run(tf.global_variables_initializer())

30. print("Parameter server: variables initialized")

32. fori inrange(5):

33. val = sess.run(var)

34. print("Parameter server: var has value %.1f"% val)

35. sleep(1.0)

37. print("Parameter server: blocking...")

38. server.join()

41. defworker(worker_n):

42. withtf.device("/job:ps/task:0"):

43. var = tf.Variable(0.0, name='var')

45. server = tf.train.Server(cluster,

46. job_name="worker",

47. task_index=worker_n)

48. sess = tf.Session(target=server.target)

50. print("Worker %d: waiting for cluster connection..."% worker_n)

51. sess.run(tf.report_uninitialized_variables())

52. print("Worker %d: cluster ready!"% worker_n)

54. whilesess.run(tf.report_uninitialized_variables()):

55. print("Worker %d: waiting for variable initialization..."% worker_n)

56. sleep(1.0)

57. print("Worker %d: variables initialized"% worker_n)

59. fori inrange(5):

60. print("Worker %d: incrementing var"% worker_n)

61. sess.run(var.assign_add(1.0))

62. sleep(1.0)

64. print("Worker %d: blocking..."% worker_n)

65. server.join()

67. ps_proc = Process(target=parameter_server, daemon=True)

68. w1_proc = Process(target=worker, args=(0, ), daemon=True)

69. w2_proc = Process(target=worker, args=(1, ), daemon=True)

1. ps_proc.start()

3. ————————————————————————————

5. Parameterserver: waiting forcluster connection...

6. Parameterserver: cluster ready!

7. Parameterserver: initializing variables...

8. Parameterserver: variables initialized

9. Parameterserver: var has value 0.0

10. Parameterserver: var has value 2.0

11. Parameterserver: var has value 4.0

12. Parameterserver: var has value 5.0

13. Parameterserver: var has value 7.0

14. Parameterserver: blocking...

1. w1_proc.start()

————————————————————————————————

1. Worker0: waiting forcluster connection...

2. Worker0: cluster ready!

3. Worker0: waiting forvariable initialization...

4. Worker0: variables initialized

5. Worker0: incrementing var

6. Worker0: incrementing var

7. Worker0: incrementing var

8. Worker0: incrementing var

9. Worker0: incrementing var

10. Worker0: blocking...

1. w2_proc.start()

3. ———————————————————————————————

5. Worker1: waiting forcluster connection...

6. Worker1: cluster ready!

7. Worker1: waiting forvariable initialization...

8. Worker1: variables initialized

9. Worker1: incrementing var

10. Worker1: incrementing var

11. Worker1: incrementing var

12. Worker1: incrementing var

13. Worker1: incrementing var

14. Worker1: blocking...

1. forproc in[w1_proc, w2_proc, ps_proc]:

2. proc.terminate()

总结

通过本文，我们了解了：

• 如何将多个 TensorFlow 执行引擎（运行在不同进程或不同机器上）集成为一个集群，以便共享变量。

• 如何为变量或操作指定服务器。

• 图内复制与图间复制。

• 在所有服务器互联之前或在服务器脱离集群之后在集群上运行操作，会发生什么。

• 如何等待变量被集群中的另一个任务初始化。

更多信息和实例，请查阅官方文档：https://www.tensorflow.org/deploy/distributed。

原文链接：http://amid.fish/distributed-tensorflow-a-gentle-introduction

本文为机器之心编译，转载请联系本公众号获得授权。返回搜狐，查看更多

责任编辑：