10 मिनट में मेटाफ़्लो सीखें

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



आज हम जिस सामग्री का अनुवाद कर रहे हैं, वह मेटाफ्लो के लिए एक त्वरित मार्गदर्शिका है।

मेटाफ़्लो क्या है?

नीचे नेटफ्लिक्स में मेटाफ्लो फ्रेमवर्क के कार्यान्वयन को दर्शाने वाला एक ग्राफ है।


नेटफ्लिक्स में मेटाफ़्लो कार्यान्वयन

नवंबर 2018 में, कंपनी के 134 परियोजनाओं में इस ढांचे का उपयोग किया गया था।

मेटाफ़्लो डेटा विज्ञान वर्कफ़्लो बनाने और निष्पादित करने के लिए एक रूपरेखा है। इसमें निम्नलिखित विशेषताएं हैं:

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

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

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


एक डेटा वैज्ञानिक की अपनी प्रत्यक्ष जिम्मेदारियों से संबंधित जरूरतों और बुनियादी ढांचे से संबंधित सहायक कार्यों का समाधान, जिस पर गणना की जाती है

मेटाफ़्लो के साथ वर्कफ़्लो परिदृश्य

यहां कुछ वर्कफ़्लो परिदृश्य हैं जिन्हें आप मेटाफ़्लो का उपयोग करके व्यवस्थित कर सकते हैं:

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

विशिष्ट मेटाफ़्लो वर्कफ़्लो

वैचारिक और प्रोग्रामिंग दृष्टिकोण से एक विशिष्ट मेटाफ़्लो कार्यप्रवाह पर विचार करें।

मेटाफ्लो कार्यप्रवाह में atConceptual देखो

एक वैचारिक दृष्टिकोण से, मेटाफ़्लो वर्कफ़्लोज़ (कार्य श्रृंखलाएँ) का निर्देशन चक्रीय रेखांकन (डीएजी) द्वारा किया जाता है । नीचे दिए गए चित्र आपको इस विचार को बेहतर ढंग से समझने में मदद करेंगे।


रेखीय एसाइक्लिक ग्राफ


"समानांतर" रास्तों के साथ चक्रीय ग्राफ

ग्राफ़ का प्रत्येक नोड वर्कफ़्लो में डेटा प्रोसेसिंग चरण का प्रतिनिधित्व करता है।

टास्क चेन के प्रत्येक चरण में, मेटाफ़्लो बिना किसी विशेष परिवर्तन के नियमित पायथन कोड निष्पादित करता है। कोड को अलग-अलग कंटेनरों में निष्पादित किया जाता है जिसमें कोड अपनी निर्भरता के साथ एक साथ पैक किया जाता है।

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

प्रोग्रामिंग के संदर्भ में ▍ मेटाफ़्लो कार्यप्रवाह

प्रत्येक कार्य श्रृंखला (स्ट्रीम) को एक मानक पायथन वर्ग के रूप में दर्शाया जा सकता है (ऐसी कक्षाओं के नाम में आमतौर पर Flow शब्द होता है) यदि यह निम्न न्यूनतम आवश्यकताओं को पूरा करता है:

• वर्ग मेटाफ़्लो FlowSpec वर्ग का वंशज है।
• प्रत्येक फ़ंक्शन जो कार्य श्रृंखला में एक चरण का प्रतिनिधित्व करता है @step डेकोरेटर @step ।
• प्रत्येक @step फ़ंक्शन के अंत में, एक समान फ़ंक्शन का संकेत होना चाहिए जो इसका अनुसरण करता है। यह इस तरह के एक निर्माण का उपयोग करके किया जा सकता है: self.next(self.function_name_here) ।
• कक्षा start और end कार्यों को लागू करता है।

तीन नोड्स वाले कार्यों की एक न्यूनतम श्रृंखला के उदाहरण पर विचार करें।

उसकी योजना इस प्रकार है:

 start → process_message → end 

यहाँ उसका कोड है:

 from metaflow import FlowSpec, step class LinearFlow(FlowSpec):         """     ,      Metaflow.    """       #         @step    def start(self):        self.message = 'Thanks for reading.'        self.next(self.process_message)    @step    def process_message(self):        print('the message is: %s' % self.message)        self.next(self.end)    @step    def end(self):        print('the message is still: %s' % self.message) if __name__ == '__main__':    LinearFlow() 

मेटाफ़्लो स्थापना निर्देश

StInstallation और परीक्षण चलाते हैं

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

• मेटाफ़्लो स्थापित करें (पायथन 3 अनुशंसित): pip3 install metaflow 3 pip3 install metaflow ।
• उपरोक्त कोड टुकड़ा ( यहाँ यह GitHub पर है) को linear_flow.py फ़ाइल में रखें।
• इस कोड द्वारा कार्यान्वित कार्य श्रृंखला की वास्तुकला को देखने के लिए, python3 linear_flow.py show कमांड का उपयोग करें।
• स्ट्रीम शुरू करने के लिए, python3 linear_flow.py run ।

आपको नीचे दिखाए गए के समान कुछ मिलना चाहिए।


सफल मेटाफ़्लो स्वास्थ्य जाँच

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

Cond अंतर्वेशन और कॉन्डा का विन्यास (यदि आप निर्भरता को लागू करने की योजना बनाते हैं)

कोंडा स्थापित करने के लिए इन चरणों का पालन करें:

• मिनिकोंडा को डाउनलोड और इंस्टॉल करें।
• कमांड conda config --add channels conda-forge साथ एक conda चैनल जोड़ें।

अब आप अपने कार्य श्रृंखला में कोंडा निर्भरता को एम्बेड करने के लिए तैयार हैं। इस प्रक्रिया का विवरण नीचे चर्चा की जाएगी।

यथार्थवादी वर्कफ़्लो उदाहरण

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

▍Zadanie

मेटाफ़्लो का उपयोग करके एक वर्कफ़्लो बनाएं जो निम्नलिखित कार्यों को लागू करता है:

• एक पंडों के डेटाफ्रेम में सीएसवी मूवी डेटा लोड हो रहा है।
• शैलियों के लिए चतुर्थक की समानांतर गणना।
• गणना के परिणामों के साथ एक शब्दकोश को सहेजना।

▍ कार्य श्रृंखला

GenreStatsFlow वर्ग का कंकाल GenreStatsFlow दिखाया गया GenreStatsFlow । इसका विश्लेषण करने के बाद, आप हमारी समस्या को हल करने के लिए यहां लागू दृष्टिकोण के सार को समझेंगे।

 from metaflow import FlowSpec, step, catch, retry, IncludeFile, Parameter class GenreStatsFlow(FlowSpec):  """    ,  ,   .         :    1)  CSV-   Pandas.    2)     .    3)     .  """   @step  def start(self):    """         :        1)      Pandas.        2)    .        3)        .    """       # TODO:  CSV         self.genres = []    self.next(self.compute_statistics, foreach='genres') #  1     @catch(var='compute_failed') #  2  @retry(times=1) #  3  @step  def compute_statistics(self):    """    .   ."""    self.genre = self.input #  4    # TODO:        self.next(self.join)     @step  def join(self, inputs):    """       ."""    # TODO:      self.next(self.end)     @step  def end(self):      """End the flow."""      pass   if __name__ == '__main__':  GenreStatsFlow() 

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

• 1 में, start चरण में, foreach पैरामीटर पर ध्यान दें। इसके लिए धन्यवाद, compute_statistics सूची में for each प्रविष्टि के for each लूप के compute_statistics में compute_statistics चरणों की प्रतियां compute_statistics जाती हैं।
• 2 @catch(var='compute_failed') डेकोरेटर @catch(var='compute_failed') चरण compute_statistics किसी भी अपवाद @catch(var='compute_failed') पकड़ @catch(var='compute_failed') और इसे compute_failed चर में लिख देगा (इसे अगले चरण में पढ़ा जा सकता है)।
• 3 @retry(times=1) डेकोरेटर @retry(times=1) वही करता है जो उसका नाम संकेत देता है। अर्थात्, जब त्रुटियां होती हैं, तो वह कदम दोहराता है।
• 4 , self.input , self.input ? बात यह है कि, input मेटाफ़्लो द्वारा प्रदान किया गया एक वर्ग चर है। इसमें एक विशेष compute_statistics लागू डेटा शामिल है (जब समानांतर में निष्पादित फ़ंक्शन की कई प्रतियां हैं)। यह चर मेटाफ़्लो द्वारा तभी जोड़ा जाता है जब नोड्स को कई समानांतर प्रक्रियाओं द्वारा दर्शाया जाता है, या जब कई नोड्स संयुक्त होते हैं।
• यहाँ समान फ़ंक्शन को समानांतर - compute_statistics में चलाने का एक उदाहरण है। लेकिन, यदि आवश्यक हो, तो आप एक साथ पूरी तरह से अलग-अलग फ़ंक्शन चला सकते हैं जो एक-दूसरे से संबंधित नहीं हैं। ऐसा करने के लिए, 1 में जो कुछ दिखाया गया है उसे self.next(self.func1, self.function2, self.function3) । बेशक, इस दृष्टिकोण के साथ, सम्मिलित कदम को फिर से लिखना आवश्यक होगा, जिससे इसके लिए विभिन्न कार्यों के परिणामों को संसाधित करना संभव होगा।

यहाँ ऊपर कंकाल वर्ग की कल्पना करने का तरीका बताया गया है।


GenreStatsFlow वर्ग का दृश्य प्रतिनिधित्व

▍Read डाटा फाइल और ट्रांसफर पैरामीटर

• इस फिल्म CSV फ़ाइल को डाउनलोड करें ।
• अब आपको गतिशील रूप से movie_data फ़ाइल में पथ को स्थानांतरित करने की संभावना और max_genres लिए max_genres मान के समर्थन के साथ कार्यक्रम से लैस करने की आवश्यकता है। बाहरी तर्कों का तंत्र हमें इसमें मदद करेगा। मेटाफ़्लो आपको वर्कफ़्लो स्टार्ट कमांड में अतिरिक्त झंडे का उपयोग करके कार्यक्रम में तर्क पारित करने की अनुमति देता है। उदाहरण के लिए, यह इस तरह दिख सकता है: python3 tutorial_flow.py run --movie_data=path/to/movies.csv --max_genres=5 ।
• मेटाफ़्लो डेवलपर IncludeFile और Parameter ऑब्जेक्ट देता है जो आपको वर्कफ़्लो कोड में इनपुट पढ़ने देता है। हम क्लास वेरिएबल्स में IncludeFile और Parameter ऑब्जेक्ट्स असाइन करके IncludeFile गए तर्कों का संदर्भ देते हैं। यह निर्भर करता है कि हम वास्तव में क्या पढ़ना चाहते हैं - फ़ाइल, या सामान्य मूल्य।

यहां यह दिखाया गया है कि कमांड लाइन से लॉन्च किए जाने पर प्रोग्राम को दिए गए मापदंडों को पढ़ना कैसा लगता है:

     movie_data = IncludeFile("movie_data",                             help="The path to a movie metadata file.",                             default = 'movies.csv')                               max_genres = Parameter('max_genres',                help="The max number of genres to return statistics for",                default=5) 

Task कार्य श्रृंखला में कोंडा का समावेश

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

   def get_python_version():    """     ,    python,       .         conda        python.    """    import platform    versions = {'2' : '2.7.15',                '3' : '3.7.4'}    return versions[platform.python_version_tuple()[0]] #       python. @conda_base(python=get_python_version()) class GenreStatsFlow(FlowSpec): 

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

       @conda(libraries={'pandas' : '0.24.2'})    @step    def start(self): 

• अब निम्नलिखित कमांड निष्पादित करें: python3 tutorial_flow.py --environment=conda run ।

▍Step कार्यान्वयन प्रारंभ

 @conda(libraries={'pandas' : '0.24.2'})    @step    def start(self):    """         :        1)      Pandas.        2)    .        3)        .    """        import pandas        from io import StringIO        #      Pandas.        self.dataframe = pandas.read_csv(StringIO(self.movie_data))        #   'genres'      .         #   .        self.genres = {genre for genres \                       in self.dataframe['genres'] \                       for genre in genres.split('|')}        self.genres = list(self.genres)        #        .        #  'foreach'             #          self.next(self.compute_statistics, foreach='genres') 

इस कोड की कुछ विशेषताओं पर विचार करें:

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

_ कंप्यूट_स्टैटिस्टिक्स चरण का कार्यान्वयन

 @catch(var='compute_failed')    @retry    @conda(libraries={'pandas' : '0.25.3'})    @step    def compute_statistics(self):        """            .        """        #             # 'input'.        self.genre = self.input        print("Computing statistics for %s" % self.genre)        #         ,         #        .        selector = self.dataframe['genres'].\                   apply(lambda row: self.genre in row)        self.dataframe = self.dataframe[selector]        self.dataframe = self.dataframe[['movie_title', 'genres', 'gross']]        #     gross   .        points = [.25, .5, .75]        self.quartiles = self.dataframe['gross'].quantile(points).values        #  ,    .        self.next(self.join) 

कृपया ध्यान दें कि इस चरण में हम उस dataframe चर का उल्लेख करते हैं जो पिछले start चरण में घोषित किया गया था। हम इस चर को संशोधित कर रहे हैं। अगले चरणों पर आगे बढ़ने पर, यह दृष्टिकोण, जो एक नई संशोधित dataframe ऑब्जेक्ट के उपयोग का अर्थ है, आपको डेटा के साथ कुशल कार्य को व्यवस्थित करने की अनुमति देता है।

। जॉइन स्टेप को लागू करें

 @conda(libraries={'pandas' : '0.25.3'})    @step    def join(self, inputs):        """               .        """        inputs = inputs[0:self.max_genres]        #   ,    .        self.genre_stats = {inp.genre.lower(): \                            {'quartiles': inp.quartiles,                             'dataframe': inp.dataframe} \                            for inp in inputs}        self.next(self.end) 

यहाँ यह कुछ बिंदुओं पर प्रकाश डालने लायक है:

• इस चरण में, हम पांडा लाइब्रेरी के पूरी तरह से अलग संस्करण का उपयोग करते हैं।
• inputs ऐरे में प्रत्येक तत्व पहले निष्पादित compute_statistics की एक प्रति है। इसमें संबंधित फ़ंक्शन रन की स्थिति होती है, अर्थात, विभिन्न चर के मान। तो, input[0].quartiles में comedy शैली के लिए input[0].quartiles हो सकते हैं, और input[1].quartiles input[0].quartiles में sci-fi शैली के लिए input[0].quartiles हो सकते हैं।

▍रेड्डी का मसौदा

पूर्ण परियोजना कोड जिसे हमने अभी समीक्षा की है वह यहां पाया जा सकता है ।

यह देखने के लिए कि कैसे tutorial_flow.py फ़ाइल में वर्णित वर्कफ़्लो tutorial_flow.py , आपको निम्न कमांड चलाने की आवश्यकता है:

 python3 tutorial_flow.py --environment=conda show 

वर्कफ़्लो शुरू करने के लिए निम्न कमांड का उपयोग करें:

 python3 tutorial_flow.py --environment=conda run --movie_data=path/to/movies.csv --max_genres=7 

क्लाइंट API का उपयोग करके वर्कफ़्लो चलाने के परिणामों की जाँच करना

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

यहाँ genre_stats के अंतिम सफल प्रक्षेपण के आंकड़ों से लिया गया चर genre_stats के आउटपुट का एक सरल उदाहरण है।

 from metaflow import Flow, get_metadata #      print("Using metadata provider: %s" % get_metadata()) #     MovieStatsFlow. run = Flow('GenreStatsFlow').latest_successful_run print("Using analysis from '%s'" % str(run)) genre_stats = run.data.genre_stats print(genre_stats) 

क्लाउड में वर्कफ़्लोज़ चलाना

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

वर्तमान में, मेटाफ़्लो केवल AWS के साथ एकीकरण का समर्थन करता है। निम्नलिखित छवि में, आप मेटाफ़्लो द्वारा उपयोग किए जाने वाले ऑन-प्रिमाइसेस और क्लाउड संसाधनों की मैपिंग देख सकते हैं।


मेटाफ़्लो और AWS एकीकरण

मेटाफ़्लो को AWS से जोड़ने के लिए, आपको निम्न चरणों को पूरा करना होगा:

• सबसे पहले आपको उन संसाधनों का निर्माण करके एक बार का AWS सेटअप करना होगा जो Metaflow के साथ काम कर सकते हैं। एक ही संसाधनों का उपयोग किया जा सकता है, उदाहरण के लिए, एक कार्य दल के सदस्यों द्वारा जो वर्कफ़्लो के एक दूसरे को प्रदर्शित करते हैं। आप यहां प्रासंगिक निर्देश पा सकते हैं। सेटिंग्स पर्याप्त तेज़ हैं, क्योंकि मेटाफ़्लो में एक क्लाउडफ़ॉर्मेशन सेटिंग टेम्पलेट है।
• अगला, स्थानीय कंप्यूटर पर, आपको metaflow configure aws को चलाने की metaflow configure aws करें और सिस्टम प्रश्नों के उत्तर दर्ज करें। इस डेटा के साथ, मेटाफ़्लो क्लाउड-आधारित डेटा वेयरहाउस का उपयोग करने में सक्षम होगा।
• अब, क्लाउड में स्थानीय वर्कफ़्लोज़ शुरू करने के लिए, वर्कफ़्लो स्टार्ट --with batch सिर्फ --with batch कुंजी जोड़ें। उदाहरण के लिए, यह इस तरह दिख सकता है: python3 sample_flow.py run --with batch ।
• वर्कफ़्लो का हाइब्रिड लॉन्च करने के लिए, यानी स्थानीय स्तर पर कुछ चरणों को करने के लिए, और कुछ क्लाउड में, आपको उन चरणों में @batch डेकोरेटर को जोड़ने की आवश्यकता होती है, जिन्हें क्लाउड में प्रदर्शन करने की आवश्यकता होती है। उदाहरण के लिए, इस तरह: @batch(cpu=1, memory=500) ।

परिणाम

यहां, मैं मेटाफ़्लो सुविधाओं के एक जोड़े पर ध्यान देना चाहूंगा, जिन्हें इस ढांचे के फायदे और नुकसान दोनों पर विचार किया जा सकता है:

• मेटाफ़्लो को कसकर AWS के साथ एकीकृत किया गया है। लेकिन ढांचागत विकास योजनाओं में बड़ी संख्या में क्लाउड प्रदाताओं का समर्थन है।
• मेटाफ़्लो एक उपकरण है जो केवल कमांड लाइन इंटरफ़ेस का समर्थन करता है। इसमें एक ग्राफिकल इंटरफ़ेस नहीं है (काम की प्रक्रियाओं के आयोजन के लिए अन्य सार्वभौमिक रूपरेखाओं के विपरीत, जैसे एयरफ्लो)।

प्रिय पाठकों! क्या आप मेटाफ़्लो का उपयोग करने की योजना बना रहे हैं?