分布式计算学习笔记(三) Ray —API & Actors

分布式计算学习笔记(三) Ray —API & Actors

概述

本篇博客主要介绍 Ray API 简单的使用(基于actor和worker),以及运行一个简单的利用 Ray 进行修改的传统神经网络模型(MNIST)

Actor: 有状态的 worker,当实例化一个新actor时,将创建一个新worker,并将acto的方法调度到该特定worker上,并且可以访问该worker并更改其状态。

CSDN: Ray入门指南(3)—-Ray API

可以简单的理解为,在函数上加入 @ray.remote之后,这个函数就是 worker,在类上加入@ray.remote之后,这个类就是actor(有状态的workers)

1
import os
2
import ray
3
import tensorflow.compat.v1 as tf
4
tf.disable_v2_behavior()
5
from tensorflow.examples.tutorials.mnist import input_data
6
7
ray.init(num_gpus=8)
8
# consruct neural network
9
10
11
def construct_network():
12
    # [None, 784]: data structure. total number of attribute is 28*28=784 with uncertain row number (batch size, can be of any size.)
13
    x = tf.placeholder(tf.float32, [None, 784])
14
    # total number of attribute is 10 (0-9) with uncertain row number
15
    y_ = tf.placeholder(tf.float32, [None, 10])
16
    W = tf.Variable(tf.zeros([784, 10]))  # Weights
17
    b = tf.Variable(tf.zeros([10]))  # biase
18
    y = tf.nn.softmax(tf.matmul(x, W) + b) # y = wx + b
19
    # y_: real,y: prediction
20
    cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ *
21
                                                  tf.log(y), reduction_indices=[1]))  # loss function
22
    # Use gradientdescentoptimizer to min the loss function
23
    train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
24
25
    # 1:search by row. tf.equal: 对比这两个矩阵或者向量的相等的元素,如果是相等的那就返回True,反正返回False
26
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
27
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # tf.cast: convert correct_prediction to float32
28
29
    return x, y_, train_step, accuracy
30
31
# define actor for structure
32
@ray.remote(num_gpus=1)  # actor gpu数量为1
33
class NeuralNetOnGPU(object):
34
    def __init__(self, mnist_data):
35
        self.mnist = mnist_data
36
        # Set an environment variable to tell TensorFlow which GPUs to use. Note
37
        # that this must be done before the call to tf.Session.
38
        os.environ["CUDA_VISIBLE_DEVICES"] = ",".join(
39
            [str(i) for i in ray.get_gpu_ids()])
40
        with tf.Graph().as_default():
41
            with tf.device("/gpu:0"):
42
                self.x, self.y_, self.train_step, self.accuracy = construct_network()
43
                # Allow this to run on CPUs if there aren't any GPUs.
44
                config = tf.ConfigProto(allow_soft_placement=True)
45
                #### normal network
46
                # init = tf.initialize_all_variables()
47
                # sess = tf.Session()
48
                # sess.run(init)
49
                ####
50
                self.sess = tf.Session(config=config)
51
                # Initialize the network.
52
                init = tf.global_variables_initializer()
53
                self.sess.run(init)
54
55
    def train(self, num_steps):
56
        for i in range(num_steps):
57
            # load dataset by batch
58
            batch_xs, batch_ys = self.mnist.train.next_batch(100)
59
            # train
60
            self.sess.run(self.train_step, feed_dict={
61
                          self.x: batch_xs, self.y_: batch_ys})
62
            if (i% 50):
63
                print(self.get_accuracy())
64
    def get_accuracy(self):
65
        return self.sess.run(self.accuracy, feed_dict={self.x: self.mnist.test.images,
66
                                                       self.y_: self.mnist.test.labels})
67
68
69
# load MNIST dataset,并告诉Ray如何序列化定制类。
70
mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
71
72
# Create the actor. 实例化actor并运行构造函数
73
nn = NeuralNetOnGPU.remote(mnist)
74
75
# Run a few steps of training and print the accuracy.
76
nn.train.remote(200)
77
accuracy = ray.get(nn.get_accuracy.remote()) # ray.get 从对象ID中进行数据的读取(python对象)
78
print("Accuracy is {}.".format(accuracy))

相较于传统的神经网络结构,通过使用 Ray 进行了网络的封装,利用 Api 的形式进行网络调用,construt_network() 函数中定义了输入变量,权重,偏执,通过 softmax 隐藏层输出结果,同时利用交叉熵定义了损失函数,最终函数返回 输入,预测的结果,训练步数以及准确率。

在定义 Ray actor(类)中,进行了网络结构的初始化,训练的工作。这些函数的实现和没有使用 Ray 没有太大的差别,可以理解为进行了更为高级的封装便于 Ray 分布式框架的实现

Output:

1
(pid=20686) 0.9017
2
(pid=20686) 0.907
3
(pid=20686) 0.9047
4
(pid=20686) 0.9047
5
(pid=20686) 0.9025
6
Accuracy is 0.9049000144004822.
7
(pid=20686) 0.9026
8
(pid=20686) 0.9059
9
(pid=20686) 0.9088
10
(pid=20686) 0.9067
11
(pid=20686) 0.9049

在训练过程中,每50步进行结果的输出,其结果输出到终端,有图中可以得知,由于多进程工作,而只有一个位置进行结果的输出,难免会有优先抢断的问题,所以本应是最后输出的 Accuracy 放在了较为靠前的位置。

Q&A:

  1. python 中 __init__(self) 以及类的使用
    _init_(self) 可以理解为JAVA的构造函数
    实例化类的时候会最先调用构造函数

  2. python class中不同函数的调用以及self的使用

    1
    class MyClass:
    2
    	def __init__(self):
    3
        	pass
    4
    	def func1(self):
    5
        	# do something
    6
        	print('a')   #for example      
    7
        	self.common_func()
    8
    	 def func2(self):
    9
        	# do something
    10
        	self.common_func() # self表示类的实例
    11
        	 
    12
    	 def common_func(self):
    13
    		pass
  3. Tensorflow 的基本定义以及使用
    input-> hidden layer -> output layer -> 梯度下降进行参数的训练
    用优化器 (optimizer) 减小误差
    sess.run(Weights): sess类似于指针,用sess.run 指向网络结构中的 Weights,进行输出
    placeholder: 在session run的时候再进行数据的传入,可以理解为占一个位置
    只要是通过 placeholder 进行运算的东西,在sess.run里面都需要进行定义相关运算的参数

    1
    feed_dict={xs:x_data, ys:y_data}

    cross_entropy: 交叉熵,用于目标与预测值之间的差距


# Recommend Posts
 1.1/1/2019 - 12/31/2019
 2.1/1/2019 - 12/31/2019
 3.82 年生的金智英
 4.Hexo主题折腾日记(二) 添加豆瓣和聊天插件
 5.Hexo主题折腾日记(一) 从cactus到icarus

Comments

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×