हगिंग फेस में अत्याधुनिक वीआईटी मॉडल को गति दें डेटाब्रिक्स, एनवीडिया और स्पार्क एनएलपी के साथ 2300% (25x गुना तेज) तक

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

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

इस लेख में मैं करूंगा:

पूर्ण पारदर्शिता की भावना में, सभी नोटबुक उनके लॉग, स्क्रीनशॉट और यहां तक कि संख्याओं के साथ एक्सेल शीट यहां GitHub पर उपलब्ध कराई गई हैं।

विजन ट्रांसफॉर्मर (वीआईटी) मॉडल का परिचय

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

थोड़ा ट्रांसफॉर्मर इतिहास https://huggingface.co/course/chapter1/4

" ट्रांसफॉर्मर कैसे काम करते हैं " के बारे में एक महान अध्याय है, जिसे मैं पढ़ने के लिए अत्यधिक अनुशंसा करता हूं यदि आप रुचि रखते हैं।

हालांकि ये नए ट्रांसफॉर्मर-आधारित मॉडल एनएलपी कार्यों में क्रांतिकारी बदलाव कर रहे हैं, कंप्यूटर विजन (सीवी) में उनका उपयोग काफी सीमित रहा। कंप्यूटर विज़न के क्षेत्र में कनवल्शनल न्यूरल नेटवर्क (सीएनएन) के उपयोग का वर्चस्व रहा है और सीएनएन (जैसे रेसनेट) पर आधारित लोकप्रिय आर्किटेक्चर हैं। यह तब तक था जब तक कि Google ब्रेन में शोधकर्ताओं की एक और टीम ने जून 2021 में "विज़न ट्रांसफॉर्मर" (ViT) को एक पेपर में पेश किया, जिसका शीर्षक था: " एक इमेज इज़ वर्थ 16x16 वर्ड्स: ट्रांसफॉर्मर्स फॉर इमेज रिकॉग्निशन एट स्केल "

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

Google अनुसंधान के मूल 2021 पेपर में पेश किए गए वीआईटी मॉडल संरचना का एक सिंहावलोकन

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

लोकप्रिय छवि वर्गीकरण बेंचमार्क पर अत्याधुनिक के साथ तुलना। ( https://arxiv.org/pdf/2010.11929.pdf )

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

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

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

[1]: डीप डाइव: विजन ट्रांसफॉर्मर्स ऑन हगिंग फेस ऑप्टिमम ग्राफकोर https://huggingface.co/blog/vision-transformers

कार्रवाई में कुछ वीआईटी मॉडल

विजन ट्रांसफॉर्मर (वीआईटी) मॉडल (विट -बेस-पैच16-224 ) इमेजनेट-21k (14 मिलियन इमेज, 21,843 वर्ग) पर पूर्व-प्रशिक्षित 224x224 रिज़ॉल्यूशन पर, और इमेजनेट 2012 (1 मिलियन इमेज, 1,000 क्लास) पर फाइन-ट्यून किया गया। संकल्प 224x224:

https://huggingface.co/google/vit-base-patch16-224

खाद्य वर्गीकरण के लिए उपयोग किए जाने वाले फाइन-ट्यून वीआईटी मॉडल:

https://huggingface.co/nateraw/food — https://huggingface.co/julien-c/hotdog-not-hotdog

हालांकि जब भविष्यवाणी की बात आती है तो किसी भी डीएल/एमएल मॉडल की सीमाएं और प्रतिबंध होते हैं। 100% सटीकता वाला कोई मॉडल नहीं है, इसलिए ध्यान रखें कि जब आप हेल्थकेयर जैसी किसी महत्वपूर्ण चीज़ के लिए उनका उपयोग कर रहे हों:

छवि यहां से ली गई है: https://www.akc.org/expert-advice/lifestyle/do-you-live-in-dog-state-or-cat-state/ — वीआईटी मॉडल : https://huggingface.co /जुलिएन-सी/हॉटडॉग-नॉट-हॉटडॉग

क्या हम इन मॉडलों को हगिंग फेस से उपयोग कर सकते हैं या नए वीआईटी मॉडल को फाइन-ट्यून कर सकते हैं और वास्तविक उत्पादन में अनुमान के लिए उनका उपयोग कर सकते हैं? AWS EMR, Azure Insight, GCP Dataproc, या Databricks जैसी वितरित गणनाओं के लिए प्रबंधित सेवाओं का उपयोग करके हम उन्हें कैसे माप सकते हैं?

उम्मीद है, इनमें से कुछ का जवाब इस लेख के अंत तक मिल जाएगा।

बेंचमार्क शुरू होने दें!

हमारे बेंचमार्क के बारे में कुछ विवरण:

1- डेटासेट: इमेजनेट मिनी: नमूना (>3K) - पूर्ण (>34K)

मैंने कागल से इमेजनेट 1000 (मिनी) डेटासेट डाउनलोड किया है: https://www.kaggle.com/datasets/ifigotin/imagenetmini-1000

मैंने 34K से अधिक छवियों के साथ ट्रेन निर्देशिका को चुना है और इसे इमेजनेट-मिनी कहा है क्योंकि मुझे बेंचमार्क करने के लिए पर्याप्त छवियों की आवश्यकता थी जो अधिक समय लेती हैं। इसके अलावा, मैंने यादृच्छिक रूप से पूर्ण डेटासेट के 10% से कम का चयन किया है और इसे इमेजनेट-मिनी-नमूना कहा है जिसमें मेरे छोटे बेंचमार्क के लिए 3544 छवियां हैं और बैच आकार जैसे सही पैरामीटर को ठीक करने के लिए भी हैं।

2- मॉडल: Google द्वारा " विट-बेस-पैच16–224 "

हम हगिंग फेस पर होस्ट किए गए Google के इस मॉडल का उपयोग करेंगे: https://huggingface.co/google/vit-base-patch16-224

3- पुस्तकालय: ट्रांसफॉर्मर और स्पार्क एनएलपी

बेयर मेटल सर्वर पर बेंचमार्किंग हगिंग फेस

Dell PowerEdge C4130 . पर वीआईटी मॉडल

बेयर-मेटल सर्वर क्या है? एक नंगे धातु सर्वर केवल एक भौतिक कंप्यूटर है जिसका उपयोग केवल एक उपयोगकर्ता द्वारा किया जा रहा है। इस मशीन पर कोई हाइपरविजर स्थापित नहीं है, कोई वर्चुअलाइजेशन नहीं है, और सब कुछ सीधे मुख्य ओएस (लिनक्स - उबंटू) पर निष्पादित किया जा रहा है - सीपीयू, जीपीयू और इस मशीन की मेमोरी के विस्तृत विनिर्देश नोटबुक के अंदर हैं।

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

TensorFlow सबसे अधिक उपयोग किया जाने वाला गहन शिक्षण ढांचा है

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

 from transformers import ViTFeatureExtractor, ViTForImageClassification from PIL import Image import requests url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream= True ).raw) feature_extractor = ViTFeatureExtractor.from_pretrained( 'google/vit-base-patch16-224' ) model = ViTForImageClassification.from_pretrained( 'google/vit-base-patch16-224' ) inputs = feature_extractor(images=image, return_tensors= "pt" ) outputs = model(**inputs) logits = outputs.logits # model predicts one of the 1000 ImageNet classes
predicted_class_idx = logits.argmax(- 1 ).item() print("Predicted class:", model.config.id2label [predicted_class_idx] )

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

छवि वर्गीकरण के लिए एक सरल पाइपलाइन इस तरह दिखेगी:

 from transformers import ViTFeatureExtractor, ViTForImageClassification from transformers import pipeline feature_extractor = ViTFeatureExtractor.from_pretrained( 'google/vit-base-patch16-224' ) model = ViTForImageClassification.from_pretrained( 'google/vit-base-patch16-224' ) pipe = pipeline( "image-classification" , model=model, feature_extractor=feature_extractor, device=- 1 )

दस्तावेज़ीकरण के अनुसार, मैंने फीचर एक्सट्रैक्टर और मॉडल (पाठ्यक्रम के PyTorch चौकियों) के लिए google/vit-base-patch16–224 को डाउनलोड/लोड किया है ताकि उन्हें कार्य के रूप में छवि वर्गीकरण के साथ पाइपलाइन में उपयोग किया जा सके। इस पाइपलाइन में 3 चीजें हैं जो हमारे बेंचमार्क के लिए महत्वपूर्ण हैं:

> डिवाइस : यदि यह -1 (डिफ़ॉल्ट) है तो यह केवल CPU का उपयोग करेगा, जबकि यदि यह एक सकारात्मक पूर्णांक संख्या है तो यह संबंधित CUDA डिवाइस आईडी पर मॉडल चलाएगा। यहां इस नंबर पर भरोसा करें)।

> बैच_साइज: जब पाइपलाइन डेटालोडर का उपयोग करेगी (जब एक डेटासेट पास करते समय, एक पाइटोरच मॉडल के लिए जीपीयू पर), उपयोग करने के लिए बैच का आकार, अनुमान के लिए हमेशा फायदेमंद नहीं होता है।

> GPU पर हगिंग फेस पाइपलाइनों में बैचिंग का पूरा लाभ उठाने के लिए आपको DataLoader या PyTorch Dataset का उपयोग करना होगा।

इससे पहले कि हम बेंचमार्क के साथ आगे बढ़ें, आपको अनुमान के लिए हगिंग फेस पाइपलाइनों में बैचिंग के बारे में एक बात जाननी होगी, कि यह हमेशा काम नहीं करता है। जैसा कि हगिंग फेस के दस्तावेज़ीकरण में कहा गया है, बैच_साइज़ सेट करने से आपकी पाइपलाइन का प्रदर्शन बिल्कुल भी नहीं बढ़ सकता है। यह आपकी पाइपलाइन को धीमा कर सकता है:

https://huggingface.co/docs/transformers/main_classes/pipelines#pipeline-batching

निष्पक्ष होने के लिए, मेरे बेंचमार्क में मैंने 1 से शुरू होने वाले बैच आकारों की एक श्रृंखला का उपयोग किया ताकि यह सुनिश्चित हो सके कि मुझे उनमें से सबसे अच्छा परिणाम मिल सकता है। इस प्रकार मैंने सीपीयू पर हगिंग फेस पाइपलाइन को बेंचमार्क किया:

 from transformers import pipeline pipe = pipeline( "image-classification" , model=model, feature_extractor=feature_extractor, device=- 1 ) for batch_size in [ 1 , 8 , 32 , 64 , 128 ]:    print ( "-" * 30 )    print ( f"Streaming batch_size= {batch_size} " )    for out in tqdm(pipe(dataset, batch_size=batch_size), total= len (dataset)):        pass

आइए नमूना (3K) इमेजनेट डेटासेट पर सीपीयू पर हगिंग फेस इमेज वर्गीकरण पाइपलाइन के लिए हमारे पहले बेंचमार्क के परिणामों पर एक नज़र डालें:

सीपीयू पर फेस इमेज-वर्गीकरण पाइपलाइन को हग करना - 3544 छवियों की भविष्यवाणी करना

जैसा कि देखा जा सकता है, नमूना डेटासेट से लगभग 3544 छवियों को संसाधित करने में लगभग 3 मिनट ( 188 सेकंड) का समय लगा। अब जब मुझे पता है कि मेरी पाइपलाइन/डेटासेट/हार्डवेयर के लिए कौन सा बैच आकार (8) सबसे अच्छा है, मैं इस बैच आकार के साथ एक बड़े डेटासेट ( 34K छवियों ) पर उसी पाइपलाइन का उपयोग कर सकता हूं:

सीपीयू पर फेस इमेज-वर्गीकरण पाइपलाइन को हग करना - 34745 छवियों की भविष्यवाणी करना

इस बार CPU पर 34745 छवियों के लिए पूर्वानुमानित कक्षाएं समाप्त करने में लगभग 31 मिनट ( 1,879 सेकंड ) का समय लगा।

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

 from transformers import ViTFeatureExtractor, ViTForImageClassification from transformers import pipeline import torch device = "cuda:0" if torch.cuda.is_available() else "cpu"
print (device) feature_extractor = ViTFeatureExtractor.from_pretrained( 'google/vit-base-patch16-224' ) model = ViTForImageClassification.from_pretrained( 'google/vit-base-patch16-224' ) model = model.to(device) pipe = pipeline( "image-classification" , model=model, feature_extractor=feature_extractor, device= 0 ) for batch_size in [ 1 , 8 , 32 , 64 , 128 , 256 , 512 , 1024 ]:    print ( "-" * 30 )    print ( f"Streaming batch_size= {batch_size} " )    for out in tqdm(pipe(dataset, batch_size=batch_size), total= len (dataset)):        pass

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

आइए नमूना इमेजनेट डेटासेट (3K) पर GPU डिवाइस पर हमारे हगिंग फेस इमेज वर्गीकरण पाइपलाइन पर एक नज़र डालें:

GPU पर हगिंग फेस इमेज-वर्गीकरण पाइपलाइन — 3544 छवियों की भविष्यवाणी

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

GPU पर हगिंग फेस इमेज-वर्गीकरण पाइपलाइन — 34745 छवियों की भविष्यवाणी

इस बार हमारे बेंचमार्क ने GPU डिवाइस पर 34745 इमेज के लिए प्रेडिक्टेड क्लासेस को पूरा करने में लगभग 8:17 मिनट ( 497 सेकंड ) का समय लिया। यदि हम सीपीयू और जीपीयू डिवाइस पर अपने बेंचमार्क से परिणामों की तुलना करते हैं तो हम देख सकते हैं कि यहां जीपीयू विजेता है:

GPU बनाम CPU पर हगिंग फेस (PyTorch) 3.9x गुना तेज है

मैंने ViT PyTorch चौकियों को लोड करने के लिए हगिंग फेस पाइपलाइनों का उपयोग किया, अपने डेटा को टार्च डेटासेट में लोड किया, और CPU और GPU दोनों पर मॉडल के लिए आउट-ऑफ-द-बॉक्स प्रदान किए गए बैचिंग का उपयोग किया। सीपीयू पर समान पाइपलाइन चलाने की तुलना में GPU ~ 3.9x गुना तेज है।

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

स्पार्क एनएलपी: अत्याधुनिक प्राकृतिक भाषा प्रसंस्करण

स्पार्क एनएलपी एक ओपन-सोर्स अत्याधुनिक प्राकृतिक भाषा प्रसंस्करण पुस्तकालय है ( https://github.com/JohnSnowLabs/spark-nlp )

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

स्पार्क एनएलपी उत्पादन में एकमात्र ओपन-सोर्स एनएलपी लाइब्रेरी है जो बीईआरटी, कैममबर्ट , अल्बर्ट , इलेक्ट्रा , एक्सएलनेट , डिस्टिलबर्ट , रॉबर्टा, डेबर्टा , एक्सएलएम -रॉबर्टा , लॉन्गफॉर्मर , एल्मो , यूनिवर्सल सेंटेंस जैसे अत्याधुनिक ट्रांसफार्मर प्रदान करती है। एनकोडर , Google T5 , MarianMT , GPT2 और विज़न ट्रांसफ़ॉर्मर ( ViT ) न केवल Python और R के लिए, बल्कि JVM पारिस्थितिकी तंत्र ( Java , Scala , और Kotlin ) को भी अपाचे स्पार्क को मूल रूप से विस्तारित करके बड़े पैमाने पर।

बेयर मेटल सर्वर पर बेंचमार्किंग स्पार्क एनएलपी

Dell PowerEdge C4130 . पर वीआईटी मॉडल

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

 from sparknlp.annotator import * from sparknlp.base import * from pyspark.ml import Pipeline imageAssembler = ImageAssembler() \ .setInputCol( "image" ) \ .setOutputCol( "image_assembler" ) imageClassifier = ViTForImageClassification \ .pretrained( "image_classifier_vit_base_patch16_224" ) \ .setInputCols( "image_assembler" ) \ .setOutputCol( "class" ) \ .setBatchSize( 8 ) pipeline = Pipeline(stages=[ imageAssembler, imageClassifier ])

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

स्पार्क एनएलपी (बाएं) और हगिंग फेस (दाएं) में छवि वर्गीकरण के लिए वीआईटी मॉडल लोड करना और उनका उपयोग करना

चूंकि अपाचे स्पार्क में आलसी मूल्यांकन नामक एक अवधारणा है, यह प्रक्रिया के निष्पादन को तब तक शुरू नहीं करता है जब तक कि एक क्रिया नहीं कहा जाता है। Apache Spark में क्रियाएँ .count() या .show() या .write() और कई अन्य RDD-आधारित ऑपरेशन हो सकते हैं, जिन्हें मैं अभी नहीं समझूंगा और आपको इस लेख के लिए उन्हें जानने की आवश्यकता नहीं होगी। डेटाफ़्रेम में सभी पंक्तियों को निष्पादित करने के लिए मैं आमतौर पर या तो गिनती () लक्ष्य कॉलम चुनता हूं या डिस्क पर परिणाम लिखता हूं ()। साथ ही, हगिंग फेस बेंचमार्क की तरह, मैं यह सुनिश्चित करने के लिए चयनित बैच आकारों के माध्यम से लूप करूंगा कि मेरे पास सर्वोत्तम परिणाम खोए बिना सभी संभावित परिणाम हो सकते हैं।

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

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

एक डीएनएन के बिना सीपीयू पर स्पार्क एनएलपीछवि-वर्गीकरण पाइपलाइन - 3544 छवियों की भविष्यवाणी

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

मैं oneDNN को यह देखने के लिए भी सक्षम करना चाहूंगा कि क्या इस विशिष्ट स्थिति में यह मेरे बेंचमार्क को बिना oneDNN के CPU की तुलना में सुधारता है। आप TF_ENABLE_ONEDNN_OPTS के पर्यावरण चर को 1 पर सेट करके स्पार्क एनएलपी में oneDNN को सक्षम कर सकते हैं । आइए देखें कि क्या होता है यदि मैं इस ध्वज को सक्षम करता हूं और सर्वोत्तम बैच आकार खोजने के लिए CPU पर पिछले बेंचमार्क को फिर से चलाता हूं:

एक डीएनएन के साथ सीपीयू पर स्पार्क एनएलपीछवि-वर्गीकरण पाइपलाइन - 3544 छवियों की भविष्यवाणी

ठीक है, इस विशिष्ट स्थिति में TensorFlow के लिए oneDNN को स्पष्ट रूप से सक्षम करने से हमारे परिणामों में कम से कम 14% सुधार हुआ है। चूँकि हमें कुछ भी करने/बदलने की ज़रूरत नहीं है और केवल निर्यात TF_ENABLE_ONEDNN_OPTS=1 कहने की ज़रूरत है, मैं इसका उपयोग बेंचमार्क के लिए एक बड़े डेटासेट के साथ-साथ अंतर देखने के लिए करने जा रहा हूं। यहां लगभग सेकंड तेज है, लेकिन बड़े डेटासेट पर 14% हमारे परिणामों के मिनटों को कम कर सकते हैं।

अब जब मुझे पता है कि एक डीएनएन के बिना सीपीयू के लिए 16 का बैच आकार और एक डीएनएन के साथ सीपीयू के लिए 2 का बैच आकार सबसे अच्छा परिणाम है जिसे मैं एक बड़े डेटासेट ( 34K छवियों ) पर एक ही पाइपलाइन का उपयोग करके जारी रख सकता हूं:

एक डीएनएन के बिना सीपीयू पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34745 छवियों की भविष्यवाणी

इस बार हमारे बेंचमार्क ने बिना oneDNN सक्षम किए CPU डिवाइस पर 34745 छवियों के लिए भविष्यवाणी कक्षाओं को पूरा करने में लगभग 24 मिनट ( 1423 सेकंड ) का समय लिया। अब देखते हैं कि अगर मैं TensorFlow के लिए oneDNN को सक्षम करता हूं और 2 के बैच आकार (सर्वोत्तम परिणाम) का उपयोग करता हूं तो क्या होता है:

एक डीएनएन के साथ सीपीयू पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34745 छवियों की भविष्यवाणी

इस बार इसमें लगभग 21 मिनट ( 1278 सेकंड ) लगे। जैसा कि हमारे नमूना बेंचमार्क से अपेक्षित था, हम परिणामों में लगभग 11% सुधार देख सकते हैं, जो कि oneDNN सक्षम नहीं होने की तुलना में मिनटों को शेव कर देता है।

आइए देखें कि GPU डिवाइस पर समान पाइपलाइन को कैसे बेंचमार्क किया जाए। स्पार्क एनएलपी में, जब आप स्पार्क एनएलपी सत्र शुरू कर रहे होते हैं, तो आपको GPU का उपयोग करने की आवश्यकता होती है, इसे gpu = True से शुरू करना होता है:

स्पार्क = स्पार्कनएलपी। स्टार्ट (जीपीयू = ट्रू)
# आप यहां मेमोरी भी सेट कर सकते हैं
स्पार्क = स्पार्कनएलपी। स्टार्ट (जीपीयू = ट्रू, मेमोरी = "16 जी")

इतना ही! यदि आपके पास अपनी पाइपलाइन में कुछ है जिसे GPU पर चलाया जा सकता है तो यह स्पष्ट रूप से कुछ भी करने की आवश्यकता के बिना इसे स्वचालित रूप से करेगा।

आइए नमूना इमेजनेट डेटासेट (3K) पर GPU डिवाइस पर हमारी स्पार्क एनएलपी छवि वर्गीकरण पाइपलाइन पर एक नज़र डालें:

GPU पर स्पार्क NLPछवि-वर्गीकरण पाइपलाइन — 3544 छवियों की भविष्यवाणी

यह देखने के लिए उत्सुकता से कि क्या एक छोटे डेटासेट पर एक अच्छा बैच आकार खोजने के लिए मेरा धर्मयुद्ध सही था, मैंने बड़े डेटासेट पर GPU के साथ एक ही पाइपलाइन चलाई, यह देखने के लिए कि बैच आकार 32 का सबसे अच्छा परिणाम होगा या नहीं:

GPU पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34745 छवियों की भविष्यवाणी

शुक्र है, यह बैच आकार 32 है जो सबसे अच्छा समय देता है। तो इसमें लगभग साढ़े 4 मिनट ( 277 सेकंड) लगे।

मैं CPU से oneDNN के साथ परिणाम चुनूंगा क्योंकि वे तेज़ थे और मैं उनकी तुलना GPU परिणामों से करूँगा:

स्पार्क एनएलपी (टेन्सरफ्लो) जीपीयू बनाम सीपीयू (वनडीएनएन) पर 4.6x गुना तेज है

यह भी खूब रही! हम देख सकते हैं कि GPU पर स्पार्क एनएलपी एक डीएनएन सक्षम होने पर भी सीपीयू की तुलना में 4.6 गुना तेज है।

आइए देखें कि इन परिणामों की तुलना हगिंग फेस बेंचमार्क से कैसे की जाती है:

स्पार्क एनएलपी 3K छवियों के साथ नमूना डेटासेट के लिए छवि वर्गों की भविष्यवाणी करने में सीपीयू पर हगिंग फेस की तुलना में 65% तेज है और 34K छवियों के साथ बड़े डेटासेट पर 47% है। स्पार्क एनएलपी भी 34K छवियों के साथ एकल GPU अनुमान बड़े डेटासेट पर हगिंग फेस की तुलना में 79% तेज है और छोटे डेटासेट पर 35% तक तेज है।

स्पार्क एनएलपी सीपीयू या जीपीयू का उपयोग करके एक मशीन में हगिंग फेस की तुलना में तेज था - विज़न ट्रांसफॉर्मर (वीआईटी) का उपयोग करके छवि वर्गीकरण।

डेटाब्रिक्स पर स्पार्क एनएलपी और हगिंग फेस

डाटाब्रिक्स क्या है? एक मंच पर आपका सारा डेटा, विश्लेषण और एआई

डेटाब्रिक्स एक क्लाउड-आधारित प्लेटफ़ॉर्म है जिसमें डेटा इंजीनियरिंग और डेटा साइंस टूल का एक सेट होता है, जिसका उपयोग कई कंपनियां बड़ी मात्रा में डेटा को संसाधित करने और बदलने के लिए करती हैं। उपयोगकर्ता डेटा का पता लगाने के लिए कई ML/DL पाइपलाइनों को चलाने के लिए डेटा की व्यापक मात्रा को संसाधित करने और बदलने से लेकर कई उद्देश्यों के लिए डेटाब्रिक्स का उपयोग करते हैं।

अस्वीकरण: यह डेटाब्रिक्स की मेरी व्याख्या थी, यह कई अन्य विशेषताओं के साथ आती है और आपको उन्हें देखना चाहिए: https://www.databricks.com/product/data-lakehouse

डेटाब्रिक्स एडब्ल्यूएस, एज़्योर और जीसीपी क्लाउड का समर्थन करता है: https://www.databricks.com/product/data-lakehouse

एडब्ल्यूएस पर सीपीयू के साथ डाटाब्रिक्स सिंगल नोड में चेहरे को गले लगाना

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

डेटाब्रिक्स सिंगल-नोड क्लस्टर — सीपीयू रनटाइम

AWS पर m5n.8xlarge इंस्टेंस का उपयोग करने वाले इस क्लस्टर का सारांश यह है कि इसमें 1 ड्राइवर (केवल 1 नोड), 128 जीबी मेमोरी, 32 कोर सीपीयू है, और इसकी लागत 5.71 डीबीयू प्रति घंटा है। आप एडब्ल्यूएस पर "डीबीयू" के बारे में यहां पढ़ सकते हैं: https://www.databricks.com/product/aws-pricing

डेटाब्रिक्स सिंगल-क्लस्टर - एडब्ल्यूएस इंस्टेंस प्रोफाइल

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

डेटाब्रिक्स सिंगल-नोड सीपीयू पर फेस इमेज-वर्गीकरण पाइपलाइन को हग करना - 3544 छवियों की भविष्यवाणी करना

केवल CPU का उपयोग करने वाले एकल-नोड डेटाब्रिक्स पर हमारे नमूना डेटासेट से लगभग 3544 छवियों को संसाधित करने में लगभग 2 मिनट और डेढ़ ( 149 सेकंड ) का समय लगा। केवल सीपीयू का उपयोग करके इस मशीन पर सबसे अच्छा बैच आकार 8 है, इसलिए मैं इसका उपयोग बड़े डेटासेट पर बेंचमार्क चलाने के लिए कर रहा हूं:

डेटाब्रिक्स सिंगल-नोड सीपीयू पर फेस इमेज-वर्गीकरण पाइपलाइन को हग करना - 34745 छवियों की भविष्यवाणी करना

34K से अधिक छवियों वाले बड़े डेटासेट पर, उन छवियों के लिए अनुमानित कक्षाओं को पूरा करने में लगभग 20 मिनट और डेढ़ ( 1233 सेकंड ) का समय लगा। हमारे अगले बेंचमार्क के लिए हमें सिंगल-नोड डेटाब्रिक्स क्लस्टर की आवश्यकता है, लेकिन इस बार हमें GPU-आधारित रनटाइम और GPU-आधारित AWS इंस्टेंस चुनने की आवश्यकता है।

AWS पर GPU के साथ डेटाब्रिक्स सिंगल नोड में हगिंग फेस

आइए एक नया क्लस्टर बनाएं और इस बार हम GPU के साथ एक रनटाइम चुनने जा रहे हैं, जिसे इस मामले में 11.1 ML (अपाचे स्पार्क 3.3.0, GPU, स्काला 2.12 शामिल है) कहा जाता है और यह सभी आवश्यक CUDA और NVIDIA सॉफ़्टवेयर स्थापित के साथ आता है। अगली चीज़ जो हमें चाहिए वह है एक एडब्ल्यूएस इंस्टेंस का चयन करना जिसमें एक जीपीयू है और मैंने g4dn.8xlarge चुना है जिसमें 1 जीपीयू है और अन्य क्लस्टर के समान कोर/मेमोरी है। यह GPU इंस्टेंस टेस्ला T4 और 16 GB मेमोरी ( 15 GB .) के साथ आता है प्रयोग करने योग्य GPU मेमोरी)।

डेटाब्रिक्स सिंगल-नोड क्लस्टर — GPU रनटाइम

यह पिछले वाले की तरह हमारे सिंगल-नोड क्लस्टर का सारांश है और यह कोर की संख्या और मेमोरी की मात्रा के मामले में समान है, लेकिन यह टेस्ला टी 4 जीपीयू के साथ आता है:

डेटाब्रिक्स सिंगल-नोड क्लस्टर - एडब्ल्यूएस इंस्टेंस प्रोफाइल

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

डेटाब्रिक्स सिंगल-नोड सीपीयू पर हगिंग फेस इमेज-वर्गीकरण पाइपलाइन - 3544 छवियों की भविष्यवाणी

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

आइए बेंचमार्क को बड़े डेटासेट पर चलाएं और देखें कि बैच आकार 256 के साथ क्या होता है:

डेटाब्रिक्स सिंगल-नोड सीपीयू पर हगिंग फेस इमेज-वर्गीकरण पाइपलाइन - 34745 छवियों की भविष्यवाणी

बड़े डेटासेट पर, 34K से अधिक छवियों के लिए पूर्वानुमानित कक्षाएं समाप्त करने में लगभग 11 मिनट ( 659 सेकंड ) का समय लगा। यदि हम सीपीयू के साथ एक नोड पर हमारे बेंचमार्क से परिणामों की तुलना करते हैं और एक नोड जो 1 जीपीयू के साथ आता है तो हम देख सकते हैं कि यहां जीपीयू नोड विजेता है:

GPU बनाम CPU पर हगिंग फेस (PyTorch) 2.3x गुना तेज है

डेटाब्रिक्स सिंगल नोड पर हगिंग फेस में सीपीयू पर समान पाइपलाइन चलाने की तुलना में जीपीयू ~ 2.3x गुना तेज है

अब हम हगिंग फेस के साथ तुलना करने के लिए समान क्लस्टर और समान डेटासेट में स्पार्क एनएलपी का उपयोग करके समान बेंचमार्क चलाने जा रहे हैं।

सिंगल नोड डेटाब्रिक्स पर बेंचमार्किंग स्पार्क एनएलपी

सबसे पहले, अपने सिंगल नोड डेटाब्रिक्स सीपीयू में स्पार्क एनएलपी स्थापित करें:

अपने क्लस्टर के अंदर लाइब्रेरी टैब में आपको इन चरणों का पालन करना होगा:
- नया स्थापित करें -> पीईपीआई -> स्पार्क-एनएलपी == 4.1.0 -> इंस्टॉल करें
- नया स्थापित करें -> मावेन -> निर्देशांक -> com.johnsnowlabs.nlp:spark-nlp_2.12:4.1.0 -> इंस्टॉल करें
- oneDNN को सक्षम करने के लिए ` TF_ENABLE_ONEDNN_OPTS=1` को `क्लस्टर-> एडवांस विकल्प-> स्पार्क-> पर्यावरण चर` में जोड़ देगा

पायथन, स्काला और जावा के लिए सीपीयू पर डेटाब्रिक्स में स्पार्क एनएलपी कैसे स्थापित करें

एडब्ल्यूएस पर सीपीयू के साथ डाटाब्रिक्स सिंगल नोड में स्पार्क एनएलपी

अब जब हमने अपने डेटाब्रिक्स सिंगल-नोड क्लस्टर पर स्पार्क एनएलपी स्थापित कर लिया है, तो हम सीपीयू और जीपीयू दोनों पर एक नमूना और पूर्ण डेटासेट के लिए बेंचमार्क दोहरा सकते हैं। आइए पहले नमूना डेटासेट पर सीपीयू पर बेंचमार्क से शुरू करें:

डेटाब्रिक्स सिंगल-नोड सीपीयू (वनडीएनएन) पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 3544 छवियों की भविष्यवाणी

3544 छवियों को संसाधित करने और सीपीयू के साथ उसी सिंगल-नोड डेटाब्रिक्स क्लस्टर पर उनकी कक्षाओं की भविष्यवाणी करने में लगभग 2 मिनट ( 111 सेकंड ) का समय लगा, जिसका उपयोग हमने हगिंग फेस के लिए किया था। हम देख सकते हैं कि 16 के बैच आकार का सबसे अच्छा परिणाम है, इसलिए मैं इसे अगले बेंचमार्क में बड़े डेटासेट पर उपयोग करूंगा:

डेटाब्रिक्स सिंगल-नोड सीपीयू (वनडीएनएन) पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

34K से अधिक छवियों वाले बड़े डेटासेट पर, उन छवियों के लिए अनुमानित कक्षाओं को पूरा करने में लगभग 18 मिनट ( 1072 सेकंड ) का समय लगा। आगे, मैं GPU के साथ क्लस्टर पर समान बेंचमार्क दोहराऊंगा।

AWS पर GPU के साथ डेटाब्रिक्स सिंगल नोड

सबसे पहले, अपने सिंगल नोड डेटाब्रिक्स जीपीयू में स्पार्क एनएलपी स्थापित करें (मावेन से " स्पार्क-एनएलपी-जीपीयू" का उपयोग केवल अंतर है):

अपने डेटाब्रिक्स क्लस्टर में स्पार्क एनएलपी स्थापित करें
— क्लस्टर के अंदर लाइब्रेरी टैब में आपको इन चरणों का पालन करना होगा:
- नया स्थापित करें -> पीईपीआई -> स्पार्क-एनएलपी == 4.1.0 -> इंस्टॉल करें
- नया स्थापित करें -> मावेन -> निर्देशांक -> com.johnsnowlabs.nlp:spark-nlp-gpu_2.12:4.1.0 -> इंस्टॉल करें

पायथन, स्काला और जावा के लिए जीपीयू पर डेटाब्रिक्स में स्पार्क एनएलपी कैसे स्थापित करें

मैं छोटे डेटासेट पर बेंचमार्क चलाने जा रहा हूं, यह देखने के लिए कि हमारे GPU-आधारित मशीन के लिए कौन सा बैच आकार अधिक उपयुक्त है:

डेटाब्रिक्स सिंगल-नोड जीपीयू पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 3544 छवियों की भविष्यवाणी

GPU डिवाइस के साथ हमारे सिंगल-नोड डेटाब्रिक्स पर हमारे नमूना डेटासेट से लगभग 3544 छवियों को संसाधित करने में एक मिनट ( 47 सेकंड ) से भी कम समय लगा। हम देख सकते हैं कि बैच आकार 8 ने इस विशिष्ट उपयोग के मामले में सबसे अच्छा प्रदर्शन किया है, इसलिए मैं बड़े डेटासेट पर बेंचमार्क चलाऊंगा:

डेटाब्रिक्स सिंगल-नोड जीपीयू पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

बड़े डेटासेट पर, 34K से अधिक छवियों के लिए पूर्वानुमानित कक्षाओं को पूरा करने में लगभग 7 मिनट और डेढ़ ( 435 सेकंड ) का समय लगा। यदि हम सीपीयू के साथ एक नोड पर हमारे बेंचमार्क से परिणामों की तुलना करते हैं और एक नोड जो 1 जीपीयू के साथ आता है तो हम देख सकते हैं कि यहां जीपीयू नोड विजेता है:

स्पार्क एनएलपी डेटाब्रिक्स सिंगल नोड में जीपीयू बनाम सीपीयू पर 2.5x गुना तेज है

यह भी खूब रही! हम देख सकते हैं कि GPU पर स्पार्क एनएलपी सीपीयू की तुलना में 2.5x गुना तेज है, यहां तक कि वनडीएनएन सक्षम होने के साथ भी (वनडीएनएन सीपीयू पर 10% से 20% के बीच परिणामों में सुधार करता है)।

आइए देखें कि इन परिणामों की तुलना समान डेटाब्रिक्स सिंगल नोड क्लस्टर में हगिंग फेस बेंचमार्क से कैसे की जाती है:

स्पार्क एनएलपी 3K छवियों के साथ नमूना डेटासेट के लिए छवि वर्गों की भविष्यवाणी करने में सीपीयू पर हगिंग फेस की तुलना में 15% तक तेज है और 34K छवियों के साथ बड़े डेटासेट पर 34% तक है। स्पार्क एनएलपी 34K इमेज वाले बड़े डेटासेट के लिए सिंगल GPU पर हगिंग फेस की तुलना में 51% तेज है और 3K इमेज वाले छोटे डेटासेट पर 36% तक तेज है।

स्पार्क एनएलपी सीपीयू और जीपीयू बनाम डेटाब्रिक्स सिंगल नोड में हगिंग फेस दोनों पर तेज है

एक मशीन से परे स्केलिंग

अब तक हमने यह स्थापित किया है कि जीपीयू पर हगिंग फेस एक बेयर-मेटल सर्वर और डेटाब्रिक्स सिंगल नोड पर सीपीयू पर हगिंग फेस से तेज है। जब आप इन नए ट्रांसफॉर्मर-आधारित मॉडलों के साथ GPU बनाम CPU की तुलना कर रहे हैं तो आप यही अपेक्षा करते हैं।

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

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

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

बढ़ाना = अपनी मशीन को बड़ा या तेज बनाना ताकि वह अधिक भार को संभाल सके।

स्केलिंग आउट = लोड को फैलाने के लिए समानांतर में अधिक मशीनें जोड़ना।

हगिंग फेस स्केलिंग:

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

https://huggingface.co/docs/transformers/performance

इसके अलावा, यह उल्लेख नहीं करने के लिए कि हगिंग फेस में अनुमान के लिए मल्टी-जीपीयू समाधान फिलहाल मौजूद नहीं है:

https://huggingface.co/docs/transformers/perf_infer_gpu_many

तो ऐसा लगता है कि हगिंग फेस पाइपलाइनों को स्केल करने का कोई मूल/आधिकारिक तरीका नहीं है। आप अलग-अलग मशीनों पर प्रत्येक अनुरोध को वितरित करने के लिए कुछ माइक्रोसर्विसेज जैसे जॉब क्यू, मैसेजिंग प्रोटोकॉल, रीस्टफुल एपीआई बैकएंड, और कुछ अन्य आवश्यक घटकों से युक्त अपने आर्किटेक्चर को लागू कर सकते हैं, लेकिन यह वास्तविक सिस्टम को स्केल करने के बजाय अलग-अलग उपयोगकर्ताओं द्वारा अनुरोधों को मापता है। अपने आप।

इसके अलावा, इस तरह के सिस्टम की लेटेंसी की तुलना स्थानीय रूप से वितरित सिस्टम जैसे Apache Spark से नहीं की जा सकती है (gRPC इस लेटेंसी को कम कर सकता है, लेकिन फिर भी प्रतिस्पर्धी नहीं)। विफलता के मुद्दे के एकल बिंदु का उल्लेख नहीं करना, असफल नौकरियों/कार्यों/इनपुटों का प्रबंधन करना, और सैकड़ों अन्य सुविधाएं जो आपको अपाचे स्पार्क से मिलती हैं, जिन्हें अब आपको स्वयं लागू/बनाए रखना है।

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

उदाहरण के लिए, फास्टएपीआई के अंदर अनुमान स्थानीय अनुमान से 10 गुना धीमा है: https://towardsdatascience.com/hugging-face-transformer-inference-under-1-millisecond-latency-e1be0057a51c

एक बार जब हगिंग फेस स्केल आउट करने के लिए कुछ मूल समाधान पेश करता है तो मैं फिर से बेंचमार्क फिर से चलाऊंगा। तब तक, राउंड-रॉबिन एल्गोरिथम में आरईएसटी एंडपॉइंट्स को हिट करने के लिए आपको एक मशीन से डेटासेट के माध्यम से लूप करने के लिए कोई स्केलिंग आउट नहीं होता है। (उस भाग के बारे में फिर से सोचें जो हमने GPU को एक साथ फीड करने के लिए पंक्तियों/अनुक्रमों/छवियों को बैच किया है, फिर आप इसे प्राप्त करेंगे)

स्पार्क एनएलपी को स्केल करना:

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

शून्य कोड परिवर्तन की आवश्यकता है! स्पार्क एनएलपी कोड में कुछ भी बदले बिना एक मशीन से असीमित संख्या में मशीनों तक स्केल कर सकता है!

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

स्पार्क एनएलपी पारिस्थितिकी तंत्र: अनुकूलित, परीक्षण और समर्थित एकीकरण

AWS पर CPU के साथ डेटाब्रिक्स मल्टी-नोड

आइए एक क्लस्टर बनाएं और इस बार हम क्लस्टर मोड के अंदर मानक चुनें। इसका मतलब है कि हमारे क्लस्टर में 1 से अधिक नोड हो सकते हैं, जो कि अपाचे स्पार्क शब्दावली में इसका अर्थ है 1 ड्राइवर और एन संख्या में श्रमिक (निष्पादक)।

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

हमारे क्लस्टर कॉन्फ़िगरेशन इस तरह दिखते हैं:

डेटाब्रिक्स मल्टी-नोड (मानक) क्लस्टर केवल सीपीयू के साथ

मैं उसी स्पार्क एनएलपी पाइपलाइन का पुन: उपयोग करूंगा जिसका मैंने पिछले बेंचमार्क में उपयोग किया था (किसी भी कोड को बदलने की आवश्यकता नहीं है) और साथ ही मैं केवल 34K छवियों के साथ बड़े डेटासेट का उपयोग करूंगा। चलो शुरू करें!

2x नोड्स के साथ सीपीयू पर स्केल स्पार्क एनएलपी

2x नोड्स के साथ डेटाब्रिक्स — केवल CPU

आइए बस 1 और नोड जोड़ें और कुल मशीन बनाएं जो 2 मशीनों को प्रसंस्करण करेगी। जब आप एकल मशीन सेटअप (आपके Colab, Kaggle, Databricks Single Node, या यहां तक कि अपने स्थानीय Jupyter नोटबुक) से मल्टी-नोड क्लस्टर सेटअप (Databricks, EMR, GCP, Azure, Cloudera) में जाते हैं, तो स्पार्क एनएलपी की सुंदरता को न भूलें। , YARN, Kubernetes, आदि), शून्य-कोड परिवर्तन की आवश्यकता है! और मेरा मतलब शून्य है! इसे ध्यान में रखते हुए, मैं इस नए क्लस्टर के अंदर 34K छवियों वाले बड़े डेटासेट पर समान बेंचमार्क चलाऊंगा:

सीपीयू (वनडीएनएन) के साथ 2x नोड्स पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

34K छवियों के लिए अनुमानित कक्षाओं को पूरा करने में लगभग 9 मिनट ( 550 सेकंड ) का समय लगा। आइए इस परिणाम की तुलना स्पार्क एनएलपी के साथ 2x नोड्स पर करें और डेटाब्रिक्स सिंगल नोड पर हगिंग फेस परिणाम (मैं एक एकल नोड पर हगिंग फेस परिणामों को एक संदर्भ के रूप में दोहराता रहूंगा क्योंकि कई मशीनों पर हगिंग फेस को स्केल नहीं किया जा सकता है, खासकर डेटाब्रिक्स पर) :

2x नोड्स वाले हगिंग फेस की तुलना में स्पार्क एनएलपी 124% तेज है

इससे पहले, स्पार्क एनएलपी ने सिंगल नोड डेटाब्रिक्स क्लस्टर पर हगिंग फेस को केवल सीपीयू का उपयोग करके 15% तक हराया था।

इस बार, 1 नोड के बजाय केवल 2x नोड्स होने के कारण, स्पार्क एनएलपी ने हगिंग फेस की तुलना में 34K से अधिक छवियों की प्रक्रिया को 124% तेजी से समाप्त किया। सीपीयू पर 4x नोड्स के साथ स्पार्क एनएलपी को स्केल करें

आइए पहले की तरह अपने क्लस्टर का आकार दोगुना करें और 2x नोड्स से 4x नोड्स पर जाएं। यह क्लस्टर 4x नोड्स के साथ कैसा दिखेगा:

4x नोड्स के साथ डेटाब्रिक्स — केवल CPU

मैं इस नए क्लस्टर पर 34K छवियों वाले बड़े डेटासेट पर समान बेंचमार्क चलाऊंगा:

सीपीयू (वनडीएनएन) के साथ 4x नोड्स पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

34K छवियों के लिए अनुमानित कक्षाओं को पूरा करने में लगभग 5 मिनट ( 289 सेकंड ) का समय लगा। आइए इस परिणाम की तुलना 4x नोड्स पर स्पार्क एनएलपी बनाम डेटाब्रिक्स पर सीपीयू पर हगिंग फेस के साथ करें:

4x नोड्स के साथ हगिंग फेस की तुलना में स्पार्क एनएलपी 327% तेज है

जैसा कि देखा जा सकता है, स्पार्क एनएलपी अब सीपीयू पर हगिंग फेस की तुलना में 327% तेज है, जबकि डेटाब्रिक्स में केवल 4x नोड्स का उपयोग कर रहा है।

8x नोड्स के साथ सीपीयू पर स्केल स्पार्क एनएलपी

अब 4x और Nodes जोड़कर पिछले क्लस्टर को दोगुना करते हैं और कुल 8x Nodes बनाते हैं। जिस तरह से क्लस्टर का आकार बदलना बहुत आसान है, आप बस अपने क्लस्टर कॉन्फ़िगरेशन में श्रमिकों की संख्या बढ़ाते हैं:

डेटाब्रिक्स में स्पार्क क्लस्टर का आकार बदलना

8x नोड्स के साथ डेटाब्रिक्स — केवल CPU

आइए इस बार उसी बेंचमार्क को 8x नोड्स पर चलाएं:

सीपीयू (वनडीएनएन) के साथ 8x नोड्स पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

34K छवियों के लिए अनुमानित कक्षाओं को पूरा करने में 2 मिनट और डेढ़ ( 161 सेकंड ) से अधिक का समय लगा। आइए इस परिणाम की तुलना 8x नोड्स पर स्पार्क एनएलपी बनाम डेटाब्रिक्स पर सीपीयू पर हगिंग फेस के साथ करें:

8x नोड्स वाले हगिंग फेस की तुलना में स्पार्क एनएलपी 666% तेज है

जैसा कि देखा जा सकता है, स्पार्क एनएलपी अब सीपीयू पर हगिंग फेस की तुलना में 666% तेज है, जबकि डेटाब्रिक्स में केवल 8x नोड्स का उपयोग करते हुए।

आइए यहाँ केवल 6s की संख्या को नज़रअंदाज़ करें! (यह 665.8% था अगर यह आपको बेहतर महसूस कराता है)

10x नोड्स के साथ सीपीयू पर स्केल स्पार्क एनएलपी

स्पार्क एनएलपी का उपयोग करके डेटाब्रिक्स में सीपीयू पर वीआईटी मॉडल की भविष्यवाणियों को पूरा करने के लिए मैं एक बार फिर क्लस्टर का आकार बदलूंगा और इसे 10x नोड्स तक बढ़ाऊंगा:

10x नोड्स के साथ डेटाब्रिक्स — केवल सीपीयू

आइए इस बार उसी बेंचमार्क को 10x नोड्स पर चलाएं:

सीपीयू (वनडीएनएन) के साथ 10x नोड्स पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

34K छवियों के लिए अनुमानित कक्षाओं को पूरा करने में 2 मिनट ( 112 सेकंड ) से भी कम समय लगा। आइए इस परिणाम की तुलना 10x नोड्स पर स्पार्क एनएलपी बनाम डेटाब्रिक्स पर सीपीयू पर हगिंग फेस के पिछले सभी परिणामों से करें:

स्पार्क एनएलपी 10x नोड्स के साथ हगिंग फेस की तुलना में 1000% तेज है

और इस तरह आप डेटाब्रिक्स में स्पार्क एनएलपी का उपयोग करके 10x नोड्स पर हगिंग फेस से आने वाले विजन ट्रांसफॉर्मर मॉडल को मापते हैं! सीपीयू पर हगिंग फेस की तुलना में हमारी पाइपलाइन अब 1000% तेज है।

हम अपनी वीआईटी पाइपलाइन को हगिंग फेस की तुलना में 1000% तेज बनाने में कामयाब रहे जो कि केवल स्पार्क एनएलपी का उपयोग करके 1 सिंगल नोड में फंस गया है, लेकिन हमने केवल सीपीयू का उपयोग किया है। आइए देखें कि क्या हम GPU क्लस्टर पर अपनी पाइपलाइन को बढ़ाकर समान सुधार प्राप्त कर सकते हैं।

AWS पर GPU के साथ डेटाब्रिक्स मल्टी-नोड

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

हमें इस नए क्लस्टर में लाइब्रेरी टैब के माध्यम से स्पार्क एनएलपी भी स्थापित करने की आवश्यकता है। पहले की तरह ही, आप एक GPU के साथ सिंगल नोड डेटाब्रिक्स में बताए गए चरणों का पालन कर सकते हैं।

GPU के साथ डेटाब्रिक्स मल्टी-नोड (मानक) क्लस्टर

2x नोड्स के साथ GPU पर स्केल स्पार्क NLP

हमारा मल्टी-नोड डेटाब्रिक्स जीपीयू क्लस्टर उसी एडब्ल्यूएस जीपीयू इंस्टेंस का उपयोग करता है जो जी4डीएन.8एक्सलार्ज का है, जिसका उपयोग हमने सिंगल-नोड डेटाब्रिक्स क्लस्टर पर स्पार्क एनएलपी बनाम हगिंग फेस की तुलना करने के लिए अपने बेंचमार्क चलाने के लिए किया था।

यह इस बार 2 नोड्स के साथ कैसा दिखता है, इसका सारांश है:

2x नोड्स के साथ डेटाब्रिक्स - प्रति नोड 1 GPU के साथ

मैं इस GPU क्लस्टर में 2x नोड्स के साथ एक ही पाइपलाइन चलाने जा रहा हूं:

GPU के साथ 2x नोड्स पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

34K छवियों के लिए अनुमानित कक्षाओं को पूरा करने में 4 मिनट ( 231 सेकंड ) का समय लगा। आइए इस परिणाम की तुलना 2x नोड्स पर स्पार्क एनएलपी बनाम डेटाब्रिक्स में जीपीयू पर हगिंग फेस के साथ करें:

स्पार्क एनएलपी 2x नोड्स वाले हगिंग फेस की तुलना में 185% तेज है

2x नोड्स के साथ स्पार्क एनएलपी लगभग 3x गुना तेज है ( 185% ) GPU का उपयोग करते समय 1 सिंगल नोड पर हगिंग फेस की तुलना में।

4x नोड्स के साथ GPU पर स्केल स्पार्क NLP

आइए हमारे GPU क्लस्टर को 2x Nodes से 4x Nodes में आकार दें। यह इस बार एक GPU का उपयोग करके 4x नोड्स के साथ कैसा दिखता है, इसका सारांश है:

4x नोड्स के साथ डेटाब्रिक्स - प्रति नोड 1 GPU के साथ

आइए 4x नोड्स पर समान बेंचमार्क चलाएं और देखें कि क्या होता है:

GPU के साथ 4x नोड्स पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

इस बार हमारे डेटासेट में सभी 34K छवियों को वर्गीकृत करने में लगभग 2 मिनट ( 118 सेकंड ) का समय लगा। आइए इसे एक बेहतर दृश्य के लिए कल्पना करें कि एक एकल नोड बनाम स्पार्क एनएलपी में एक बहु-नोड क्लस्टर में हगिंग फेस के संदर्भ में इसका क्या अर्थ है:

स्पार्क एनएलपी 4x नोड्स वाले हगिंग फेस से 458% तेज है

हगिंग फेस की तुलना में यह 458% बढ़ा हुआ प्रदर्शन है। हमने अभी-अभी 4x नोड्स के साथ स्पार्क एनएलपी का उपयोग करके अपनी पाइपलाइन को 5.6x गुना तेज बनाया है।

8x नोड्स के साथ GPU पर स्केल स्पार्क NLP

इसके बाद, मैं निम्नलिखित सारांश के साथ अपने डेटाब्रिक्स में 8x नोड्स रखने के लिए क्लस्टर का आकार बदलूंगा:

8x नोड्स के साथ डेटाब्रिक्स - प्रति नोड 1 GPU के साथ

एक अनुस्मारक के रूप में, प्रत्येक AWS इंस्टेंस ( g4dn.8xlarge ) में 1 NVIDIA T4 GPU 16GB (15GB उपयोग करने योग्य मेमोरी) है। आइए बेंचमार्क को फिर से चलाएं और देखें कि क्या हम किसी भी सुधार को देख सकते हैं क्योंकि किसी भी वितरित सिस्टम में स्केलिंग के अपने ओवरहेड्स हैं और आप केवल मशीनों को जोड़ना जारी नहीं रख सकते हैं:

GPU के साथ 8x नोड्स पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

हमारे डेटाब्रिक्स क्लस्टर में 8x नोड्स के साथ 34K छवियों को वर्गीकृत करने में लगभग एक मिनट ( 61 सेकंड ) का समय लगा। ऐसा लगता है कि हम अभी भी प्रदर्शन में सुधार करने में कामयाब रहे। आइए इस परिणाम को पिछले परिणामों के बगल में एक एकल नोड बनाम स्पार्क एनएलपी में एक बहु-नोड क्लस्टर में रखें:

8x नोड्स के साथ हगिंग फेस की तुलना में स्पार्क एनएलपी 980% तेज है

8x नोड्स के साथ स्पार्क एनएलपी GPU पर हगिंग फेस की तुलना में लगभग 11x गुना तेज (980%) है।

10x नोड्स के साथ GPU पर स्केल स्पार्क NLP

सीपीयू पर हमारे मल्टी-नोड बेंचमार्क के समान, मैं 10x नोड्स रखने के लिए GPU क्लस्टर का एक बार और आकार बदलना चाहता हूं और नोड्स की अंतिम संख्या के संदर्भ में उनका मिलान करना चाहता हूं। इस क्लस्टर का अंतिम सारांश इस प्रकार है:

10x नोड्स के साथ डेटाब्रिक्स - प्रति नोड 1 GPU के साथ

आइए इस विशिष्ट GPU क्लस्टर (शून्य कोड परिवर्तनों के साथ) में अपना अंतिम बेंचमार्क चलाएं:

GPU के साथ 10x नोड्स पर स्पार्क एनएलपी छवि-वर्गीकरण पाइपलाइन - 34742 छवियों की भविष्यवाणी

34743 से अधिक छवियों के लिए भविष्यवाणी कक्षाओं को पूरा करने में एक मिनट ( 51 सेकंड ) से भी कम समय लगा। आइए उन सभी को एक-दूसरे के बगल में रखें और देखें कि हमने डेटाब्रिक्स में स्पार्क एनएलपी पाइपलाइन में हगिंग फेस से आने वाले अपने विज़न ट्रांसफार्मर मॉडल को कैसे बढ़ाया है:

स्पार्क एनएलपी 10x नोड्स के साथ हगिंग फेस की तुलना में 1200% तेज है

और हम कर रहे हैं!

हम डेटाब्रिक्स में स्पार्क एनएलपी का उपयोग करके 10x नोड्स पर हगिंग फेस से आने वाले हमारे विजन ट्रांसफॉर्मर मॉडल को स्केल करने में कामयाब रहे! GPU पर हगिंग फेस की तुलना में 1200% प्रदर्शन सुधार के साथ हमारी पाइपलाइन अब 13x गुना तेज है।

आइए पहले सीपीयू और जीपीयू के बीच सुधारों की तुलना करके इन सभी बेंचमार्क का योग करें, और फिर जीपीयू पर स्पार्क एनएलपी का उपयोग करके हगिंग फेस सीपीयू से डेटाब्रिक्स पर 10x नोड्स तक जाने से हमारी पाइपलाइन कितनी तेज हो सकती है।

यह सब एक साथ लाना:

डेटाब्रिक्स: सिंगल नोड और मल्टी नोड्स

सीपीयू के साथ 10x नोड्स पर स्पार्क एनएलपी हगिंग फेस की तुलना में 1000% (11x गुना) तेज है सीपीयू के साथ एकल नोड में फंस गया है

GPU के साथ 10x नोड्स पर स्पार्क NLP हगिंग फेस की तुलना में 1192% (13x गुना) तेज है GPU के साथ एकल नोड में अटका हुआ है

हमारे एडब्ल्यूएस सीपीयू इंस्टेंस और एडब्ल्यूएस जीपीयू इंस्टेंस के बीच मूल्य अंतर के बारे में क्या? (मेरा मतलब है, यदि आप अधिक भुगतान करते हैं तो आपको अधिक मिलता है, है ना?)

सीपीयू बनाम एडब्ल्यूएस g4dn.8x बड़े के साथ एडब्ल्यूएस m5d.8xबड़ा 1 जीपीयू और इसी तरह के चश्मे के साथ

ठीक है, तो कीमत काफी समान लगती है! इसे ध्यान में रखते हुए, यदि आप एक मशीन में फंसे सीपीयू पर हगिंग फेस से 10x जीपीयू के साथ 10x नोड्स पर स्पार्क एनएलपी में जाते हैं तो आपको क्या सुधार मिलते हैं?

जीपीयू पर स्पार्क एनएलपी सीपीयू पर हगिंग फेस की तुलना में 25 गुना (2366%) तेज है

GPU के साथ 10x नोड्स पर स्पार्क NLP 2366% (25x गुना) हगिंग फेस की तुलना में तेज़ है CPU के साथ एक नोड में

अंतिम शब्द

• पूर्ण पारदर्शिता की भावना में, सभी नोटबुक उनके लॉग, स्क्रीनशॉट और यहां तक कि संख्याओं के साथ एक्सेल शीट यहां GitHub पर उपलब्ध कराई गई हैं।
• स्पार्क एनएलपी को स्केल करने के लिए शून्य कोड परिवर्तन की आवश्यकता होती है। बेंचमार्क को सिंगल नोड डेटाब्रिक्स से 10 नोड्स तक चलाने का मतलब है कि उसी नोटबुक में कोड के समान ब्लॉक को फिर से चलाना
• ध्यान रखें कि ये दो पुस्तकालय विभिन्न उपयोग के मामलों के लिए विभिन्न वातावरणों में अपनी गति और दक्षता को अनुकूलित करने के लिए कई सर्वोत्तम प्रथाओं के साथ आते हैं। उदाहरण के लिए, मैंने अपाचे स्पार्क में विभाजन और समानता और वितरण के संबंध के बारे में बात नहीं की। क्लस्टर को ठीक करने के लिए कई स्पार्क कॉन्फ़िगरेशन हैं, विशेष रूप से सीपीयू और जीपीयू के बीच कार्यों की संख्या को संतुलित करना। अब सवाल यह है कि क्या उनमें से किसी एक को उसी वातावरण में गति देना संभव होगा, जिसका उपयोग हमने अपने बेंचमार्क के लिए किया था? जवाब 100% है! मैंने दोनों पुस्तकालयों के लिए डिफ़ॉल्ट मानों और सही आउट-ऑफ-द-बॉक्स सुविधाओं के साथ अधिकांश उपयोगकर्ताओं के लिए सादगी के पक्ष में सब कुछ रखने की कोशिश की।
• आप उन्हें स्केल करने के लिए स्पार्क यूडीएफ में हगिंग फेस और अन्य डीएल-आधारित पाइथोनिश पुस्तकालयों को लपेटना चाह सकते हैं। यह एक हद तक काम करता है क्योंकि मैंने इसे स्वयं किया है और अभी भी करता हूं (जब कोई मूल समाधान नहीं होता है)। जब कोई यूडीएफ में ऐसे ट्रांसफॉर्मर-आधारित मॉडल को लपेटता है तो मैं अत्यधिक मेमोरी उपयोग, संभावित सीरियलाइजेशन मुद्दों, उच्च विलंबता और अन्य समस्याओं के विवरण में नहीं जाऊंगा। मैं सिर्फ इतना कहूंगा कि यदि आप अपाचे स्पार्क का उपयोग कर रहे हैं तो उस पुस्तकालय का उपयोग करें जो अपाचे स्पार्क पर आपकी आवश्यक सुविधाओं को मूल रूप से बढ़ा रहा है।
• इस पूरे लेख के दौरान, मैं अपने रास्ते से हटकर PyTorch पर हगिंग फेस और TensorFlow पर स्पार्क एनएलपी का उल्लेख करने के लिए गया था। यह इस तथ्य को देखते हुए एक बड़ा अंतर है कि PyTorch और TensorFlow के बीच हगिंग फेस द्वारा किए गए हर एक बेंचमार्क में, PyTorch अनुमान के लिए विजेता था और अभी भी है। हगिंग फेस में, PyTorch की विलंबता बहुत कम है और यह ट्रांसफॉर्मर में TensorFlow की तुलना में बहुत तेज लगता है। तथ्य यह है कि स्पार्क एनएलपी एक ही TensorFlow का उपयोग करता है और हगिंग फेस में PyTorch की तुलना में हर बेंचमार्क में आगे आता है, यह एक बड़ी बात है। या तो हगिंग फेस में TensorFlow की उपेक्षा की जाती है, या PyTorch TensorFlow की तुलना में अनुमान में तेज़ है। किसी भी तरह, मैं यह देखने के लिए इंतजार नहीं कर सकता कि क्या होता है जब स्पार्क एनएलपी टेंसरफ्लो के अलावा टॉर्चस्क्रिप्ट और ओएनएनएक्स रनटाइम का समर्थन करना शुरू कर देता है।
• एमएल और एमएल जीपीयू डाटाब्रिक्स रनटाइम्स हगिंग फेस के साथ आते हैं, यह बहुत अच्छा है। लेकिन इसका मतलब यह नहीं है कि डेटाब्रिक्स में हगिंग फेस का उपयोग करना आसान है। हगिंग फेस द्वारा ट्रांसफॉर्मर लाइब्रेरी डीबीएफएस (डेटाब्रिक्स की मूल वितरित फाइल सिस्टम) या अमेज़ॅन एस 3 का समर्थन नहीं करती है। जैसा कि आप नोटबुक में देखते हैं, मुझे डेटासेट का एक संकुचित संस्करण डाउनलोड करना था और उनका उपयोग करने के लिए उन्हें निकालना था। यह वास्तव में ऐसा नहीं है कि डेटाब्रिक्स और प्रोडक्शंस में अन्य प्लेटफॉर्म के उपयोगकर्ता कैसे काम करते हैं। हम अपने डेटा को वितरित फ़ाइल सिस्टम के भीतर रखते हैं, सुरक्षा उपाय लागू किए गए हैं, और उनमें से अधिकांश इतने बड़े हैं कि एक व्यक्तिगत कंप्यूटर द्वारा डाउनलोड नहीं किया जा सकता है। मुझे डीबीएफएस पर पहले से मौजूद डेटासेट को डाउनलोड करना था, उन्हें ज़िप करना था, उन्हें एस 3 पर अपलोड करना था, उन्हें सार्वजनिक करना था, और उन्हें फिर से नोटबुक में डाउनलोड करना था। एक बहुत ही थकाऊ प्रक्रिया जिसे टाला जा सकता था अगर हगिंग फेस DBFS/S3 का समर्थन कर सकता है।

संदर्भ

विटामिन

• https://arxiv.org/pdf/2010.11929.pdf
• छवि पहचान में https://github.com/google-research/vision_transformer विजन ट्रांसफॉर्मर (वीआईटी) - 2022 गाइड
• https://github.com/lucidrains/vit-pytorch
• https://medium.com/mlearning-ai/an-image-is-worth-16x16-words-transformers-for-image-रिकग्निशन-एट-स्केल-51f3561a9f96
• https://medium.com/nerd-for-tech/an-image-is-worth-16x16-words-transformers-for-image-Recognition-at-scale-paper-summary-3a387e71880a
• https://gareemadhingra11.medium.com/summary-of-paper-an-image-is-worth-16x16-words-3f7f3aca941
• https://medium.com/analytics-vidhya/vision-transformers-bye-bye-convolutions-e929d022e4ab
• https://medium.com/syncedreview/google-brain-uncovers-representation-structure-differences-between-cnns-and-vision-transformers-83b6835dbbac

गले लगाना चेहरा

• https://huggingface.co/docs/transformers/main_classes/pipelines
• https://huggingface.co/blog/fine-tune-vit
• https://huggingface.co/blog/vision-transformers
• https://huggingface.co/blog/tf-serving-vision
• https://huggingface.co/blog/deploy-tfserving-kubernetes
• https://huggingface.co/google/vit-base-patch16-224
• https://huggingface.co/blog/deploy-vertex-ai
• https://huggingface.co/models?other=vit

डेटाब्रिक्स

• https://www.databricks.com/spark/getting-started-with-apache-spark
• https://docs.databricks.com/getting-started/index.html
• https://docs.databricks.com/getting-started/quick-start.html
• DATA+AI SUMMIT 2022 का सर्वोत्तम देखें
• https://www.databricks.com/blog/2020/05/15/shrink-training-time-and-cost-using-nvidia-gpu-accelerated-xgboost-and-apache-spark-on-databricks.html

स्पार्क एनएलपी

• स्पार्क एनएलपी गिटहब
• स्पार्क एनएलपी कार्यशाला (स्पार्क एनएलपी उदाहरण)
• स्पार्क एनएलपी ट्रांसफॉर्मर
• स्पार्क एनएलपी मॉडल हब
• स्पार्क एनएलपी 3 में स्पीड ऑप्टिमाइज़ेशन और बेंचमार्क: स्पार्क एनएलपी में आधुनिक हार्डवेयर हार्डवेयर एक्सेलेरेशन का अधिकतम लाभ उठाना
• एपीआई के माध्यम से स्पार्क एनएलपी की सेवा: स्प्रिंग और लाइटपाइपलाइन
• एपीआई के माध्यम से स्पार्क एनएलपी की सेवा (1/3): माइक्रोसॉफ्ट का सिनैप्स एमएल
• एपीआई के माध्यम से स्पार्क एनएलपी की सेवा (2/3): FastAPI और LightPipelines
• एपीआई के माध्यम से स्पार्क एनएलपी की सेवा (3/3): डेटाब्रिक्स जॉब्स और एमएलएफलो सर्व एपीआई
• स्पार्क 3.0 पर GPU के साथ स्काला में गहरी शिक्षा का लाभ उठाएं
• GPU-त्वरित Apache Spark 3 के साथ प्रारंभ करना
• अपाचे स्पार्क प्रदर्शन ट्यूनिंग
• जीपीयू पर संभावित अतिरिक्त अनुकूलन: अपाचे स्पार्क कॉन्फ़िगरेशन के लिए रैपिड्स एक्सेलेरेटर