Amazon SageMaker पर TensorFlow 1.x त्वरण प्रशिक्षण के लिए सर्वोत्तम अभ्यास

आज, बहुत से ग्राहक ई-कॉमर्स में विज्ञापन और वैयक्तिकरण अनुशंसाओं में अपनी क्लिकथ्रू दर के लिए गहन शिक्षण मॉडल को प्रशिक्षित करने के लिए TensorFlow का उपयोग कर रहे हैं। जैसे-जैसे उनके ग्राहकों का व्यवहार बदलता है, वे हर दिन बड़ी मात्रा में नया डेटा जमा कर सकते हैं। मॉडल पुनरावृत्ति डेटा वैज्ञानिक के दैनिक कार्यों में से एक है, लेकिन उन्हें बड़े डेटासेट पर प्रशिक्षित करने में बहुत अधिक समय लगने की समस्या का सामना करना पड़ता है।

अमेज़न SageMaker एक पूरी तरह से प्रबंधित मशीन लर्निंग (एमएल) प्लेटफॉर्म है जो डेटा वैज्ञानिकों को बुनियादी ढांचे के बजाय मॉडल पर ध्यान केंद्रित करने में मदद कर सकता है, जो टेंसरफ्लो और पायटोरच जैसे ढांचे और ढांचे के लिए मूल समर्थन के साथ है। सेजमेकर लचीले वितरित प्रशिक्षण विकल्प प्रदान करता है जो आपके विशिष्ट वर्कफ़्लो में समायोजित होते हैं। क्योंकि कई डेटा वैज्ञानिकों को त्वरण प्रशिक्षण प्रक्रिया में अनुभव की कमी हो सकती है, इस पोस्ट में हम आपको तेजी से गहन शिक्षण मॉडल प्रशिक्षण और सेजमेकर पर TensorFlow 1.x के लिए त्वरण प्रशिक्षण के सर्वोत्तम अभ्यासों के लिए महत्वपूर्ण कारक दिखाते हैं। हमारे पास का एक नमूना कोड भी है डीपएफएम सेजमेकर पर वितरित किया गया प्रशिक्षण गीथहब रेपो.

जब आप SageMaker पर अपनी TensorFlow स्क्रिप्ट चलाते हैं, तो आपको CPU/GPU उपयोग को अधिकतम करने के लिए कई कारकों पर विचार करना चाहिए, जैसे कि बुनियादी ढाँचा, त्वरक का प्रकार, वितरित प्रशिक्षण विधि, डेटा लोडिंग विधि, मिश्रित सटीक प्रशिक्षण, और बहुत कुछ।

हम निम्नलिखित क्षेत्रों में सर्वोत्तम प्रथाओं पर चर्चा करते हैं:

• एक ही उदाहरण पर प्रशिक्षण में तेजी लाएं
• कई उदाहरणों पर प्रशिक्षण में तेजी लाना
• डेटा पाइपलाइन
• स्वचालित मिश्रित सटीक प्रशिक्षण

एक ही उदाहरण पर प्रशिक्षण में तेजी लाएं

एक ही उदाहरण पर अपनी TensorFlow स्क्रिप्ट चलाते समय, आप एक कंप्यूटर अनुकूलित श्रृंखला चुन सकते हैं जैसे कि अमेज़ॅन इलास्टिक कम्प्यूट क्लाउड (अमेज़ॅन ईसी2) सी5 सीरीज़, या एक ही इंस्टेंस में कई जीपीयू के साथ एक त्वरित कंप्यूटिंग सीरीज़ जैसे कि p3.8xlarge, p3.16xlarge, p3dn.24xlarge, और p4d.24xlarge।

इस खंड में, हम एक ही उदाहरण पर कई सीपीयू के लिए रणनीतियों पर चर्चा करते हैं, और एक ही उदाहरण पर कई जीपीयू के साथ प्रशिक्षण वितरित करते हैं।

एक ही उदाहरण पर एकाधिक CPU

इस खंड में, हम सीपीयू उपकरणों, टावर विधि, टेंसरफ्लो मिररडस्ट्रेटी, और होरोवोड पर मैन्युअल रूप से ऑपरेटरों की समानता स्थापित करने पर चर्चा करते हैं।

सीपीयू उपकरणों पर ऑपरेटरों की समानता को मैन्युअल रूप से सेट करना

TensorFlow स्वचालित रूप से प्रशिक्षण प्रक्रिया में ऑपरेशन गणना को समानांतर करने के लिए उपयुक्त संख्या में थ्रेड्स का चयन करता है। हालाँकि, आप सेट कर सकते हैं intra_op धागे पूल और inter_op TensorFlow द्वारा प्रदान की गई समांतरता सेटिंग्स और OS थ्रेड के लिए बाइंडिंग सेट करने के लिए MKL-DNN के पर्यावरण चर का उपयोग करें। निम्नलिखित कोड देखें:

# Set parallelism of intra_op and inter_op
num_cpus = int(os.environ['SM_NUM_CPUS'])
config = tf.ConfigProto(allow_soft_placement=True, device_count={'CPU': num_cpus}, intra_op_parallelism_threads=num_cpus, inter_op_parallelism_threads=num_cpus)
run_config = tf.estimator.RunConfig().replace(session_config = config)

# Use Intel MKL-DNN Setting to accelerate training speed
os.environ["KMP_AFFINITY"]= "verbose,disabled"
os.environ['OMP_NUM_THREADS'] = str(num_cpus)
os.environ['KMP_SETTINGS'] = '1'

पर्यावरण चर KMP_AFFINITY एमकेएल-डीएनएन के लिए सेट है granularity=fine,compact,1,0 डिफ़ॉल्ट रूप से। TensorFlow के इंट्रा और इंटर दोनों को वर्तमान उदाहरण के vCPU की अधिकतम संख्या पर सेट करने के बाद, CPU उपयोग की ऊपरी सीमा लगभग प्रशिक्षण उदाहरण के भौतिक कोर की संख्या के समान है।

यदि आप सेट करते हैं os.environ["KMP_AFFINITY"]= "verbose,disabled", OS थ्रेड हार्डवेयर हाइपर थ्रेड के लिए बाध्य नहीं है, और CPU उपयोग भौतिक कोर की संख्या से अधिक हो सकता है।

TensorFlow इंट्रा पैरेललिज़्म, TensorFlow इंटर पैरेललिज़्म और MKL-DNN थ्रेड्स की संख्या की सेटिंग्स के संबंध में, इन तीन मापदंडों के विभिन्न संयोजनों के परिणामस्वरूप अलग-अलग प्रशिक्षण गति होती है। इसलिए, आपको सर्वोत्तम संयोजन खोजने के लिए प्रत्येक मामले का परीक्षण करने की आवश्यकता है। एक सामान्य स्थिति तीन पैरामीटर सेट करना है (intra_op_parallelism_threads और inter_op_parallelism_threads टेंसरफ्लो के लिए, os.environ['OMP_NUM_THREADS'] एमकेएल-डीएनएन के लिए) वीसीपीयू (भौतिक कोर) की संख्या का आधा या वीसीपीयू की कुल संख्या।

टॉवर विधि

GPU पर एक मॉडल को दोहराने के लिए, प्रत्येक GPU को फ़ॉरवर्ड पास का अपना उदाहरण मिलता है। फॉरवर्ड पास के उदाहरण को a . कहा जाता है मीनार. टॉवर विधि लगभग हमेशा GPU उपकरणों के लिए उपयोग की जाती है। अन्य तरीकों के साथ प्रशिक्षण की गति की तुलना करने के लिए, यहां हम अपने सीपीयू डिवाइस के लिए टॉवर विधि का भी उपयोग करते हैं।

यदि आप CPU डिवाइस को मैन्युअल रूप से सेट नहीं करते हैं, तो TensorFlow ग्रेडिएंट को औसत करने के लिए टावर विधि का उपयोग नहीं करता है, इसलिए आपको ऐसे मामलों में बैच आकार को स्केल करने की आवश्यकता नहीं है।

1. CPU डिवाइस को मैन्युअल रूप से सेट करें:

device_list = []
if manual_CPU_device_set:
		cpu_prefix=’/cpu:’
		for I in range(1, num_cpus):
			devices_list.append(cpu_prefix + str(i))

2. उपयोग replicate_model_fn लपेटने के लिए model_fn:

DeepFM = tf.estimator.Estimator(model_fn=tf.contrib.estimator.replicate_model_fn(model_fn, devices=device_list), model_dir=FLAGS.model_dir, params=model_params, config=config)

3. उपयोग TowerOptimizer लपेटने के लिए optimizer:

optimizer = tf.contrib.estimator.TowerOptimizer(optimizer)

4. अपने को लपेटो model_fn:

with tf.variable_scope(‘deepfm_model’, reuse=tf.AUTO_REUSE)

5. बैच आकार को (NUM_CPU-1) तक स्केल करें।

आइए टॉवर मोड सक्षम के साथ CPU उपयोग के अंतर को देखें। निम्न आंकड़ा निम्न कॉन्फ़िगरेशन के साथ ml.c5.18xlarge उदाहरण के CPU उपयोग को दर्शाता है:

कोई टॉवर + LibSVM डेटा + पाइप मोड + MKL-DNN बाइंडिंग को अक्षम नहीं करता है + TensorFlow इंट्रा/इंटर सेशन पैरेललिज़्म सेटिंग अधिकतम वीसीपीयू की अधिकतम संख्या के लिए

निम्न आंकड़ा निम्न कॉन्फ़िगरेशन के साथ ml.c5.18xlarge उदाहरण के CPU उपयोग को दर्शाता है:

सेट CPU डिवाइस के साथ टॉवर + LibSVM डेटा + पाइप मोड + MKL-DNN डिसेबल बाइंडिंग + TensorFlow इंट्रा/इंटर सेशन पैरेललिज़्म सेटिंग इंस्टेंस के वीसीपीयू की अधिकतम संख्या के लिए

टॉवर विधि का उपयोग करते समय CPU उपयोग अधिक होता है, और यह भौतिक कोर की संख्या से अधिक होता है।

TensorFlow मिरर की गई रणनीति

TensorFlow MirroredStrategy का अर्थ है एक मशीन पर कई प्रतिकृतियों में तुल्यकालिक प्रशिक्षण। यह रणनीति आमतौर पर एक मशीन पर कई GPU के साथ प्रशिक्षण के लिए उपयोग की जाती है। किसी अन्य विधि के साथ प्रशिक्षण गति की तुलना करने के लिए, हम अपने CPU डिवाइस के लिए MirroredStrategy का उपयोग करते हैं।

TensorFlow MirroredStrategy का उपयोग करते समय, यदि आप CPU डिवाइस को सेट नहीं करते हैं, तो TensorFlow केवल एक CPU का उपयोग एकल कार्यकर्ता के रूप में करता है, जो संसाधनों की बर्बादी है। हम सीपीयू डिवाइस को मैन्युअल रूप से सेट करने की सलाह देते हैं, क्योंकि यह कम ऑपरेशन करेगा /CPU:0, इतना /CPU:0 डिवाइस का उपयोग यहां प्रतिकृति के रूप में नहीं किया गया है। निम्नलिखित कोड देखें:

device_list = []
if manual_CPU_device_set:
		cpu_prefix=’/cpu:’
		for I in range(1, num_cpus):
			devices_list.append(cpu_prefix + str(i))
mirrored_strategy = tf.distribute.MirroredStrategy(devices=devices_list)
	else:
mirrored_strategy = tf.distribute.MirroredStrategy()

# Set strategy to config:
config = tf.estimator.RunConfig(train_distribute=mirrored_strategy,
eval_distribute=mirrored_strategy,
session_config = config)

मिररडस्ट्रेटी का उपयोग करते समय आपको बैच आकार को स्केल करने की आवश्यकता होती है; उदाहरण के लिए, बैच आकार को GPU उपकरणों की संख्या के गुणक में स्केल करें।

उप-रणनीति के लिए जब आप CPU डिवाइस सेट करते हैं, यदि आप सेट नहीं करते हैं cross_device_ops पैरामीटर में tf.distribute.MirroredStrategy(), TensorFlow का उपयोग करता है ReductionToOneDevice डिफ़ॉल्ट रूप से उप-रणनीति। हालाँकि, यदि आप सेट करते हैं HierarchicalCopyAllReduce उप-रणनीति के रूप में, TensorFlow बस कम करने का काम करता है /CPU:0. जब आप TensorFlow डेटासेट API का उपयोग करते हैं और एक साथ रणनीति वितरित करते हैं, तो फ़ंक्शन में सुविधाओं और लेबल के बजाय डेटासेट ऑब्जेक्ट को वापस किया जाना चाहिए input_fn.

आमतौर पर, TensorFlow MirroredStrategy CPU प्रशिक्षण पर टॉवर विधि की तुलना में धीमी होती है, इसलिए हम एक बहु-CPU एकल होस्ट पर MirroredStrategy का उपयोग करने की अनुशंसा नहीं करते हैं।

horovod

horovod TensorFlow, Keras, PyTorch और Apache MXNet के लिए एक वितरित गहन शिक्षण प्रशिक्षण ढांचा है। होरोवोड का लक्ष्य वितरित गहन शिक्षण को तेज और उपयोग में आसान बनाना है।

का एक पैरामीटर है distribution सेजमेकर पायथन एसडीके एस्टिमेटर एपीआई में, जिसका उपयोग आप होरोवोड वितरित प्रशिक्षण को बताने के लिए कर सकते हैं। सेजमेकर बुनियादी ढांचे का प्रावधान करता है और आपकी स्क्रिप्ट को एमपीआई के साथ चलाता है। निम्नलिखित कोड देखें:

hvd_processes_per_host = 4
distribution = {'mpi': { 
'enabled': True, 
'processes_per_host': hvd_processes_per_host,
'custom_mpi_options': '-verbose --NCCL_DEBUG=INFO -x OMPI_MCA_btl_vader_single_copy_mechanism=none' 
} 
}

GPU इंस्टेंस जैसे ml.p3.8xlarge चुनते समय, आपको प्रत्येक कार्यकर्ता के लिए प्रत्येक GPU को पिन करना होगा:

config = tf.ConfigProto()
config.gpu_options.visible_device_list = str(hvd.local_rank())

मॉडल अभिसरण को गति देने के लिए, होरोवोड आधिकारिक दस्तावेज़ीकरण के अनुसार श्रमिकों की संख्या के अनुसार सीखने की दर को मापें। हालांकि, वास्तविक दुनिया की परियोजनाओं में, आपको सीखने की दर को कुछ हद तक मापना चाहिए, लेकिन श्रमिकों की संख्या से नहीं, जिसके परिणामस्वरूप खराब मॉडल प्रदर्शन होता है। उदाहरण के लिए, यदि मूल सीखने की दर 0.001 है, तो हम सीखने की दर को 0.0015 तक मापते हैं, भले ही श्रमिकों की संख्या चार या अधिक हो।

आम तौर पर, केवल प्राथमिक (होरोवोड रैंक 0) चेकपॉइंट और मॉडल के साथ-साथ मूल्यांकन संचालन को भी बचाता है। होरोवोड का उपयोग करते समय आपको बैच के आकार को मापने की आवश्यकता नहीं है। सेजमेकर ऑफर पाइप मोड से डेटा स्ट्रीम करने के लिए अमेज़न सरल भंडारण सेवा (अमेज़ॅन S3) प्रशिक्षण उदाहरणों में। जब आप पाइप मोड को सक्षम करते हैं, तो सावधान रहें कि त्रुटियों से बचने के लिए एक ही होस्ट पर विभिन्न कर्मचारियों को विभिन्न चैनलों का उपयोग करने की आवश्यकता है। ऐसा इसलिए है क्योंकि पहली कार्यकर्ता प्रक्रिया फीफो/चैनल डेटा को पढ़ती है, और उसी उदाहरण पर अन्य कार्यकर्ता प्रक्रियाएं लटक जाएंगी क्योंकि वे एक ही फीफो/चैनल से डेटा नहीं पढ़ सकते हैं, इसलिए होरोवोड ठीक से काम नहीं करता है। इस समस्या से बचने के लिए, चैनलों को प्रति उदाहरण श्रमिकों की संख्या के अनुसार सेट करें। कम से कम सुनिश्चित करें कि एक ही होस्ट पर अलग-अलग कर्मचारी अलग-अलग चैनलों का उपभोग करते हैं; एक ही चैनल को एक अलग मेजबान पर श्रमिकों द्वारा उपभोग किया जा सकता है।

होरोवोड का उपयोग करते समय, आपको निम्न त्रुटि का सामना करना पड़ सकता है:

“One or more tensors were submitted to be reduced, gathered or broadcasted by subset of ranks and are waiting for remainder of ranks for more than 60 seconds. This may indicate that different ranks are trying to submit different tensors or that only subset of ranks is submitting tensors, which will cause deadlock.”

इस समस्या का संभावित कारण यह है कि एक निश्चित रैंक (जैसे रैंक 0) धीमी गति से काम करता है या अन्य रैंकों की तुलना में अधिक कार्य करता है, और इससे अन्य रैंक लंबे समय तक प्रतीक्षा करते हैं। हालांकि रैंक 0 को कभी-कभी अन्य रैंकों की तुलना में अधिक काम करना पड़ता है, यह ध्यान दिया जाना चाहिए कि रैंक 0 को लंबे समय तक ज्यादा कुछ नहीं करना चाहिए। उदाहरण के लिए, प्रशिक्षण के दौरान सत्यापन सेट और बचत चौकियों पर मॉडल मूल्यांकन के लिए, यदि यह अपरिहार्य है कि इन कार्यों में लंबा समय लगेगा, जिससे त्रुटियां हो सकती हैं, तो एक समाधान यह है कि सभी श्रमिकों को रैंक 0 (चौकियों) के समान काम करने दिया जाए। बचत, मूल्यांकन, और इसी तरह)।

वितरित प्रशिक्षण का उपयोग करते समय विचार करने के लिए डेटा शार्डिंग सबसे महत्वपूर्ण चीजों में से एक है। आप TensorFlow का उपयोग कर सकते हैं dataset.shard() आपकी लिपि में। सेजमेकर इसमें डेटासेट शार्ड फीचर भी प्रदान करता है इनपुट चैनल व्यवस्थित करके distribution=S3shardbykey डेटासेट चैनल में। निम्नलिखित कोड देखें:

dataset = PipeModeDataset(channel, record_format='TFRecord')

number_host = len(FLAGS.hosts)

if FLAGS.enable_data_multi_path : # If there are multi channels mapping with different S3 path
    if FLAGS.enable_s3_shard == False :
        if number_host > 1:
            index = hvd.rank() // FLAGS.worker_per_host
            dataset = dataset.shard(number_host, index)
else :
    if FLAGS.enable_s3_shard :
        dataset = dataset.shard(FLAGS.worker_per_host, hvd.local_rank())
    else :
        dataset = dataset.shard(hvd.size(), hvd.rank())

निम्न आंकड़ा होरोवोड (ml.c5.18xlarge, Horovod + LibSVM + डिफ़ॉल्ट इंट्रा सेशन और इंटर सेशन सेटिंग) का उपयोग करते समय परिणाम दिखाता है, जिसकी तुलना आप टावर विधि से कर सकते हैं।

एक ही उदाहरण पर कई GPU के साथ वितरित प्रशिक्षण

एक ही इंस्टेंस पर कई GPU के साथ वितरित प्रशिक्षण शुरू करना सामान्य है क्योंकि डेटा वैज्ञानिकों को केवल एक इंस्टेंस को प्रबंधित करने और GPU के बीच हाई-स्पीड इंटरलिंक का लाभ उठाने की आवश्यकता होती है। सेजमेकर ट्रेनिंग जॉब कई इंस्टेंस प्रकारों का समर्थन करता है, जिसमें एक ही इंस्टेंस पर कई GPU होते हैं, जैसे कि ml.p3.8xlarge, ml.p3.16xlarge, ml.p3dn.24xlarge, और ml.p4d.24xlarge। विधि एक ही उदाहरण में एकाधिक CPU के समान है, लेकिन स्क्रिप्ट में कुछ बदलावों के साथ।

टॉवर विधि

यहां टॉवर विधि लगभग बहु-सीपीयू प्रशिक्षण के समान है। उपयोग में आने वाले GPU की संख्या के अनुसार आपको बैच के आकार को मापना होगा।

TensorFlow मिरर की गई रणनीति

की डिफ़ॉल्ट उप-रणनीति MirroredStrategy is NcclAllReduce. आपको उपयोग में आने वाले GPU की संख्या के अनुसार बैच आकार को मापना होगा। निम्नलिखित कोड देखें:

mirrored_strategy = tf.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(train_distribute=mirrored_strategy,
				eval_distribute=mirrored_strategy)

कई उदाहरणों पर प्रशिक्षण में तेजी लाना

प्रशिक्षण की गति में सुधार के लिए स्केलिंग आउट हमेशा एक विकल्प होता है। अधिक से अधिक डेटा वैज्ञानिक इसे वितरित प्रशिक्षण के संबंध में एक डिफ़ॉल्ट विकल्प के रूप में चुनते हैं। इस खंड में, हम कई मेजबानों के साथ वितरित प्रशिक्षण के लिए रणनीतियों पर चर्चा करते हैं।

एकाधिक उदाहरणों के साथ एकाधिक CPU

वितरित प्रशिक्षण को सक्षम करते समय कई उदाहरणों के साथ कई सीपीयू का उपयोग करने के चार मुख्य तरीके हैं:

• • सीपीयू उपकरणों पर ऑपरेटरों की समानता को मैन्युअल रूप से सेट किए बिना पैरामीटर सर्वर
  • पैरामीटर सर्वर सीपीयू उपकरणों पर मैन्युअल रूप से ऑपरेटरों की समानांतरता को सेट करता है
  • टॉवर के साथ पैरामीटर सर्वर (सीपीयू उपकरणों को मैन्युअल रूप से सेट करना, और सेट करना) allow_soft_placement=True in tf.ConfigProto)
  • horovod

में पैरामीटर सर्वर का उपयोग करते समय tf.estimator एपीआई, चेकपॉइंट का पथ एक साझा करने योग्य पथ होना चाहिए जैसे कि अमेज़ॅन एस 3 या स्थानीय पथ अमेज़न इलास्टिक फ़ाइल सेवा (अमेज़ॅन ईएफएस) कंटेनर में मैपिंग। में एक पैरामीटर सर्वर के लिए tf.keras, चेकपॉइंट पथ को स्थानीय पथ पर सेट किया जा सकता है। होरोवोड के लिए, चेकपॉइंट पथ को प्रशिक्षण उदाहरण के स्थानीय पथ पर सेट किया जा सकता है।

पैरामीटर सर्वर का उपयोग करते समय और tf.estimator अमेज़ॅन एस 3 के चेकपॉइंट पथ के साथ एपीआई, यदि मॉडल काफी बड़ा है, तो आपको प्राथमिक की त्रुटि का सामना करना पड़ सकता है जो चेकपॉइंट को एस 3 में सहेजने पर फंस गया है। आप SageMaker बिल्ट-इन कंटेनर TensorFlow 1.15 या TensorFlow 1.15.2 का उपयोग कर सकते हैं या Amazon EFS को शेयर के चेकपॉइंट पथ के रूप में उपयोग कर सकते हैं।

एकाधिक होस्ट के लिए पैरामीटर सर्वर का उपयोग करते समय, प्रत्येक पैरामीटर सर्वर प्रक्रिया पर पैरामीटर लोड असंतुलित हो सकता है (विशेषकर जब अपेक्षाकृत बड़े एम्बेडिंग तालिका चर होते हैं), जो त्रुटियों का कारण बन सकता है। पैरामीटर सर्वर पर पैरामीटर संतुलित हैं या नहीं, यह निर्धारित करने के लिए आप अमेज़ॅन एस 3 में प्रत्येक शार्ड के चेकपॉइंट के फ़ाइल आकार की जांच कर सकते हैं, क्योंकि प्रत्येक पैरामीटर सर्वर चेकपॉइंट फ़ाइल के शार्ड से मेल खाता है। ऐसे मुद्दों से बचने के लिए, आप प्रत्येक पैरामीटर सर्वर के पैरामीटर को समान रूप से वितरित करने का प्रयास करने के लिए पार्टीशनर फ़ंक्शन का उपयोग कर सकते हैं:

with tf.variable_scope('deepfm_model', reuse=tf.AUTO_REUSE, partitioner = tf.fixed_size_partitioner(num_shards=len(FLAGS.hosts))):

एकाधिक उदाहरणों के साथ एकल GPU

SageMaker प्रशिक्षण कार्य ऐसे उदाहरणों का समर्थन करते हैं जिनमें केवल एक GPU होता है, जैसे ml.p3.xlarge, ml.g4dn, और ml.g5 श्रृंखला। इस परिदृश्य में उपयोग की जाने वाली दो मुख्य विधियाँ हैं: पैरामीटर सर्वर और होरोवोड।

सेजमेकर की अंतर्निहित पैरामीटर सर्वर वितरित प्रशिक्षण विधि प्रत्येक प्रशिक्षण उदाहरण के लिए एक पैरामीटर सर्वर प्रक्रिया और एक कार्यकर्ता प्रक्रिया शुरू करना है (प्रत्येक पैरामीटर सर्वर केवल मॉडल मापदंडों के हिस्से के लिए जिम्मेदार है), इसलिए डिफ़ॉल्ट मल्टी-मशीन सिंगल है- जीपीयू प्रशिक्षण। सेजमेकर बिल्ट-इन पैरामीटर सर्वर वितरित प्रशिक्षण एक एसिंक्रोनस ग्रेडिएंट अपडेट विधि है। प्रशिक्षण अभिसरण पर एसिंक्रोनस अपडेट के प्रभाव को कम करने के लिए, सीखने की दर को कम करने की सिफारिश की जाती है। यदि आप उदाहरण के लिए सभी GPU का उपयोग करना चाहते हैं, तो आपको पैरामीटर सर्वर और टावर विधि के संयोजन का उपयोग करने की आवश्यकता है।

होरोवोड के लिए, बस सेट करें processes_per_host=1 सेजमेकर पायथन एस्टिमेटर एपीआई के वितरण पैरामीटर में।

एकाधिक उदाहरणों के साथ एकाधिक GPU

पैरामीटर सर्वर और टॉवर विधि के लिए, कोड परिवर्तन मूल रूप से एक ही उदाहरण के लिए कई GPU के साथ टॉवर विधि के समान होते हैं, और GPU उपकरणों को मैन्युअल रूप से सेट करने की कोई आवश्यकता नहीं होती है।

होरोवोड के लिए, वितरण पैरामीटर में प्रक्रियाओं_पर_होस्ट को प्रत्येक प्रशिक्षण उदाहरण के GPU की संख्या पर सेट करें। यदि आप पाइप मोड का उपयोग करते हैं, तो प्रति उदाहरण श्रमिकों की संख्या को चैनलों की संख्या से मेल खाना चाहिए।

डेटा पाइपलाइन

हमने जिन बुनियादी ढांचे पर चर्चा की है, उनके अलावा एक और महत्वपूर्ण बात पर विचार करना है: डेटा पाइपलाइन। डेटा पाइपलाइन से तात्पर्य है कि आप डेटा को कैसे लोड करते हैं और डेटा को न्यूरल नेटवर्क में फीड करने से पहले कैसे बदलते हैं। CPU का उपयोग डेटा तैयार करने के लिए किया जाता है, जबकि GPU का उपयोग CPU से डेटा की गणना करने के लिए किया जाता है। चूंकि GPU एक महंगा संसाधन है, इसलिए अधिक GPU निष्क्रिय समय अक्षम है; आपके प्रशिक्षण कार्य में एक अच्छी डेटा पाइपलाइन GPU और CPU उपयोग में सुधार कर सकती है।

जब आप अपने TensorFlow डेटा इनपुट पाइपलाइन को ऑप्टिमाइज़ करने का प्रयास कर रहे हों, तो उपयोग किए गए API ऑर्डर पर विचार करें TensorFlow डेटासेट, प्रशिक्षण डेटा का आकार (बहुत सारी छोटी फाइलें या कई बड़ी फाइलें), बैच का आकार, और इसी तरह।

आइए प्रशिक्षण के दौरान GPU और CPU के बीच की बातचीत को देखें। निम्नलिखित आंकड़े पाइपलाइन के साथ और उसके बिना बातचीत की तुलना करते हैं।

एक बेहतर पाइपलाइन GPU के निष्क्रिय समय को कम कर सकती है। निम्नलिखित युक्तियों पर विचार करें:

• सुविधाओं और लेबलों को निकालने में सरल फ़ंक्शन लॉजिक का उपयोग करें
• मेमोरी के लिए नमूने प्रीफ़ेच करें
• अनावश्यक डिस्क I/O और नेटवर्किंग I/O को कम करें
• संसाधित सुविधाओं और लेबल को मेमोरी में कैश करें
• CPU और GPU के बीच प्रतिकृति समय की संख्या कम करें
• प्रशिक्षण डेटासेट के विभिन्न हिस्सों के साथ अलग-अलग कार्यकर्ता व्यवहार करें
• TensorFlow डेटासेट API को कॉल करने का समय कम करें

TensorFlow डेटासेट स्वरूपों से संबंधित एक परिवर्तन API प्रदान करता है, और TensorFlow में परिवर्तन API का क्रम प्रशिक्षण की गति को बहुत प्रभावित करता है। TensorFlow डेटासेट API को कॉल करने के सर्वोत्तम क्रम का परीक्षण करने की आवश्यकता है। निम्नलिखित कुछ बुनियादी सिद्धांत हैं:

• एक वेक्टरकृत मानचित्र का प्रयोग करें। इसका मतलब है कि पहले TensorFlow डेटासेट बैच API को कॉल करें, फिर डेटासेट मैप API को। मानचित्र फ़ंक्शन में प्रदान किया गया कस्टम पार्सिंग फ़ंक्शन, जैसे decode_tfrecord नमूना कोड में, डेटा के एक मिनी बैच को पार्स करता है। इसके विपरीत, पहले नक्शा और फिर बैच एक अदिश नक्शा है, और कस्टम पार्सर फ़ंक्शन केवल एक नमूने को संसाधित करता है।
• सुविधाओं और लेबल को कैश करने के लिए TensorFlow डेटासेट कैश API का उपयोग करें। TensorFlow डेटासेट कैश API को TensorFlow डेटासेट रिपीट API से पहले रखें, अन्यथा RAM का उपयोग युगों-युगों में रैखिक रूप से बढ़ता जाता है। यदि डेटासेट RAM जितना बड़ा है, तो TensorFlow डेटासेट कैश API का उपयोग न करें। यदि आपको TensorFlow डेटासेट कैश API और शफ़ल API का उपयोग करने की आवश्यकता है, तो निम्न क्रम का उपयोग करने पर विचार करें: TensorFlow डेटासेट ऑब्जेक्ट बनाएं -> कैश API -> शफ़ल API -> बैच API -> मैप API -> रिपीट API -> प्रीफ़ेच API।
• उपयोग tfrecord डेटासेट प्रारूप LibSVM प्रारूप से अधिक है।
• फ़ाइल मोड या पाइप मोड आपके डेटासेट प्रारूप और फ़ाइलों की मात्रा पर निर्भर करता है। tfrecorddataset एपीआई सेट कर सकते हैं num_parallel_reads समानांतर में कई फाइलों को पढ़ने और सेट करने के लिए buffer_size डेटा के पठन को अनुकूलित करने के लिए, जबकि pipemodedataset एपीआई में ऐसी सेटिंग्स नहीं हैं। पाइप मोड उन स्थितियों के लिए अधिक उपयुक्त है जहां एकल फ़ाइल बड़ी है और फ़ाइलों की कुल संख्या छोटी है। हम प्रीप्रोसेसिंग कार्य करने के लिए सेजमेकर प्रसंस्करण कार्य का उपयोग करने की सलाह देते हैं, जैसे कि लेबल के अनुसार एक से अधिक फ़ाइलों को एक बड़ी फ़ाइल में शामिल करना, डेटासेट को अधिक संतुलित बनाने के लिए एक नमूना पद्धति का उपयोग करना, और संतुलित डेटासेट को फेरबदल करना।

निम्नलिखित कोड नमूना देखें:

def decode_tfrecord(batch_examples):
        # The feature definition here should BE consistent with LibSVM TO TFRecord process.
        features = tf.parse_example(batch_examples,
                                           features={
                                               "label": tf.FixedLenFeature([], tf.float32),
                                               "ids": tf.FixedLenFeature(dtype=tf.int64, shape=[FLAGS.field_size]),
                                               "values": tf.FixedLenFeature(dtype=tf.float32, shape=[FLAGS.field_size]) 
                                           })
        
        batch_label = features["label"]
        batch_ids = features["ids"]
        batch_values = features["values"]
        
        return {"feat_ids": batch_ids, "feat_vals": batch_values}, batch_label


    def decode_libsvm(line):
        columns = tf.string_split([line], ' ')
        labels = tf.string_to_number(columns.values[0], out_type=tf.float32)
        splits = tf.string_split(columns.values[1:], ':')
        id_vals = tf.reshape(splits.values,splits.dense_shape)
        feat_ids, feat_vals = tf.split(id_vals,num_or_size_splits=2,axis=1)
        feat_ids = tf.string_to_number(feat_ids, out_type=tf.int32)
        feat_vals = tf.string_to_number(feat_vals, out_type=tf.float32)
        return {"feat_ids": feat_ids, "feat_vals": feat_vals}, labels

if FLAGS.pipe_mode == 0:
        dataset = tf.data.TFRecordDataset(filenames)
    else :
        # Enter Pipe mode
        dataset = PipeModeDataset(channel, record_format='TFRecord')
        
    if FLAGS.enable_s3_shard == False:
        host_rank = FLAGS.hosts.index(FLAGS.current_host)
        number_host = len(FLAGS.hosts)
        dataset = dataset.shard(number_host, host_rank)
    
    dataset = dataset.batch(batch_size, drop_remainder=True) # Batch size to use
    dataset = dataset.map(decode_tfrecord,
                          num_parallel_calls=tf.data.experimental.AUTOTUNE) 

    if num_epochs > 1:
        dataset = dataset.repeat(num_epochs)
    dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)

सीपीयू इंस्टेंस पर प्रशिक्षण के लिए, की समानता स्थापित करना intra op, inter op, और एमकेएल-डीएनएन का पर्यावरण चर एक अच्छा प्रारंभिक बिंदु है।

स्वचालित मिश्रित सटीक प्रशिक्षण

आखिरी बात जो हम चर्चा करते हैं वह स्वचालित मिश्रित सटीक प्रशिक्षण है, जो गति को तेज कर सकती है और मॉडल के प्रदर्शन में परिणाम कर सकती है। इस लेखन के समय, Nvidia V100 GPU (P3 उदाहरण) और A100 (P4dn उदाहरण) Tensor कोर का समर्थन करते हैं। इस प्रकार के इंस्टेंस का उपयोग करते समय आप TensorFlow में मिश्रित सटीक प्रशिक्षण सक्षम कर सकते हैं। संस्करण 1.14 से शुरू होकर, TensorFlow ने स्वचालित मिश्रित सटीक प्रशिक्षण का समर्थन किया है। आप अपने मूल अनुकूलक को लपेटने के लिए निम्नलिखित कथन का उपयोग कर सकते हैं:

tf.train.experimental.enable_mixed_precision_graph_rewrite(optimizer)

यदि मॉडल छोटा है और GPU का उपयोग कम है, तो स्वचालित मिश्रित सटीक प्रशिक्षण का कोई लाभ नहीं है। यदि मॉडल बड़ा है, तो स्वचालित मिश्रित सटीक प्रशिक्षण प्रशिक्षण की गति को तेज कर सकता है।

निष्कर्ष

जब आप सेजमेकर में अपना गहन शिक्षण मॉडल प्रशिक्षण शुरू करते हैं, तो तेज प्रशिक्षण गति प्राप्त करने के लिए निम्नलिखित युक्तियों पर विचार करें:

• पहले मल्टी-सीपीयू, सिंगल-इंस्टेंस मेथड या सिंगल-जीपीयू, सिंगल-इंस्टेंस मेथड आज़माएं। यदि CPU/GPU उपयोग बहुत अधिक है (उदाहरण के लिए 90% से अधिक), तो अगले चरण पर जाएँ।
• एकल होस्ट में अधिक CPU या एकल होस्ट में अधिक GPU आज़माएं। यदि उपयोग CPU या GPU के अधिकतम उपयोग के निकट है, तो अगले चरण पर जाएँ।
• एकाधिक होस्ट के साथ एकाधिक CPU या एकाधिक GPU आज़माएं।
• पैरामीटर सर्वर या होरोवोड का उपयोग करते समय आपको कोड संशोधित करने की आवश्यकता होती है। कोड संशोधन TensorFlow सत्र-आधारित API के लिए समान नहीं है, tf.estimator एपीआई, और tf.keras एपीआई। एक पैरामीटर सर्वर या होरोवोड अलग-अलग प्रशिक्षण मामलों और कार्यों में अलग-अलग प्रशिक्षण गति दिखा सकता है, इसलिए यदि आपके पास सबसे अच्छा निर्धारित करने के लिए समय और बजट है तो दोनों तरीकों का प्रयास करें।

निम्नलिखित सलाह को ध्यान में रखें:

• स्केलिंग से पहले उपयोग की जांच करें, अपनी डेटा पाइपलाइन को ऑप्टिमाइज़ करें और सीपीयू और जीपीयू को टाइमलाइन में ओवरलैप करें।
• पहले स्केल अप करें, फिर स्केल आउट करें।
• यदि आप सभी विधियों के बाद अपने GPU उपयोग को नहीं बढ़ा सकते हैं, तो CPU का प्रयास करें। ऐसे कई मामले हैं (विशेषकर क्लिकथ्रू दर रैंकिंग मॉडल के लिए) जहां CPU इंस्टेंस प्रशिक्षण का कुल प्रशिक्षण समय GPU इंस्टेंस प्रशिक्षण की तुलना में कम और अधिक लागत प्रभावी है।

हमारे पास एक कोड नमूना भी है गीथहब रेपो, जहां हम सेजमेकर पर डीपएफएम वितरित प्रशिक्षण के दो नमूने दिखाते हैं। एक CPU इंस्टेंस पर TensorFlow पैरामीटर सर्वर है, दूसरा GPU इंस्टेंस पर Horovod है।

लेखक के बारे में

युहुई लिआंग एक सीनियर मशीन लर्निंग सॉल्यूशंस आर्किटेक्ट हैं। उन्होंने मशीन लर्निंग के प्रचार और अनुप्रयोग पर ध्यान केंद्रित किया है, और कई ग्राहकों की मशीन लर्निंग परियोजनाओं में गहराई से शामिल है। उन्हें गहन शिक्षण वितरित प्रशिक्षण, अनुशंसा प्रणाली और कम्प्यूटेशनल विज्ञापन में समृद्ध अनुभव है।

शिशुई वांगो एक सीनियर मशीन लर्निंग सॉल्यूशंस आर्किटेक्ट हैं। वह बड़े पैमाने पर मशीन लर्निंग को अपनाने में मदद करने के लिए AWS ग्राहकों के साथ काम करता है। उन्हें फिल्में देखना और दुनिया भर में घूमना पसंद है।