TensorFlow और Amazon SageMaker के साथ टेराबाइट्स डेटा पर एक अरब-पैरामीटर भाषा मॉडल बनाएं, प्रशिक्षित करें और तैनात करें

भाषा मॉडल का बढ़ता आकार हाल के वर्षों में प्राकृतिक भाषा प्रसंस्करण (एनएलपी) में सबसे बड़े रुझानों में से एक रहा है। 2018 के बाद से, हमने BERT और इसके वेरिएंट, GPT-2, T-NLG और GPT-3 (175 बिलियन पैरामीटर) सहित बड़े भाषा मॉडल का अभूतपूर्व विकास और तैनाती देखी है।

इन मॉडलों ने संभावित वास्तुशिल्प नवाचारों की सीमाओं को आगे बढ़ाया है। बड़े पैमाने पर गहन शिक्षण मॉडल, विशेष रूप से जेनरेटर पूर्व-प्रशिक्षित ट्रांसफार्मर की नई लहर का प्रशिक्षण करते समय हमें कई चुनौतियों का सामना करना पड़ता है। इन चुनौतियों में हार्डवेयर सीमाएँ और गणना और दक्षता के साथ व्यापार-बंद शामिल हैं। मॉडल और डेटा समानता की इन चुनौतियों से पार पाने के लिए, AWS क्षमताओं की एक विस्तृत श्रृंखला प्रदान करता है।

इस पोस्ट में, हम दो मुख्य दृष्टिकोण प्रस्तुत करते हैं: डेटा समानांतरीकरण और मॉडल समानांतरीकरण का उपयोग करना अमेज़न SageMaker, और उनके पेशेवरों और विपक्षों पर चर्चा करें।

आदर्श

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

हम टोकन और पोजिशनल एम्बेडिंग के लिए दो एम्बेडिंग परतें बनाकर शुरुआत करते हैं। इनपुट एम्बेडिंग टोकन एम्बेडिंग और स्थिति एम्बेडिंग का योग है।

class TokenAndPositionEmbedding(tf.keras.layers.Layer): """ Creates two separate embedding layers: one for tokens and one for token index (positions). """ def __init__(self, maxlen, vocab_size, embed_dim): super(TokenAndPositionEmbedding, self).__init__() self.token_emb = tf.keras.layers.Embedding(input_dim=vocab_size, output_dim=embed_dim) self.pos_emb = tf.keras.layers.Embedding(input_dim=maxlen, output_dim=embed_dim) def call(self, x): maxlen = tf.shape(x)[-1] # positions are represented by a token's index positions = tf.range(start=0, limit=maxlen, delta=1) positions = self.pos_emb(positions) # token embedding x = self.token_emb(x) # return sum as input return x + positions

फिर हम दो उप-परतों के साथ एक ट्रांसफॉर्मर डिकोडर ब्लॉक को परिभाषित करते हैं: एक मल्टी-हेड सेल्फ-अटेंशन लेयर, और एक सरल पूरी तरह से कनेक्टेड फीड-फॉरवर्ड नेटवर्क जिसके बाद लेयर सामान्यीकरण और ड्रॉपआउट होता है:

class TransformerBlock(tf.keras.layers.Layer): def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1): # self attention layer super(TransformerBlock, self).__init__() self.att = tf.keras.layers.MultiHeadAttention( num_heads=num_heads, key_dim=embed_dim) # feed forward layer self.ffn = [tf.keras.layers.Dense(ff_dim, activation="relu"), tf.keras.layers.Dense(embed_dim)] # layer normalization self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6) self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6) # dropout self.dropout1 = tf.keras.layers.Dropout(rate) self.dropout2 = tf.keras.layers.Dropout(rate) def call(self, inputs): # getting batch size and seq len from input shape input_shape = tf.shape(inputs) batch_size = input_shape[0] seq_len = input_shape[1] # decoder casual mask casual_mask = casual_attention_mask(batch_size, seq_len, seq_len, tf.bool) # self attention forward pass attention_output = self.att(inputs, inputs, attention_mask=causal_mask) # dense layers, dropout and normalization attention_output = self.dropout1(attention_output) ffn_output = self.ffn[0](out1) ffn_output = self.ffn[1](ffn_output) out2 = self.dropout2(ffn_output) return self.layernorm2(out1 + out2)

अंत में, हम पूर्ववर्ती एम्बेडिंग परत और ट्रांसफार्मर ब्लॉक के साथ अपना भाषा मॉडल बनाते हैं:

class MyModel(tf.keras.Model): def __init__(self, maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): super(MyModel, self).__init__(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) # embedding layer self.embedding_layer = TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) # transformer blocks self.transformer_blocks = [ TransformerBlock(embed_dim, num_heads, feed_forward_dim) for i in range(num_layers) ] # last dense layer self.dense = tf.keras.layers.Dense(vocab_size) def call(self, inputs, training=None): x_emb = self.embedding_layer(inputs) x = x_emb for transformer_block in self.transformer_blocks: x = transformer_block(x) outputs = self.dense(x) return [outputs, x_emb] def init_train_settings(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): """ Creates model, optimizer and loss function """ model = MyModel(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate) return model, optimizer, loss_fn

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

डेटासेट

हमारे प्रयोगों में, हमने इसका उपयोग किया ढेर डेटासेट. पाइल एक 800 GiB अंग्रेजी टेक्स्ट डेटासेट है जिसे बड़े पैमाने पर भाषा मॉडल के प्रशिक्षण के लिए डिज़ाइन किया गया है। इसे 22 विविध और उच्च-गुणवत्ता वाले डेटासेट से बनाया गया है, जिसमें स्थापित एनएलपी डेटासेट और नए पेश किए गए दोनों डेटासेट शामिल हैं।

डेटासेट पुस्तकों सहित विभिन्न डेटा स्रोतों से बनाया गया है; GitHub रिपॉजिटरी; वेब पृष्ठ; चैट लॉग; और चिकित्सा, भौतिकी, गणित, कंप्यूटर विज्ञान और दर्शनशास्त्र के पेपर। विशेष रूप से, यह निम्नलिखित स्रोतों का उपयोग करता है: पाइल-सीसी, पबमेड सेंट्रल, आर्क्सिव, गिटहब, फ्रीलॉ प्रोजेक्ट, स्टैक एक्सचेंज, यूएस पेटेंट और ट्रेडमार्क कार्यालय, पबमेड, उबंटू, आईआरसी, हैकरन्यूज, यूट्यूब, फिलपेपर्स, बुक्स3, प्रोजेक्ट गुटेनबर्ग ( पीजी-19), ओपनसबटाइटल्स, अंग्रेजी विकिपीडिया, डीएम गणित, यूरोपार्ल, एनरॉन ईमेल कॉर्पस, और एनआईएच एक्सपोर्टर। इसमें OpenWebText2 और BookCorpus2 भी शामिल हैं, जो क्रमशः मूल OpenWebText और BookCorpus डेटासेट के एक्सटेंशन हैं। डेटा स्रोतों में विविधता सामान्य क्रॉस-डोमेन ज्ञान में सुधार कर सकती है और परिणामस्वरूप डाउनस्ट्रीम सामान्यीकरण क्षमताओं में सुधार कर सकती है।

इस डेटासेट के साथ प्राथमिक चुनौती इसका विशाल आकार है; डेटासेट में 825 GiB टेक्स्ट है, जो 4.2 TiB पूर्व-संसाधित और संपीड़ित डेटापॉइंट में परिवर्तित होता है। मॉडलों को प्रशिक्षित करने और होस्ट करने में हमें जिन चुनौतियों का सामना करना पड़ता है, उसी तरह, एक ही उदाहरण पर इस डेटासेट के साथ एक मॉडल को प्रशिक्षित करने में बहुत समय लगेगा और यह व्यावहारिक नहीं है।

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

इसके बाद, हम इन चुनौतियों से निपटने के लिए वितरित प्रशिक्षण रणनीतियों पर गौर करते हैं।

वितरित प्रशिक्षण

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

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

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

डेटा समानांतरीकरण

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

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

1. दौड़कर आरंभ करें hvd.init().
2. प्रत्येक डिवाइस को एक ही प्रक्रिया से संबद्ध करें। पहली प्रक्रिया या कार्यकर्ता पहले डिवाइस से जुड़ा होता है, दूसरी प्रक्रिया दूसरे डिवाइस से जुड़ी होती है, इत्यादि।
3. उपकरणों की संख्या के आधार पर सीखने की दर को समायोजित करें।
4. ऑप्टिमाइज़र को लपेटें hvd.DistributedOptimizer.
5. रैंक 0 वाले पहले कार्यकर्ता से अन्य सभी प्रक्रियाओं तक प्रारंभिक परिवर्तनशील स्थिति प्रसारित करें। जब प्रशिक्षण यादृच्छिक भार के साथ शुरू किया जाता है या किसी चेकपॉइंट से बहाल किया जाता है, तो सभी श्रमिकों की लगातार शुरुआत सुनिश्चित करने के लिए यह आवश्यक है।
6. सुनिश्चित करें कि केवल डिवाइस 0 ही अन्य कर्मचारियों को उन्हें भ्रष्ट करने से रोकने के लिए चौकियों को बचा सकता है।

निम्नलिखित प्रशिक्षण स्क्रिप्ट है:

import horovod.tensorflow as hvd
# Initialize Horovod
hvd.init() # Pin GPU to be used to process local rank (one GPU per process)
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True)
if gpus: tf.config.experimental.set_visible_devices(gpus[hvd.local_rank()], 'GPU') # Build model
... @tf.function
def training_step(texts, labels, first_batch): with tf.GradientTape() as tape: predictions = model(texts, training=True) loss = loss_fn(labels, predictions[0]) # Horovod: add Horovod Distributed GradientTape. tape = hvd.DistributedGradientTape(tape) grads = tape.gradient(loss, model.trainable_variables) opt.apply_gradients(zip(grads, model.trainable_variables)) # Horovod: broadcast initial variable states from rank 0 to all other processes. # This is necessary to ensure consistent initialization of all workers when # training is started with random weights or restored from a checkpoint. # # Note: broadcast should be done after the first gradient step to ensure optimizer # initialization. if first_batch: hvd.broadcast_variables(model.variables, root_rank=0) hvd.broadcast_variables(opt.variables(), root_rank=0) return loss # Horovod: adjust number of steps based on number of GPUs.
for batch, (texts, labels) in enumerate(dataset.take(10000 // hvd.size())): loss = training_step(texts, labels, batch == 0) if batch % 10 == 0 and hvd.local_rank() == 0: print('Step #%dtLoss: %.6f' % (batch, loss)) # Horovod: save checkpoints only on worker 0 to prevent other workers from
# corrupting it.
if hvd.rank() == 0: checkpoint.save(checkpoint_dir)

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

1. आयात करें और प्रारंभ करें sdp.init().
2. प्रत्येक डिवाइस को एक के साथ संबद्ध करें smdistributed.dataparallel के साथ प्रक्रिया local_rank. sdp.tensorflow.local_rank() हमें उपकरणों की स्थानीय रैंक देता है। नेता रैंक 0 है, और कार्यकर्ता रैंक 1, 2, 3, इत्यादि हैं।
3. उपकरणों की संख्या के आधार पर सीखने की दर को समायोजित करें।
4. लपेटें tf.GradientTape साथ में DistributedGradientTape प्रदर्शन करने के लिए AllReduce.
5. प्रारंभिक मॉडल चर को लीडर नोड से सभी कार्यकर्ता नोड्स तक प्रसारित करें।
6. सुनिश्चित करें कि केवल डिवाइस 0 ही चौकियों को बचा सकता है।

मॉडल समानांतरीकरण

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

1. लाइब्रेरी को आयात और प्रारंभ करें smp.init().
2. केरस मॉडल को केरस मॉडल वर्ग के बजाय smp.DistributedModel से इनहेरिट करने की आवश्यकता है।
3. सेट drop_remainder=True में tf.Dataset.batch() यह सुनिश्चित करने की विधि कि बैच का आकार हमेशा माइक्रोबैच की संख्या से विभाज्य हो।
4. डेटा पाइपलाइन में यादृच्छिक संचालन के लिए सभी को एक ही बीज का उपयोग करने की आवश्यकता होती है: smp.dp_rank()उदाहरण के लिए, shuffle(ds, seed=smp.dp_rank()). यह विभिन्न मॉडल विभाजन रखने वाले उपकरणों में डेटा नमूनों की स्थिरता सुनिश्चित करता है।
5. फॉरवर्ड और बैकवर्ड लॉजिक को एक चरणबद्ध फ़ंक्शन में होना आवश्यक है smp.step सजावट।
6. जैसे स्टेपआउटपुट विधियों का उपयोग करके माइक्रोबैच में आउटपुट पर पोस्टप्रोसेसिंग करें reduce_mean। smp.step फ़ंक्शन का रिटर्न मान होना चाहिए जो आउटपुट पर निर्भर करता है smp.DistributedModel.

प्रशिक्षण स्क्रिप्ट इस प्रकार है:

import smdistributed.modelparallel.tensorflow as smp # SMP: Initialize
smp.init() # SMP: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel): def __init__(self, maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate): super(MyModel, self).__init__(maxlen, vocab_size, embed_dim, num_heads, feed_forward_dim, num_layers, learning_rate) self.embedding_layer = gpt_model.TokenAndPositionEmbedding(maxlen, vocab_size, embed_dim) self.transformer_blocks = [ gpt_model.TransformerBlock(embed_dim, num_heads, feed_forward_dim) for i in range(num_layers) ] self.dense = tf.keras.layers.Dense(vocab_size) def call(self, inputs, training=None): x_emb = self.embedding_layer(inputs) x = x_emb for transformer_block in self.transformer_blocks: x = transformer_block(x) outputs = self.dense(x) return [outputs, x_emb] # SMP: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(texts, labels): predictions = model(texts, training=True) loss = loss_fn(labels, predictions[0]) grads = optimizer.get_gradients(loss, model.trainable_variables) return grads, loss, predictions[0] @tf.function
def train_step(texts, labels, first_batch): gradients, loss, predictions = get_grads(texts, labels) # SMP: Accumulate the gradients across microbatches gradients = [g.accumulate() for g in gradients] optimizer.apply_gradients(zip(gradients, model.trainable_variables)) # SMP: Average the loss across microbatches train_loss(loss.reduce_mean()) # SMP: Merge predictions across microbatches train_accuracy(labels, predictions.merge()) return loss.reduce_mean() histories = [] for _ in range(epochs): train_loss.reset_states() train_accuracy.reset_states() for texts, labels in text_ds: for i in range(128): text = tf.expand_dims(texts[0][i], axis=0) label = tf.expand_dims(labels[0][i], axis=0) train_step(text, label) 

सेजमेकर वितरित मॉडल समानांतर लाइब्रेरी के लिए टेन्सरफ्लो प्रशिक्षण स्क्रिप्ट को सक्षम करने के लिए एक विस्तृत मार्गदर्शिका के लिए, देखें TensorFlow प्रशिक्षण स्क्रिप्ट को संशोधित करें. PyTorch के लिए, देखें एक PyTorch प्रशिक्षण स्क्रिप्ट को संशोधित करें.

सेजमेकर डिबगर

पिछले अनुभागों में, हमने चर्चा की कि मॉडल और डेटा समानांतरीकरण तकनीकों का उपयोग करके प्रशिक्षण को कैसे अनुकूलित किया जाए। साथ अमेज़न SageMaker डिबगर, अब हम यह निर्धारित करने के लिए अपने प्रशिक्षण दौरों से प्रदर्शन प्रोफ़ाइलिंग जानकारी प्राप्त कर सकते हैं कि प्रशिक्षण में कितना सुधार हुआ है। डिफ़ॉल्ट रूप से, डिबगर 500 मिलीसेकंड के नमूना अंतराल पर प्रत्येक सेजमेकर प्रशिक्षण कार्य जैसे जीपीयू, सीपीयू उपयोग, मेमोरी, नेटवर्क और आई/ओ के लिए सिस्टम मेट्रिक्स को कैप्चर करता है। हम डेटा तक इस प्रकार पहुंच सकते हैं:

from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob('SMD-MP-demo-2022-01-21-06-43-23-841', "us-east-1")
tj.wait_for_sys_profiling_data_to_be_available()
system_metrics_reader = tj.get_systems_metrics_reader()

डिबगर उपयोगिताएँ प्रदान करता है कल्पना प्रोफाइलिंग डेटा अलग-अलग तरीकों से। निम्नलिखित उदाहरण में, हम होरोवोड का उपयोग करके मल्टी-जीपीयू प्रशिक्षण कार्य के लिए कुल जीपीयू और सीपीयू उपयोग के साथ-साथ I/O प्रतीक्षा समय देखते हैं। इन ग्राफ़ को उत्पन्न करने के लिए, हम निम्नलिखित कोड चलाते हैं:

from smdebug.profiler.analysis.notebook_utils.timeline_charts import TimelineCharts view_timeline_charts = TimelineCharts( system_metrics_reader, framework_metrics_reader, select_dimensions=["CPU", "GPU", "I/O"], select_events=["total"], show_workers=False )

GPU उपयोग अक्सर 0-100% के बीच उतार-चढ़ाव करता है, और कम GPU उपयोग के साथ उच्च I/O प्रतीक्षा समय I/O बाधा का संकेतक है। इसके अलावा, कुल सीपीयू उपयोग कभी भी 70% से अधिक नहीं होता है, जिसका अर्थ है कि हम कार्यकर्ता प्रक्रियाओं की संख्या बढ़ाकर डेटा प्रीप्रोसेसिंग में सुधार कर सकते हैं।

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

प्रशिक्षण बुनियादी ढांचा

मॉडलों को प्रशिक्षित करने के लिए, हमने सेजमेकर प्रशिक्षण कार्य का उपयोग करके 10 ml.p3.16xबड़े उदाहरणों का उपयोग किया। सेजमेकर बुनियादी ढांचे के प्रबंधन की आवश्यकता के बिना मशीन लर्निंग (एमएल) मॉडल को प्रशिक्षित करने और ट्यून करने में लगने वाले समय और लागत को कम करता है। सेजमेकर के साथ, आप प्रशिक्षण प्रयोगों को प्रबंधित और ट्रैक करने के लिए अंतर्निहित टूल का उपयोग करके एमएल मॉडल को आसानी से प्रशिक्षित और ट्यून कर सकते हैं, स्वचालित रूप से इष्टतम हाइपरपैरामीटर चुन सकते हैं, प्रशिक्षण कार्य डिबग कर सकते हैं और जीपीयू, सीपीयू और नेटवर्क बैंडविड्थ जैसे सिस्टम संसाधनों के उपयोग की निगरानी कर सकते हैं। डेटा को अमेज़ॅन ईएफएस में होस्ट किया गया था, जिसने हमें प्रबंधन या प्रावधान की आवश्यकता के बिना फ़ाइलों को जोड़ने और हटाने के दौरान बढ़ने और सिकुड़ने में सक्षम बनाया। हमारा प्राथमिक उद्देश्य प्रशिक्षण की गति में सुधार करना और लागत कम करना था।

मॉडल मापनीयता

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

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

व्यापार नापसंद

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

निष्कर्ष

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

सेजमेकर के साथ मॉडल समानता के बारे में अधिक जानकारी के लिए देखें अमेज़ॅन सेजमेकर पर मॉडल समानांतर परिवर्धन और हगिंग फेस के साथ 175+ बिलियन पैरामीटर एनएलपी मॉडल को प्रशिक्षित करें और कैसे लेटेंट स्पेस ने बड़े पैमाने पर ट्रांसफॉर्मर के फ्रंटर्स को पुश करने के लिए अमेज़ॅन सैजमेकर मॉडल समानता पुस्तकालय का उपयोग किया.

यदि आप अपने उत्पादों और प्रक्रियाओं में एमएल के उपयोग को तेज करने में मदद करना चाहते हैं, तो कृपया संपर्क करें अमेज़न एमएल सॉल्यूशंस लैब.

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

सिया घोलमी अमेज़ॅन एमएल सॉल्यूशंस लैब में एक वरिष्ठ डेटा वैज्ञानिक हैं, जहां वे विभिन्न उद्योगों में ग्राहकों के लिए एआई/एमएल समाधान तैयार करते हैं। उन्हें नेचुरल लैंग्वेज प्रोसेसिंग (एनएलपी) और डीप लर्निंग का शौक है। काम के अलावा, सिया को प्रकृति में समय बिताना और टेनिस खेलना पसंद है।

मेहदी नूरीअमेज़ॅन एमएल सॉल्यूशंस लैब में एक प्रबंधक और एक वरिष्ठ एप्लाइड वैज्ञानिक हैं, जहां वह विभिन्न उद्योगों में ग्राहकों के साथ काम करते हैं, और उनकी क्लाउड माइग्रेशन यात्रा को तेज करने और अत्याधुनिक समाधानों का उपयोग करके उनकी एमएल समस्याओं को हल करने में मदद करते हैं और प्रौद्योगिकियाँ।

मुय्युन किम अमेज़न मशीन लर्निंग सॉल्यूशंस लैब में एक डेटा वैज्ञानिक है। वह मशीन लर्निंग और डीप लर्निंग लागू करके ग्राहक की विभिन्न व्यावसायिक समस्याओं को हल करता है, और उन्हें कुशल बनाने में भी मदद करता है।

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

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

योहेई नाकायमा अमेज़ॅन एमएल सॉल्यूशंस लैब में डीप लर्निंग आर्किटेक्ट हैं। वह विभिन्न क्षेत्रों के ग्राहकों के साथ उनकी व्यावसायिक चुनौतियों को हल करने के लिए कृत्रिम बुद्धिमत्ता और एडब्ल्यूएस क्लाउड सेवाओं के उपयोग में तेजी लाने के लिए काम करता है। वह अंतरिक्ष उद्योग में एमएल/एआई प्रौद्योगिकियों को लागू करने में रुचि रखते हैं।

नाथाली रौश्माय्र AWS में एक वरिष्ठ एप्लाइड साइंटिस्ट हैं, जहां वह ग्राहकों को गहन शिक्षण एप्लिकेशन विकसित करने में मदद करती हैं।

• कॉइनस्मार्ट। यूरोप का सर्वश्रेष्ठ बिटकॉइन और क्रिप्टो एक्सचेंज।
• प्लेटोब्लॉकचैन। Web3 मेटावर्स इंटेलिजेंस। ज्ञान प्रवर्धित। नि: शुल्क प्रवेश।
• क्रिप्टोहॉक। Altcoin रडार। मुफ्त परीक्षण।
• स्रोत: https://aws.amazon.com/blogs/machine-learning/create-train-and-deploy-a-billion-parameter-langageage-model-on-terabytes-of-data-with-tensorflow-and- अमेज़न-सेजमेकर/