Amazon SageMaker पर RStudio के साथ समानांतर डेटा प्रोसेसिंग

पिछले साल, हमने की सामान्य उपलब्धता की घोषणा की थी अमेज़न सेजमेकर पर RStudio, क्लाउड में उद्योग का पहला पूरी तरह से प्रबंधित RStudio कार्यक्षेत्र एकीकृत विकास वातावरण (IDE)। आप जल्दी से परिचित RStudio IDE लॉन्च कर सकते हैं, और अपने काम को बाधित किए बिना अंतर्निहित कंप्यूट संसाधनों को डायल अप और डाउन कर सकते हैं, जिससे मशीन लर्निंग (एमएल) और एनालिटिक्स सॉल्यूशंस को बड़े पैमाने पर R में बनाना आसान हो जाता है।

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

समाधान अवलोकन

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

सेजमेकर प्रोसेसिंग डेटा वितरित करने के तरीके के लिए विकल्प प्रदान करता है। समानांतर डेटा प्रोसेसिंग के लिए, आपको इसका उपयोग करना चाहिए S3DataDistributionType के लिए ShardedByS3Key विकल्प. जब यह पैरामीटर चुना जाता है, तो सेजमेकर प्रोसेसिंग प्रदान करता है n उदाहरण और वस्तुओं को वितरित करें 1/n उदाहरणों में इनपुट डेटा स्रोत से ऑब्जेक्ट। उदाहरण के लिए, यदि चार डेटा ऑब्जेक्ट के साथ दो इंस्टेंस प्रदान किए जाते हैं, तो प्रत्येक इंस्टेंस को दो ऑब्जेक्ट प्राप्त होते हैं।

सेजमेकर प्रोसेसिंग को प्रोसेसिंग जॉब चलाने के लिए तीन घटकों की आवश्यकता होती है:

• एक कंटेनर छवि जिसमें आपके डेटा प्रोसेसिंग वर्कलोड को चलाने के लिए आपका कोड और निर्भरताएं होती हैं
• Amazon S3 के भीतर इनपुट डेटा स्रोत का पथ
• Amazon S3 के भीतर आउटपुट डेटा स्रोत का पथ

प्रक्रिया को निम्नलिखित आरेख में दर्शाया गया है।

इस पोस्ट में, हम आपको दिखाते हैं कि SageMaker पर RStudio का उपयोग कैसे करें, SageMaker प्रसंस्करण नौकरियों की एक श्रृंखला के साथ इंटरफेस करने के लिए एक समानांतर डेटा प्रोसेसिंग पाइपलाइन बनाने के लिए आर प्रोग्रामिंग भाषा।

समाधान में निम्नलिखित चरण होते हैं:

1. RStudio प्रोजेक्ट सेट करें।
2. प्रसंस्करण कंटेनर छवि बनाएं और पंजीकृत करें।
3. दो-चरणीय प्रसंस्करण पाइपलाइन चलाएँ:
   1. पहला चरण कई डेटा फ़ाइलों को लेता है और उन्हें प्रसंस्करण कार्यों की एक श्रृंखला में संसाधित करता है।
   2. दूसरा चरण आउटपुट फ़ाइलों को जोड़ता है और उन्हें ट्रेन, परीक्षण और सत्यापन डेटासेट में विभाजित करता है।

.. पूर्वापेक्षाएँ

निम्नलिखित पूर्वापेक्षाएँ पूरी करें:

1. सेजमेकर वर्कबेंच पर RStudio सेट करें। अधिक जानकारी के लिए देखें डेटा वैज्ञानिकों के लिए Amazon SageMaker पर पूरी तरह से प्रबंधित RStudio की घोषणा.
2. उपयुक्त एक्सेस अनुमतियों के साथ SageMaker पर RStudio के साथ एक उपयोगकर्ता बनाएँ।

RStudio प्रोजेक्ट सेट करें

RStudio प्रोजेक्ट सेट करने के लिए, निम्न चरणों को पूरा करें:

1. अपने नेविगेट करें अमेज़ॅन सैजमेकर स्टूडियो सेजमेकर कंसोल पर कंट्रोल पैनल।
2. RStudio परिवेश में अपना ऐप लॉन्च करें।
   
3. एक नया RStudio सत्र प्रारंभ करें।
4. के लिए सत्र का नाम, नाम डालें।
5. के लिए उदाहरण प्रकार और छवि, डिफ़ॉल्ट सेटिंग्स का उपयोग करें।
6. चुनें सत्र प्रारंभ करें.
   
7. सत्र में नेविगेट करें।
8. चुनें नई परियोजना, संस्करण नियंत्रण, और फिर गिट का चयन करें.
9. के लिए रिपोजिटरी यूआरएल, दर्ज https://github.com/aws-samples/aws-parallel-data-processing-r.git
10. शेष विकल्पों को डिफ़ॉल्ट के रूप में छोड़ दें और चुनें प्रोजेक्ट बनाएं.
    

आप पर नेविगेट कर सकते हैं aws-parallel-data-processing-R पर निर्देशिका फ़ाइलें भंडार देखने के लिए टैब। रिपॉजिटरी में निम्नलिखित फाइलें हैं:

• Container_Build.rmd
• /dataset
  • bank-additional-full-data1.csv
  • bank-additional-full-data2.csv
  • bank-additional-full-data3.csv
  • bank-additional-full-data4.csv
• /docker
• Dockerfile-Processing
• Parallel_Data_Processing.rmd
• /preprocessing
  • filter.R
  • process.R

कंटेनर बनाएँ

इस चरण में, हम अपनी प्रोसेसिंग कंटेनर इमेज बनाते हैं और इसे आगे बढ़ाते हैं अमेज़ॅन इलास्टिक कंटेनर रजिस्ट्री (अमेज़ॅन ईसीआर)। निम्नलिखित चरणों को पूरा करें:

1. पर नेविगेट करें Container_Build.rmd फ़ाइल.
2. स्थापित करें सेजमेकर स्टूडियो इमेज बिल्ड सीएलआई निम्नलिखित सेल चलाकर। सुनिश्चित करें कि इस चरण को पूरा करने से पहले आपके पास आवश्यक अनुमतियां हैं, यह एक सीएलआई है जिसे स्टूडियो के भीतर कंटेनर छवियों को पुश और पंजीकृत करने के लिए डिज़ाइन किया गया है।

   pip install sagemaker-studio-image-build

3. हमारे प्रोसेसिंग कंटेनर को बनाने और पंजीकृत करने के लिए अगला सेल चलाएँ:

   /home/sagemaker-user/.local/bin/sm-docker build . --file ./docker/Dockerfile-Processing --repository sagemaker-rstudio-parallel-processing:1.0

कार्य सफलतापूर्वक चलने के बाद, आपको निम्न जैसा दिखने वाला आउटपुट प्राप्त होता है:

Image URI: <Account_Number>.dkr.ecr.<Region>.amazonaws.com/sagemaker-rstudio- parallel-processing:1.0

प्रसंस्करण पाइपलाइन चलाएँ

कंटेनर बनाने के बाद, पर नेविगेट करें Parallel_Data_Processing.rmd फ़ाइल। इस फ़ाइल में चरणों की एक श्रृंखला है जो हमें सेजमेकर प्रोसेसिंग का उपयोग करके समानांतर डेटा प्रोसेसिंग पाइपलाइन बनाने में मदद करती है। निम्नलिखित आरेख पाइपलाइन के उन चरणों को दर्शाता है जिन्हें हम पूरा करते हैं।

पैकेज आयात चरण चलाकर प्रारंभ करें। SageMaker SDK के साथ आवश्यक RStudio पैकेज आयात करें:

suppressWarnings(library(dplyr))
suppressWarnings(library(reticulate))
suppressWarnings(library(readr))
path_to_python <- system(‘which python’, intern = TRUE)

use_python(path_to_python)
sagemaker <- import('sagemaker')

अब अपनी सेजमेकर निष्पादन भूमिका और पर्यावरण विवरण सेट करें:

role = sagemaker$get_execution_role()
session = sagemaker$Session()
bucket = session$default_bucket()
account_id <- session$account_id()
region <- session$boto_region_name
local_path <- dirname(rstudioapi::getSourceEditorContext()$path)

उस कंटेनर को प्रारंभ करें जिसे हमने पहले चरण में बनाया और पंजीकृत किया था:

container_uri <- paste(account_id, "dkr.ecr", region, "amazonaws.com/sagemaker-rstudio-parallel-processing:1.0", sep=".")
print(container_uri)

यहां से हम प्रत्येक प्रसंस्करण चरण में अधिक विस्तार से गोता लगाते हैं।

डेटासेट अपलोड करें

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

local_dataset_path <- paste0(local_path,"/dataset/")

dataset_files <- list.files(path=local_dataset_path, pattern=".csv$", full.names=TRUE)
for (file in dataset_files){
  session$upload_data(file, bucket=bucket, key_prefix="sagemaker-rstudio-example/split")
}

input_s3_split_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/split")

फ़ाइलें अपलोड होने के बाद, अगले चरण पर जाएँ।

समानांतर डेटा प्रोसेसिंग करें

इस चरण में, हम डेटा फ़ाइलें लेते हैं और कुछ स्तंभों को फ़िल्टर करने के लिए फ़ीचर इंजीनियरिंग करते हैं। यह कार्य प्रसंस्करण उदाहरणों की एक श्रृंखला में वितरित किया जाता है (हमारे उदाहरण के लिए, हम दो का उपयोग करते हैं)।

हम उपयोग filter.R डेटा को संसाधित करने के लिए फ़ाइल, और कार्य को निम्नानुसार कॉन्फ़िगर करें:

filter_processor <- sagemaker$processing$ScriptProcessor(command=list("Rscript"),
                                                        image_uri=container_uri,
                                                        role=role,
                                                        instance_count=2L,
                                                        instance_type="ml.m5.large")

output_s3_filter_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/filtered")
s3_filter_input <- sagemaker$processing$ProcessingInput(source=input_s3_split_location,
                                                        destination="/opt/ml/processing/input",
                                                        s3_data_distribution_type="ShardedByS3Key",
                                                        s3_data_type="S3Prefix")
s3_filter_output <- sagemaker$processing$ProcessingOutput(output_name="bank-additional-full-filtered",
                                                         destination=output_s3_filter_location,
                                                         source="/opt/ml/processing/output")

filtering_step <- sagemaker$workflow$steps$ProcessingStep(name="FilterProcessingStep",
                                                      code=paste0(local_path, "/preprocessing/filter.R"),
                                                      processor=filter_processor,
                                                      inputs=list(s3_filter_input),
                                                      outputs=list(s3_filter_output))

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

s3_data_distribution_type="ShardedByS3Key",
                                                      s3_data_type="S3Prefix")

आपके द्वारा इन मापदंडों को सम्मिलित करने के बाद, सेजमेकर प्रोसेसिंग चयनित उदाहरणों की संख्या में डेटा को समान रूप से वितरित करेगा।

आवश्यकतानुसार मापदंडों को समायोजित करें, और फिर कार्य को तत्काल करने के लिए कक्ष चलाएँ।

प्रशिक्षण, परीक्षण और सत्यापन डेटासेट उत्पन्न करें

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

हम उपयोग process.R डेटा को संसाधित करने के लिए फ़ाइल, और कार्य को निम्नानुसार कॉन्फ़िगर करें:

script_processor <- sagemaker$processing$ScriptProcessor(command=list("Rscript"),
                                                         image_uri=container_uri,
                                                         role=role,
                                                         instance_count=1L,
                                                         instance_type="ml.m5.large")

output_s3_processed_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/processed")
s3_processed_input <- sagemaker$processing$ProcessingInput(source=output_s3_filter_location,
                                                         destination="/opt/ml/processing/input",
                                                         s3_data_type="S3Prefix")
s3_processed_output <- sagemaker$processing$ProcessingOutput(output_name="bank-additional-full-processed",
                                                         destination=output_s3_processed_location,
                                                         source="/opt/ml/processing/output")

processing_step <- sagemaker$workflow$steps$ProcessingStep(name="ProcessingStep",
                                                      code=paste0(local_path, "/preprocessing/process.R"),
                                                      processor=script_processor,
                                                      inputs=list(s3_processed_input),
                                                      outputs=list(s3_processed_output),
                                                      depends_on=list(filtering_step))

मापदंडों को समायोजित करना आवश्यक है, और फिर कार्य को त्वरित करने के लिए कक्ष को चलाएँ।

पाइपलाइन चलाएं

सभी चरणों के तत्काल होने के बाद, निम्न कक्ष चलाकर प्रत्येक चरण को चलाने के लिए प्रसंस्करण पाइपलाइन प्रारंभ करें:

pipeline = sagemaker$workflow$pipeline$Pipeline(
  name="BankAdditionalPipelineUsingR",
  steps=list(filtering_step, processing_step)
)

upserted <- pipeline$upsert(role_arn=role)
execution <- pipeline$start()

execution$describe()
execution$wait()

इनमें से प्रत्येक कार्य में लगने वाला समय इंस्टेंस आकार और चयनित गणना के आधार पर अलग-अलग होगा।

अपने सभी प्रसंस्करण कार्य देखने के लिए सेजमेकर कंसोल पर नेविगेट करें।

हम फ़िल्टरिंग कार्य से शुरू करते हैं, जैसा कि निम्नलिखित स्क्रीनशॉट में दिखाया गया है।

जब यह पूरा हो जाता है, तो पाइपलाइन डेटा प्रोसेसिंग कार्य में चली जाती है।

जब दोनों कार्य पूरे हो जाएं, तो अपने S3 बकेट पर नेविगेट करें। के भीतर देखो sagemaker-rstudio-example फ़ोल्डर, के तहत processed. आप ट्रेन, परीक्षण और सत्यापन डेटासेट के लिए फ़ाइलें देख सकते हैं।

निष्कर्ष

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

इस समाधान में उपयोग की जाने वाली सुविधाओं और सेवाओं के बारे में अधिक जानने के लिए, देखें अमेज़न सेजमेकर पर RStudio और अमेज़न SageMaker प्रसंस्करण.

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

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

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

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

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

पॉल वू टेक्सास में एडब्ल्यूएस 'ग्रीनफील्ड बिजनेस में काम कर रहे एक समाधान वास्तुकार है। उनकी विशेषज्ञता के क्षेत्रों में कंटेनर और पलायन शामिल हैं।