केर में मल्टी जी.पी.यू.

आप कई जीपीयू पर प्रशिक्षण के विभाजन के लिए केरस लाइब्रेरी (या टेंसरफ़्लो) में कैसे प्रोग्राम कर सकते हैं? मान लीजिए कि आप Amazon ec2 उदाहरण में हैं, जिसमें 8 GPU हैं और आप उन सभी का उपयोग तेजी से प्रशिक्षित करने के लिए करना चाहेंगे, लेकिन आपका कोड केवल एक CPU या GPU के लिए है।

— हेक्टर ब्लांडिन
स्रोत

क्या आपने टेंसोफ़्लो डॉक्टर की जाँच की है?

— n1tk

@ sb0709: मैंने आज सुबह पढ़ना शुरू किया, लेकिन मैं सोच रहा था कि इसे कैसे में करूं

— हेक्टर

केरस में पता नहीं है, लेकिन टेंसरफ्लो के लिए: सीपीयू डिफ़ॉल्ट रूप से कम्प्यूटेशन के लिए जीपीयू का उपयोग करेगा भले ही सीपीयू के लिए (यदि वर्तमान में समर्थित जीपीयू है)। तो आप बस एक लूप के लिए कर सकते हैं: "डी के लिए ['/ gpu: 1', '/ gpu: 2', '/ gpu: 3' ... '/ gpu: 8',]:" और में "tf.device (d)" में आपके सभी उदाहरण GPU संसाधन शामिल होने चाहिए। तो tf.device () वास्तव में उपयोग किया जाएगा।

— n1tk

ऐशे ही ?? d में ['/ gpu: 1', '/ gpu: 2', '/ gpu: 3' ... '/ gpu: 8',]: tf.device (d) और वह है? मैं उस तरह की कोशिश करूंगा :)

— हेक्टर ब्लैंडिन

जहाँ तक मुझे पता है हाँ, आप विभिन्न डिवाइस पर कोई भी कार्य कर सकते हैं।

— n1tk

जवाबों:

करैस सामान्य प्रश्न से:

https://keras.io/getting-started/faq/#how-can-i-run-a-keras-model-on-multiple-gpus

नीचे 'डेटा समानता' को सक्षम करने के लिए कॉपी-पेस्ट कोड है। यानी आपका प्रत्येक GPU स्वतंत्र रूप से आपके डेटा के एक अलग सबसेट को संसाधित करता है।

from keras.utils import multi_gpu_model

# Replicates `model` on 8 GPUs.
# This assumes that your machine has 8 available GPUs.
parallel_model = multi_gpu_model(model, gpus=8)
parallel_model.compile(loss='categorical_crossentropy',
                       optimizer='rmsprop')

# This `fit` call will be distributed on 8 GPUs.
# Since the batch size is 256, each GPU will process 32 samples.
parallel_model.fit(x, y, epochs=20, batch_size=256)

ध्यान दें कि यह केवल लेखन के समय में Tensorflow backend के लिए मान्य प्रतीत होता है।

अपडेट (फरवरी 2018) :

Keras अब multi_gpu_model का उपयोग करके स्वचालित gpu चयन स्वीकार करता है, इसलिए आपको अब gp की संख्या को हार्डकोड नहीं करना होगा। इस पुल अनुरोध में विवरण । दूसरे शब्दों में, यह इस तरह दिखने वाले कोड को सक्षम करता है:

try:
    model = multi_gpu_model(model)
except:
    pass

लेकिन अधिक स्पष्ट होने के लिए , आप कुछ इस तरह से चिपका सकते हैं:

parallel_model = multi_gpu_model(model, gpus=None)

बोनस :

यह जांचने के लिए कि क्या आप वास्तव में अपने सभी GPU, विशेष रूप से NVIDIA वाले का उपयोग कर रहे हैं, आप टर्मिनल का उपयोग करके अपने उपयोग की निगरानी कर सकते हैं:

watch -n0.5 nvidia-smi

संदर्भ:

— weiji14
स्रोत

क्या उस multi_gpu_model(model, gpus=None)मामले में काम करता है जहां केवल 1 जीपीयू है? यदि यह स्वतः उपलब्ध GPUs की संख्या के अनुकूल होगा तो यह अच्छा होगा।

— CMCDragonkai

हां मुझे लगता है कि यह 1 GPU के साथ काम करता है, github.com/keras-team/keras/pull/9226#issuecomment-361692460 देखें , लेकिन आपको सावधान रहने की जरूरत है कि आपका कोड एक साधारण मॉडल के बजाय एक मल्टी_गुप_मॉडल पर चलने के लिए अनुकूलित है । ज्यादातर मामलों के लिए यह शायद मायने नहीं रखता है, लेकिन यदि आप कुछ ऐसा करने जा रहे हैं जैसे कि कुछ मध्यवर्ती परत का उत्पादन लेते हैं, तो आपको तदनुसार कोड करने की आवश्यकता होगी।

— वीजी १४

क्या आपके पास मल्टी जीपीयू मॉडल मतभेदों का कोई संदर्भ है?

— CMCDragonkai

आपका कुछ मतलब है जैसे github.com/rossumai/keras-multi-gpu/blob/master/blog/docs/… ?

— वीजी १४

यह संदर्भ महान @ weiji14 था। हालाँकि, मैं यह भी दिलचस्पी रखता हूँ कि यह निष्कर्ष के लिए कैसे काम करता है। क्या केर किसी तरह उपलब्ध मॉडल प्रतिकृतियों पर समान रूप से या गोल रॉबिन अनुसूची को विभाजित करता है?

— CMCDragonkai 6

TensorFlow के लिए:

TensorFlow GPUs का उपयोग करना

यहां बताया गया है कि कैसे उपयोग किया जाता है पर नमूना कोड है, इसलिए प्रत्येक कार्य के लिए उपकरणों / डिवाइस के साथ सूची निर्दिष्ट की गई है:

# Creates a graph.
c = []
for d in ['/gpu:2', '/gpu:3']:
  with tf.device(d):
    a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3])
    b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2])
    c.append(tf.matmul(a, b))
with tf.device('/cpu:0'):
  sum = tf.add_n(c)
# Creates a session with log_device_placement set to True.
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
# Runs the op.
print(sess.run(sum))

tf CPU के लिए डिफ़ॉल्ट रूप से कम्प्यूटेशन के लिए उपयोग करेगा भले ही वह CPU के लिए हो (यदि वर्तमान में समर्थित GPU है)। तो आप बस एक लूप के लिए कर सकते हैं: "डी के लिए ['/ gpu: 1', '/ gpu: 2', '/ gpu: 3' ... '/ gpu: 8',]:" और में "tf.device (d)" में आपके सभी उदाहरण GPU संसाधन शामिल होने चाहिए। तो tf.device () वास्तव में इस्तेमाल किया जाएगा।

मल्टीपल जीपीयू को स्केलिंग केरस मॉडल ट्रेनिंग

Keras

Args.num_gpus की तुलना में Mxnet का उपयोग करके Keras के लिए , जहाँ num_gpus आपके GPU GPU की सूची है।

def backend_agnostic_compile(model, loss, optimizer, metrics, args):
  if keras.backend._backend == 'mxnet':
      gpu_list = ["gpu(%d)" % i for i in range(args.num_gpus)]
      model.compile(loss=loss,
          optimizer=optimizer,
          metrics=metrics, 
          context = gpu_list)
  else:
      if args.num_gpus > 1:
          print("Warning: num_gpus > 1 but not using MxNet backend")
      model.compile(loss=loss,
          optimizer=optimizer,
          metrics=metrics)

horovod.tensorflow

हाल ही में खुले उबेर होरोवोड के सभी शीर्ष पर और मुझे लगता है कि यह बहुत अच्छा है:

horovod

import tensorflow as tf
import horovod.tensorflow as hvd

# Initialize Horovod
hvd.init()

# Pin GPU to be used to process local rank (one GPU per process)
config = tf.ConfigProto()
config.gpu_options.visible_device_list = str(hvd.local_rank())

# Build model…
loss = …
opt = tf.train.AdagradOptimizer(0.01)

# Add Horovod Distributed Optimizer
opt = hvd.DistributedOptimizer(opt)

# Add hook to broadcast variables from rank 0 to all other processes during
# initialization.
hooks = [hvd.BroadcastGlobalVariablesHook(0)]

# Make training operation
train_op = opt.minimize(loss)

# The MonitoredTrainingSession takes care of session initialization,
# restoring from a checkpoint, saving to a checkpoint, and closing when done
# or an error occurs.
with tf.train.MonitoredTrainingSession(checkpoint_dir=“/tmp/train_logs”,
                                      config=config,
                                      hooks=hooks) as mon_sess:
 while not mon_sess.should_stop():
   # Perform synchronous training.
   mon_sess.run(train_op)

— n1tk
स्रोत

मूल रूप से, आप निम्न उदाहरण का उदाहरण ले सकते हैं। आप सभी की जरूरत है kpu आयात करने के बाद cpu और gpu खपत मूल्यों को निर्दिष्ट है।

import keras

config = tf.ConfigProto( device_count = {'GPU': 1 , 'CPU': 56} )
sess = tf.Session(config=config) 
keras.backend.set_session(sess)

उसके बाद, आप मॉडल को फिट करेंगे।

model.fit(x_train, y_train, epochs=epochs, validation_data=(x_test, y_test))

अंत में, आप खपत मान को कम कर सकते हैं ऊपरी सीमा पर काम नहीं करते हैं।

— johncasey
स्रोत