10-分布式系统和线性回归

10-分布式系统和线性回归

分布式Tensorflow：分布式Tensorflow是由高性能的gRPC框架作为底层技术来支持的。这是一个通信框架gRPC(google remote procedure call)，是一个高性能、跨平台的RPC框架。RPC协议，即远程过程调用协议，是指通过网络从远程计算机程序上请求服务。 多机多卡分布式的架构 分布式的模式：

02自实现一个线性回归 分布式API

1、创建一个tf.train.ClusterSpec，用于对集群中的所有任务进行描述，该描述内容对所有任务应该是相同的

2、创建一个tf.train.Server，用于创建一个任务(ps,worker)，并运行相应作业上的计算任务。

在tensorflow对设备的命名是有一定规则的，其主要以两个参数job表示工作的内心，为ps或者worker。还有有事task，其是用来指定第几台机器，如/job：ps/task：0表示的，就是第0台参数服务器。/job：woker/task：0代表第0台工作服务器。那么其设备怎么去添加呢？继续往后添加。第0台参数服务器其下有cpu。则为/job：ps/task：0/cpu：0。如果是GPU，则为/job：ps/task：0/GPU：0。

1、创建集群

1、 cluster = tf.train.ClusterSpec({"ps": ps_spec, "worker": worker_spec})
cluster = tf.train.ClusterSpec(
{
"worker":
[“worker0.example.com:2222”,    /job:worker/task:0 
“worker1.example.com:2222”,    /job:worker/task:1 
“worker2.example.com:2222”],    /job:worker/task:2 

"ps": 
[“ps0.example.com:2222”,    /job:ps/task:0 
“ps1.example.com:2222”]   /job:ps/task:1
})

2、创建服务

tf.train.Server(server_or_cluster_def, job_name=None, task_index=None, 
protocol=None, config=None, start=True)
创建服务(ps,worker)
	server_or_cluster_def: 集群描述
	job_name: 任务类型名称
	task_index: 任务数
	
	attribute：target
	返回tf.Session连接到此服务器的目标
	method：join()
	参数服务器端，直到服务器等待接受参数任务关闭

3、工作节点指定设备运行

tf.device(device_name_or_function)
	选择指定设备或者设备函数
	if device_name:
	指定设备
	例如："/job:worker/task:0/cpu:0”
	
	if function:
	tf.train.replica_device_setter(worker_device=worker_device,
	cluster=cluster)
	作用：通过此函数协调不同设备上的初始化操作
	worker_device:为指定设备, “/job:worker/task:0/cpu:0” or
	"/job:worker/task:0/gpu:0"
	cluster:集群描述对象
	
注：使用with tf.device(),使不同工作节点工作在不同的设备上

3、工作节点指定设备运行

tf.device(device_name_or_function)
选择指定设备或者设备函数
if device_name:
指定设备
例如："/job:worker/task:0/cpu:0”

if function:
tf.train.replica_device_setter(worker_device=worker_device,
cluster=cluster)
作用：通过此函数协调不同设备上的初始化操作
worker_device:为指定设备, “/job:worker/task:0/cpu:0” or
"/job:worker/task:0/gpu:0"
cluster:集群描述对象

注：使用with tf.device(),使不同工作节点工作在不同的设备上

一般步骤如下： 1、对集群当中的一些ps，worker进行指定。 2、创建对应的服务，如果是worker则创建worker服务，ps同理。ps创建之后执行join即可，woker需要运行模型，程序，初始化等。 3、会话，但是这里不能使用tf.Session()不支持分布式。需要使用分布式会话API：

MonitoredTrainingSession(master=‘’,is_chief=True,checkpoint_dir=None,    hooks=None,save_checkpoint_secs=600,save_summaries_steps=USE_DEFAULT,    save_summaries_secs=USE_DEFAULT,config=None)
分布式会话函数
master:指定运行会话协议IP和端口（用于分布式）
	“grpc://192.168.0.1:2000”
is_chief是否为主worker（用于分布式）
	如果True，它将负责初始化和恢复基础的TensorFlow会话。如果False，
它将等待一位负责人初始化或恢复TensorFlow会话。
checkpoint_dir:检查点文件目录，同时也是events目录
config:会话运行的配置项, tf.ConfigProto(log_device_placement=True)
hooks:可选SessionRunHook对象列表

should_stop():是否异常停止
run():跟session一样可以运行op

其上的hooks

tf.train.SessionRunHook
Hook to extend calls to MonitoredSession.run()
1、begin():
在会话之前，做初始化工作
2、before_run(run_context)在每次调用run()之前调用，以添加run()中的参数。
ARGS：
run_context：一个SessionRunContext对象，包含会话运行信息
return：一个SessionRunArgs对象，例如：tf.train.SessionRunArgs(loss)
3、after_run(run_context,run_values)在每次调用run()后调用，一般用于运行之后的结果处理
该run_values参数包含所请求的操作/张量的结果 before_run()。
该run_context参数是相同的一个发送到before_run呼叫。
 ARGS：
run_context：一个SessionRunContext对象
run_values一个SessionRunValues对象, run_values.results

常用钩子

tf.train.StopAtStepHook(last_step=5000)

指定执行的训练轮数也就是max_step，超过了就会抛出异常

tf.train.NanTensorHook(loss)

判断指定Tensor是否为NaN，为NaN则结束

注：在使用钩子的时候需要定义一个全局步数：global_step = tf.contrib.framework.get_or_create_global_step()

下面是一个例子。

下面我们通过一个案例，去实现这样的分布式案例，步骤如下： 1、创建集群对象 2、创建服务 3、服务端等待接受参数 4、客户端使用不同设备进行定义模型以进行计算 5、使用高级会话类

编写代码如下：

import tensorflow as tf
FLAFS = tf.app.flags.FLAGS

tf.app.flags.DEFINE_string("job_name", "","启动服务的类型ps or woker")
tf.app.flags.DEFINE_string("task_idex", "0","指定ps或者worker当中那一台服务器，以task:0,task:1")




def main(argv):
    # 定义全局计数的op，给钩子列表中的训练步数使用
    global_step = tf.contrib.framework.get_or_create_global_step()

    # 指定集群描述对象ps，worker
    cluster = tf.train.ClusterSpec({"ps":["192.168.1.1:2222"], "worker":["192.168.1.12:2222"]})

    # 创建不同的服务，ps，worker
    server = tf.train.Server(cluster, job_name=FLAFS.job_name, task_index=FLAFS.task_index)

    # 根据不同的服务做不同的事情 ps:去保存更新参数    worker:指定设备区运行模型计算
    if FLAFS.job_name =="ps":
        # 参数服务器什么都不用干，只需要等待worker传递参数
        server.join()
    else:
        worker_device = "job:worker/task:0/cpu:0/"

        # 可以指定设备区去运行
        with tf.device(tf.train.replica_device_setter(
            worker_device=worker_device,
            cluster=cluster
        )):
            # 简单做一个矩阵乘法运算
            x = tf.Variable([[1,2,3,4]])
            w = tf.Variable([[2],[2],[2],[2]])

            mat = tf.matmul(x,w)

        # 创建分布式会话
        with tf.train.MonitoredTrainingSession(
            master = "grpc/192.168.1.12:2222",   # 指定worler
            is_chierf=(FLAFS.task_index == 0),   # 判断是否为在worker
            config=tf.ConfigProto(log_device_placement=True),  # 打印设备信息
            hooks=[tf.train.StopAtStepHook(last_step=200)]
        ) as mon_sess:
            while not mon_sess.should_stop():
                mon_sess.run(mat)

if __name__ == '__main__':
    tf.app.run()