1. परिचय
| Kubeflow, Kubernetes के लिए एक मशीन लर्निंग टूलकिट है. इस प्रोजेक्ट का मकसद, Kubernetes पर मशीन लर्निंग (एमएल) के वर्कफ़्लो को डिप्लॉय करना करना है. साथ ही, इसे इस्तेमाल करना आसान और पोर्टेबल है. इसका मकसद, एमएल के लिए सबसे बेहतर ओपन सोर्स सिस्टम को अलग-अलग इन्फ़्रास्ट्रक्चर के लिए आसान तरीके से डिप्लॉय करना है. |
| मशीन लर्निंग वर्कफ़्लो में एक-दूसरे पर निर्भर होने वाले कई चरण शामिल हो सकते हैं. इनमें डेटा तैयार करना और उसका विश्लेषण करना, ट्रेनिंग, आकलन करना, डिप्लॉयमेंट करना वगैरह शामिल है. इन प्रोसेस को ऐड-हॉक तरीके से लिखना और ट्रैक करना मुश्किल है. उदाहरण के लिए, नोटबुक या स्क्रिप्ट के किसी सेट में. ऑडिटिंग और फिर से बनाने जैसी चीज़ों में समस्याएं आने लगती हैं.Kubeflow पाइपलाइन (केएफ़पी), इन समस्याओं को हल करने में मदद करती है. यह मशीन लर्निंग पाइपलाइन को मॉनिटर करने, ऑडिट करने, वर्शन को ट्रैक करने, और फिर से बनाने के साथ-साथ उसे डिप्लॉय करने में मदद करती है. Cloud AI Pipelines की मदद से, केएफ़पी इंस्टॉलेशन को सेट अप करना आसान हो जाता है. |
आपको क्या बनाना होगा
इस कोडलैब में, आपको एक वेब ऐप्लिकेशन बनाना होगा. इस वेब ऐप्लिकेशन में, GitHub से जुड़ी समस्याओं की जानकारी दी जाएगी. इसके लिए, Kubeflow Pipelines का इस्तेमाल करके, मॉडल को ट्रेनिंग दी जाएगी और उसे उपलब्ध कराया जाएगा. यह Kubeflow के उदाहरणों के रेपो के उदाहरण पर आधारित है. काम पूरा होने पर, आपके इन्फ़्रास्ट्रक्चर में ये चीज़ें शामिल होंगी:
- Google Kubernetes Engine (जीकेई) क्लस्टर, जिसमें Kubeflow पाइपलाइन इंस्टॉल की गई हैं. इसके लिए, Cloud AI Pipelines का इस्तेमाल किया जा सकता है.
- जीपीयू पर Tensor2Tensor मॉडल को ट्रेनिंग देने वाली पाइपलाइन
- एक ऐसा कंटेनर, जो ट्रेन किए गए मॉडल के अनुमान दिखाता है
- ऐसा यूज़र इंटरफ़ेस (यूआई) जो GitHub की समस्याओं के बारे में खास जानकारी देने के लिए, सुझावों को समझता है
- एक नोटबुक जो Kubeflow Pipelines (KFP) SDK का इस्तेमाल करके, शुरुआत से एक पाइपलाइन बनाती है
आपको इनके बारे में जानकारी मिलेगी
आपकी बनाई हुई पाइपलाइन, GitHub से जुड़ी समस्या के डेटा पर Tensor2Tensor मॉडल को ट्रेनिंग देगी. इससे, समस्या के मुख्य भाग से समस्या के टाइटल का अनुमान लगाना सिखाया जाएगा. इसके बाद, यह ट्रेन किए गए मॉडल को एक्सपोर्ट करता है और Tensorflow Serving की मदद से, एक्सपोर्ट किए गए मॉडल को डिप्लॉय करता है. पाइपलाइन के आखिरी चरण में एक वेब ऐप्लिकेशन लॉन्च किया जाता है. यह मॉडल का अनुमान लगाने के लिए, TF-Serving इंस्टेंस से इंटरैक्ट करता है.
- GKE (जीकेई) क्लस्टर में Kubeflow Pipelines इंस्टॉल करने का तरीका
- Kubeflow Pipelines का इस्तेमाल करके एमएल वर्कफ़्लो बनाने और चलाने का तरीका
- AI Platform Notebook से पाइपलाइन तय करने और उन्हें चलाने का तरीका
आपको इन चीज़ों की ज़रूरत होगी
- Kubernetes की बुनियादी समझ मददगार होगी. हालांकि, यह ज़रूरी नहीं है
- एक चालू GCP प्रोजेक्ट जिसका मालिकाना हक आपके पास हो
- (ज़रूरी नहीं) GitHub खाता
- Google Cloud Shell का ऐक्सेस, Google Cloud Platform (GCP) Console में उपलब्ध है
2. सेटअप
क्लाउड शेल
ब्राउज़र में GCP कंसोल पर जाएं और अपने प्रोजेक्ट क्रेडेंशियल से लॉग इन करें:
"प्रोजेक्ट चुनें" पर क्लिक करें ताकि आप अपने कोडलैब प्रोजेक्ट के साथ काम कर सकें.
इसके बाद, "Cloud Shell को चालू करें" पर क्लिक करें आइकॉन का इस्तेमाल करें.
Cloud Shell को शुरू करने पर, आपको उस प्रोजेक्ट का नाम पता चलेगा जिसे इस्तेमाल करने के लिए सेट किया गया है. देखें कि यह सेटिंग सही है या नहीं.
अपना प्रोजेक्ट आईडी ढूंढने के लिए, GCP कंसोल के होम पैनल पर जाएं. अगर स्क्रीन खाली है, तो ‘हां' पर क्लिक करें डैशबोर्ड बनाने के लिए प्रॉम्प्ट पर.
इसके बाद, Cloud Shell टर्मिनल में, अगर ज़रूरी हो, तो सही प्रोजेक्ट का इस्तेमाल करने के लिए gcloud को कॉन्फ़िगर करने के लिए, ये कमांड चलाएं:
export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}
स्टोरेज बकेट बनाना
पाइपलाइन में फ़ाइलें सेव करने के लिए, Cloud Storage बकेट बनाएं. आपको दुनिया भर में लागू होने वाले यूनीक आईडी का इस्तेमाल करना होगा. इसलिए, बकेट का नाम तय करना आसान है जिसमें आपका प्रोजेक्ट आईडी शामिल हो. gsutil mb (बकेट बनाएं) कमांड का इस्तेमाल करके बकेट बनाएं:
export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}
इसके अलावा, GCP कंसोल के ज़रिए बकेट बनाई जा सकती है.
ज़रूरी नहीं**: GitHub टोकन बनाएं**
यह कोडलैब, सार्वजनिक तौर पर उपलब्ध डेटा को वापस लाने के लिए, GitHub API को कॉल करता है. अनुरोध संख्या सीमित करने से रोकने के लिए, खास तौर पर ऐसे इवेंट में जब GitHub API को बड़ी संख्या में पहचान छिपाकर अनुरोध भेजे जाते हैं, एक ऐसा ऐक्सेस टोकन सेट अप करें जिसके लिए अनुमति न हो. इसका मकसद आपको पहचान छिपाने वाले उपयोगकर्ता के बजाय एक व्यक्ति के तौर पर अनुमति देना है.
- https://github.com/settings/tokens पर जाएं और बिना किसी स्कोप वाला नया टोकन जनरेट करें.
- इसे किसी सुरक्षित जगह पर सेव करें. अगर आपसे यह फ़ाइल हट जाती है, तो आपको इसे मिटाकर नया खाता बनाना होगा.
अगर आप इस चरण को छोड़ देते हैं, तो लैब अब भी काम करेगा – आपको अपने मॉडल की जांच करने के लिए, इनपुट डेटा जनरेट करने के ज़्यादा विकल्प मिलेंगे.
ज़रूरी नहीं: काम के डैशबोर्ड को पिन करना
आसानी से ऐक्सेस करने के लिए, GCP कंसोल में Kubernetes Engine और स्टोरेज डैशबोर्ड को पिन करें.
AI Platform Pipelines (होस्ट किया गया Kubeflow Pipelines) इंस्टॉलेशन बनाना
'शुरू करने से पहले' में दिए गए निर्देशों का पालन करें और 'अपना इंस्टेंस सेट अप करें' सेक्शन यहां दिए गए हैं. दस्तावेज़ में बताए गए तरीके के मुताबिक, इन Cloud API का ऐक्सेस दें बॉक्स पर सही का निशान लगाना पक्का करें. (अगर ऐसा नहीं किया जाता है, तो उदाहरण पाइपलाइन सफलतापूर्वक नहीं चलेगी). इंस्टॉलेशन नेमस्पेस को default के तौर पर छोड़ें.
आपको ऐसा ज़ोन चुनना होगा जो Nvidia k80s के साथ काम करता हो. डिफ़ॉल्ट के तौर पर, us-central1-a या us-central1-c का इस्तेमाल किया जा सकता है.
इंस्टॉल पूरा होने के बाद, एआई पाइपलाइन डैशबोर्ड में आपके इंस्टॉलेशन के लिए दिए गए GKE (जीकेई) क्लस्टर का नाम और ज़ोन देखें. साथ ही, इन वैल्यू के लिए एनवायरमेंट वैरिएबल की सुविधा सेट करें.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
अपने नए GKE (जीकेई) क्लस्टर के क्रेडेंशियल का इस्तेमाल करने के लिए, kubectl सेट अप करना
GKE (जीकेई) क्लस्टर बनने के बाद, नए क्लस्टर के क्रेडेंशियल का इस्तेमाल करने के लिए, kubectl को कॉन्फ़िगर करें. इसके लिए, अपने क्लाउड शेल में यह निर्देश चलाएं:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--project ${PROJECT_ID} \
--zone ${ZONE}
इसके अलावा, एआई पाइपलाइन डैशबोर्ड में क्लस्टर के नाम पर क्लिक करके, उसके GKE (जीकेई) पेज पर जाएं. इसके बाद, "कनेक्ट करें" पर क्लिक करें पेज में सबसे ऊपर मौजूद बटन पर क्लिक करें. पॉप-अप से, कमांड को अपने Cloud Shell में चिपकाएं.
यह आपके kubectl कॉन्टेक्स्ट को कॉन्फ़िगर करता है, ताकि आप अपने क्लस्टर से इंटरैक्ट कर सकें. कॉन्फ़िगरेशन की पुष्टि करने के लिए, यह निर्देश चलाएं:
kubectl get nodes -o wide
आपको "Ready" स्थिति वाले नोड और नोड की उम्र, वर्शन, बाहरी आईपी पता, ओएस इमेज, कर्नेल वर्शन, और कंटेनर रनटाइम के बारे में अन्य जानकारी दिखेगी.
जीपीयू-चालू नोड पूल पर Nvidia ड्राइवर इंस्टॉल करने के लिए, क्लस्टर को कॉन्फ़िगर करें
इसके बाद, हम क्लस्टर में एक डेमोसेट लागू करेंगे. इससे जीपीयू की सुविधा वाले किसी भी क्लस्टर नोड पर Nvidia ड्राइवर इंस्टॉल हो जाएगा:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
इसके बाद नीचे दिया गया कमांड चलाएं, जो KFP कॉम्पोनेंट को नए Kubernetes संसाधन बनाने की अनुमति देता है:
kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner
जीपीयू नोड पूल बनाना
इसके बाद, हम 1 साइज़ वाला जीपीयू नोड पूल सेट अप करेंगे:
gcloud container node-pools create gpu-pool \
--cluster=${CLUSTER_NAME} \
--zone ${ZONE} \
--num-nodes=1 \
--machine-type n1-highmem-8 \
--scopes cloud-platform --verbosity error \
--accelerator=type=nvidia-tesla-k80,count=1
3. Pipelines डैशबोर्ड से पाइपलाइन चलाएं
पाइपलाइन डैशबोर्ड खोलें
अगर आप पाइपलाइन पैनल पर पहले से नहीं हैं, तो Cloud Console में जाकर उस पर जाएं. इसके बाद, "पाइपलाइन डैशबोर्ड खोलें" पर क्लिक करें को इंस्टॉल करें और बाएं मेन्यू बार में पाइपलाइन पर क्लिक करें. अगर आपको लोड से जुड़ी गड़बड़ी का मैसेज दिखता है, तो टैब को रीफ़्रेश करें. आपको नया पेज इस तरह दिखेगा:
पाइपलाइन की जानकारी
जो पाइपलाइन चलाई जाएगी उसमें कई चरण हैं (जानकारी के लिए इस कोडलैब का अपेंडिक्स देखें):
- एक मौजूदा मॉडल चेकपॉइंट आपके बकेट में कॉपी हो जाता है.
- Tensor2Tensor मॉडल को पहले से प्रोसेस किए गए डेटा का इस्तेमाल करके ट्रेनिंग दी जाती है.
- ट्रेनिंग पहले चरण में कॉपी किए गए मौजूदा मॉडल चेकपॉइंट से शुरू होती है. इसके बाद, ट्रेनिंग कुछ सौ कदमों के लिए की जाती है. (कोडलैब के दौरान इसे पूरी तरह से ट्रेनिंग देने में बहुत ज़्यादा समय लगेगा).
- ट्रेनिंग पूरी होने के बाद, पाइपलाइन स्टेप में मॉडल को ऐसे फ़ॉर्मैट में एक्सपोर्ट किया जाता है जो TensorFlow को ब्राउज़र में दिखाने के लिए सही होता है.
- उस मॉडल का इस्तेमाल करके, TensorFlow का सर्विंग इंस्टेंस लागू किया गया है.
- वेब ऐप्लिकेशन को, दिखाए गए मॉडल से इंटरैक्ट करने के लिए लॉन्च किया जाता है, ताकि अनुमान पाए जा सकें.
पाइपलाइन डाउनलोड और कंपाइल करना
इस सेक्शन में, हम पाइपलाइन की परिभाषा को बनाने का तरीका देखेंगे. हमें सबसे पहले KFP SDK टूल इंस्टॉल करना होगा. Cloud Shell में इन्हें चलाएं:
pip3 install -U kfp
पाइपलाइन की परिभाषा वाली फ़ाइल डाउनलोड करने के लिए, Cloud Shell से इस निर्देश को एक्ज़ीक्यूट करें:
curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py
इसके बाद, पाइपलाइन की परिभाषा फ़ाइल को इस तरह चलाकर, कंपाइल करें:
python3 gh_summ_hosted_kfp.py
आपको gh_summ_hosted_kfp.py.tar.gz फ़ाइल दिखेगी.
कंपाइल की गई पाइपलाइन अपलोड करना
Kubeflow Pipelines के वेब यूज़र इंटरफ़ेस में, अपलोड पाइपलाइन पर क्लिक करें और यूआरएल से इंपोर्ट करें चुनें. इसे कॉपी करें और फिर नीचे दिया गया यह यूआरएल चिपकाएं. यह यूआरएल उसी पाइपलाइन पर ले जाएगा जिसे आपने अभी-अभी कंपाइल किया है. (Cloud Shell से फ़ाइल अपलोड करने के कुछ और चरण हैं, इसलिए हम शॉर्टकट ले रहे हैं).
पाइपलाइन को एक नाम दें (उदाहरण, gh_summ).
पाइपलाइन चलाएं
सूची में अपलोड की गई पाइपलाइन पर क्लिक करें —इससे पाइपलाइन का स्टैटिक ग्राफ़ देखा जा सकता है—इसके बाद, पाइपलाइन का इस्तेमाल करके एक नया प्रयोग बनाने के लिए प्रयोग बनाएं पर क्लिक करें. एक्सपेरिमेंट, वाक्य की बनावट के हिसाब से रनों को एक साथ ग्रुप करने का तरीका है.
प्रयोग को कोई नाम दें (उदा. पाइपलाइन के नाम के जैसा ही नाम, gh_summ), फिर बनाने के लिए आगे बढ़ें पर क्लिक करें.
इससे एक पेज खुल जाएगा, जहां पर रन के लिए पैरामीटर डाले जा सकते हैं और उसे शुरू किया जा सकता है.
पैरामीटर भरने में मदद करने के लिए, Cloud Shell में ये कमांड इस्तेमाल किए जा सकते हैं.
gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"
दौड़ने का नाम अपने-आप भर जाएगा, लेकिन अगर आप चाहें, तो इसे कोई दूसरा नाम दिया जा सकता है.
इसके बाद, तीन पैरामीटर फ़ील्ड भरें:
project- (ज़रूरी नहीं)
github-token working-dir
वर्किंग-डायर के लिए, अपने बनाए गए GCS बकेट में कुछ पाथ डालें. ‘gs://' शामिल करें उपसर्ग. github-token फ़ील्ड के लिए, वह टोकन डालें जिसे आपने वैकल्पिक रूप से पहले जनरेट किया था या प्लेसहोल्डर स्ट्रिंग को ऐसे ही रहने दें, जैसे कि आपने टोकन जनरेट नहीं किया हो.
फ़ील्ड भरने के बाद, शुरू करें पर क्लिक करें. इसके बाद, चुनी गई दौड़ की जानकारी देखने के लिए उस पर क्लिक करें. जब कोई पाइपलाइन चरण चल रहा हो, तो आप उसके पॉड लॉग को देखने के साथ-साथ उसके बारे में ज़्यादा जानकारी पाने के लिए, उस पर क्लिक कर सकते हैं. Cloud Logging (स्टैकड्राइवर) लॉग के लिंक के ज़रिए, पाइपलाइन स्टेप के लॉग भी देखे जा सकते हैं, भले ही क्लस्टर नोड बंद कर दिया गया हो.
पाइपलाइन की परिभाषा देखना
पाइपलाइन के काम करने के दौरान, हो सकता है कि आप इस बात पर करीब से गौर करना चाहें कि इसे कैसे एक साथ रखा जा रहा है और यह क्या कर रहा है. कोडलैब के अपेंडिक्स सेक्शन में ज़्यादा जानकारी दी गई है.
TensorBoard में मॉडल ट्रेनिंग की जानकारी देखें
ट्रेनिंग पूरी हो जाने के बाद, उसका विज़ुअलाइज़ेशन टैब चुनें और नीले रंग के TensorBoard शुरू करें बटन पर क्लिक करें. इसके बाद, जब वह तैयार हो जाए, तो Tensorboard खोलें पर क्लिक करें.
आर्टफ़ैक्ट और उससे जुड़े काम करने के डैशबोर्ड को एक्सप्लोर करना
Kubeflow Pipelines, पाइपलाइन के चलने पर पाइपलाइन के चरणों का मेटाडेटा अपने आप लॉग करता है. Artifact और Artifact, दोनों की जानकारी रिकॉर्ड की जाती है. ज़्यादा जानने के लिए, डैशबोर्ड के बाएं नेविगेशन बार में मौजूद इन एंट्री पर क्लिक करें.
आर्टफ़ैक्ट के लिए, खास जानकारी वाले पैनल और Lineage Explorer पैनल, दोनों को देखा जा सकता है.
पाइपलाइन से बनाए गए वेब ऐप्लिकेशन को इकट्ठा करना और कुछ अनुमान लगाना
पाइपलाइन के आखिरी चरण में एक वेब ऐप्लिकेशन डिप्लॉय किया जाता है. यह यूज़र इंटरफ़ेस (यूआई) उपलब्ध कराता है, ताकि अनुमान लगाने के लिए वेब ऐप्लिकेशन को TF सर्विंग की मदद से दिखाया जा सके. इस यूज़र इंटरफ़ेस (यूआई) की मदद से, ट्रेन किए गए मॉडल की क्वेरी की जा सकती है.
पाइपलाइन पूरी होने के बाद, वेब ऐप्लिकेशन को पोर्ट-फ़ॉरवर्डिंग की मदद से उसकी सेवा से कनेक्ट करें (हम पोर्ट-फ़ॉरवर्डिंग कर रहे हैं, क्योंकि इस कोडलैब के लिए webapp सेवा में कोई बाहरी एंडपॉइंट सेट अप नहीं किया गया है).
Cloud Shell में इस कमांड को चलाकर सेवा का नाम ढूंढें:
kubectl get services
सूची में इस तरह की सेवा का नाम ढूंढें: ghsumm-*-webappsvc.
इसके बाद, Cloud Shell में, उस सेवा को नीचे बताए गए तरीके से पोर्ट-फ़ॉरवर्ड करें और अपने webappsvc के नाम का इस्तेमाल करने के लिए, यहां दिए गए कमांड में बदलाव करें:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
पोर्ट-फ़ॉरवर्डिंग की सुविधा चालू होने के बाद, 'झलक देखें' पर क्लिक करें आइकॉन पर क्लिक करें और ड्रॉपडाउन में, "पोर्ट 8080 पर झलक देखें" पर क्लिक करें.
आपको नए टैब में, इस तरह का पेज दिखेगा:
टेक्स्ट का ब्लॉक वापस पाने के लिए, किसी भी क्रम में लगाई गई समस्या को भरें बटन पर क्लिक करें. ट्रेन किए गए मॉडल को कॉल करने और सुझाव दिखाने के लिए, Generate title पर क्लिक करें.
अगर आपकी पाइपलाइन पैरामीटर में कोई मान्य GitHub टोकन शामिल है, तो दूसरे फ़ील्ड में GitHub यूआरएल डालकर, "टाइटल जनरेट करें" पर क्लिक करके भी ऐसा किया जा सकता है. अगर आपने मान्य GitHub टोकन सेट अप नहीं किया है, तो सिर्फ़ "रैंडम तरीके से अपने-आप जनरेट होने वाली समस्या" का इस्तेमाल करें फ़ील्ड में डालें.
4. AI Platform Notebook से पाइपलाइन चलाएं
आप KFP SDK का इस्तेमाल करके, Jupyter notebook से Kubeflow Pipelines को इंटरैक्टिव तरीके से तय कर सकते हैं और चला सकते हैं. AI Platform Notebooks, जिसका इस्तेमाल हम इस कोडलैब के लिए करेंगे. इससे यह काम आसान हो जाता है.
नोटबुक इंस्टेंस बनाना
हम Cloud Shell के एपीआई का इस्तेमाल करके, Cloud Shell से नोटबुक इंस्टेंस बनाएंगे. (इसके अलावा, Cloud Console की मदद से नोटबुक बनाई जा सकती है. ज़्यादा जानकारी के लिए दस्तावेज़ देखें).
Cloud Shell में ये एनवायरमेंट वैरिएबल सेट करें:
export INSTANCE_NAME="kfp-ghsumm" export VM_IMAGE_PROJECT="deeplearning-platform-release" export VM_IMAGE_FAMILY="tf2-2-3-cpu" export MACHINE_TYPE="n1-standard-4" export LOCATION="us-central1-c"
इसके बाद, Cloud Shell से, notebook का इंस्टेंस बनाने के लिए कमांड चलाएं:
gcloud beta notebooks instances create $INSTANCE_NAME \ --vm-image-project=$VM_IMAGE_PROJECT \ --vm-image-family=$VM_IMAGE_FAMILY \ --machine-type=$MACHINE_TYPE --location=$LOCATION
पहली बार इस निर्देश को चलाने पर, आपसे अपने प्रोजेक्ट के लिए notebooks एपीआई को चालू करने के लिए कहा जा सकता है. ‘y' जवाब दें अगर हां.
कुछ मिनट बाद, आपका notebook सर्वर चालू हो जाएगा. Notebook के इंस्टेंस, Cloud Console में सूची में देखे जा सकते हैं.
कोडलैब नोटबुक अपलोड करना
Notebook का इंस्टेंस बनाने के बाद, कोडलैब की Jupyter notebook को अपलोड करने के लिए, इस लिंक पर क्लिक करें. इस्तेमाल करने के लिए notebook का इंस्टेंस चुनें. नोटबुक अपने-आप खुल जाएगी.
Notebook का इस्तेमाल करना
लैब के बचे हुए हिस्से के लिए, नोटबुक में दिए गए निर्देशों का पालन करें. ध्यान दें कि "सेटअप" में होने पर, बाकी नोटबुक को चलाने से पहले आपको खुद की वैल्यू भरनी होगी.
(अगर आप अपने प्रोजेक्ट का इस्तेमाल कर रहे हैं, तो वापस आकर इस लैब के "साफ़ करें" सेक्शन पर जाएं).
5. व्यवस्थित करें
अगर किसी अस्थायी कोडलैब खाते का इस्तेमाल किया जा रहा है, तो आपको ऐसा करने की ज़रूरत नहीं है. हालांकि, अपने प्रोजेक्ट का इस्तेमाल करने पर, पाइपलाइन इंस्टॉल करने और नोटबुक को बंद करने का विकल्प चुना जा सकता है.
पाइपलाइन GKE (जीकेई) क्लस्टर को हटाना
Cloud Console से, पाइपलाइन क्लस्टर को मिटाया जा सकता है. (अगर आपको GKE (जीकेई) क्लस्टर का फिर से इस्तेमाल करना है, तो आपके पास पाइपलाइन इंस्टॉलेशन को मिटाने का विकल्प है).
एआई नोटबुक के इंस्टेंस को मिटाना
अगर आपने "नोटबुक" चलाया है, तो कोडलैब का हिस्सा होने पर, Cloud Console से notebook के इंस्टेंस को मिटाया या रोकें.
ज़रूरी नहीं: GitHub टोकन हटाएं
https://github.com/settings/tokens पर जाएं और जनरेट किया गया टोकन हटाएं.
6. अपेंडिक्स
कोड पर एक नज़र
पाइपलाइन तय करना
इस कोडलैब में इस्तेमाल की जाने वाली पाइपलाइन के बारे में यहां बताया गया है.
आइए, देखते हैं कि इसे कैसे परिभाषित किया गया है और इसके कॉम्पोनेंट (कदम) कैसे परिभाषित किए गए हैं. हम कुछ हाइलाइट शामिल करेंगे, लेकिन ज़्यादा जानकारी के लिए दस्तावेज़ देखें.
Kubeflow पाइपलाइन के चरण कंटेनर पर आधारित हैं. पाइपलाइन बनाते समय, पहले से बने कंटेनर इमेज के साथ-साथ पहले से बने कॉम्पोनेंट इस्तेमाल किए जा सकते हैं. इसके अलावा, अपने कॉम्पोनेंट भी बनाए जा सकते हैं. इस कोडलैब के लिए, हमने अपना एक कोड बनाया है.
पाइपलाइन के चार चरण, फिर से इस्तेमाल किए जा सकने वाले कॉम्पोनेंट से तय किए जाते हैं. इन्हें कॉम्पोनेंट डेफ़िनिशन फ़ाइलों से ऐक्सेस किया जाता है. इस पहले कोड स्निपेट में, हम इन कॉम्पोनेंट डेफ़िनिशन फ़ाइलों को उनके यूआरएल के ज़रिए ऐक्सेस कर रहे हैं. साथ ही, इन परिभाषाओं का इस्तेमाल ‘ऑपरेशन’ बनाने के लिए कर रहे हैं जिनका इस्तेमाल हम एक पाइपलाइन चरण बनाने के लिए करेंगे.
import kfp.dsl as dsl
import kfp.gcp as gcp
import kfp.components as comp
...
copydata_op = comp.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/datacopy_component.yaml'
)
train_op = comp.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/train_component.yaml'
)
ट्रेनिंग सेशन के लिए, yml फ़ॉर्मैट में कॉम्पोनेंट की परिभाषाओं में से एक नीचे दी गई है. यह देखा जा सकता है कि इसके इनपुट, आउटपुट, कंटेनर इमेज, और कंटेनर एंट्रीपॉइंट आर्ग तय किए गए हैं.
name: Train T2T model
description: |
A Kubeflow Pipeline component to train a Tensor2Tensor
model
metadata:
labels:
add-pod-env: 'true'
inputs:
- name: train_steps
description: '...'
type: Integer
default: 2019300
- name: data_dir
description: '...'
type: GCSPath
- name: model_dir
description: '...'
type: GCSPath
- name: action
description: '...'
type: String
- name: deploy_webapp
description: '...'
type: String
outputs:
- name: launch_server
description: '...'
type: String
- name: train_output_path
description: '...'
type: GCSPath
- name: MLPipeline UI metadata
type: UI metadata
implementation:
container:
image: gcr.io/google-samples/ml-pipeline-t2ttrain:v3ap
args: [
--data-dir, {inputValue: data_dir},
--action, {inputValue: action},
--model-dir, {inputValue: model_dir},
--train-steps, {inputValue: train_steps},
--deploy-webapp, {inputValue: deploy_webapp},
--train-output-path, {outputPath: train_output_path}
]
env:
KFP_POD_NAME: "{{pod.name}}"
fileOutputs:
launch_server: /tmp/output
MLPipeline UI metadata: /mlpipeline-ui-metadata.json
जैसा कि हम नीचे देख रहे हैं, आपके पास dsl.ContainerOp कंस्ट्रक्टर की मदद से भी पाइपलाइन स्टेप तय करने का विकल्प है.
नीचे पाइपलाइन की परिभाषा के बारे में पूरी जानकारी दी गई है. हम पाइपलाइन इनपुट (और उनकी डिफ़ॉल्ट वैल्यू) तय कर रहे हैं. इसके बाद, हम पाइपलाइन के चरण तय करते हैं. अधिकांश के लिए हम 'ops' का उपयोग कर रहे हैं ऊपर परिभाषित किया गया है, लेकिन हम 'सेवा' को भी परिभाषित कर रहे हैं स्टेप इनलाइन को ContainerOp से सीधे कंटेनर इमेज और एंट्रीपॉइंट आर्ग्युमेंट के बारे में बताया गया है.
देखा जा सकता है कि train, log_model, और serve चरण, पिछले चरण के आउटपुट को इनपुट के तौर पर ऐक्सेस कर रहे हैं. यह कैसे बताया गया है, इस बारे में ज़्यादा जानने के लिए यहां जाएं.
@dsl.pipeline(
name='Github issue summarization',
description='Demonstrate Tensor2Tensor-based training and TF-Serving'
)
def gh_summ( #pylint: disable=unused-argument
train_steps: 'Integer' = 2019300,
project: str = 'YOUR_PROJECT_HERE',
github_token: str = 'YOUR_GITHUB_TOKEN_HERE',
working_dir: 'GCSPath' = 'gs://YOUR_GCS_DIR_HERE',
checkpoint_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/model_output_tbase.bak2019000/',
deploy_webapp: str = 'true',
data_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/t2t_data_gh_all/'
):
copydata = copydata_op(
data_dir=data_dir,
checkpoint_dir=checkpoint_dir,
model_dir='%s/%s/model_output' % (working_dir, dsl.RUN_ID_PLACEHOLDER),
action=COPY_ACTION,
)
train = train_op(
data_dir=data_dir,
model_dir=copydata.outputs['copy_output_path'],
action=TRAIN_ACTION, train_steps=train_steps,
deploy_webapp=deploy_webapp
)
serve = dsl.ContainerOp(
name='serve',
image='gcr.io/google-samples/ml-pipeline-kubeflow-tfserve:v6',
arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
"--model_path", train.outputs['train_output_path']
]
)
train.set_gpu_limit(1)
ध्यान दें कि हमें 'ट्रेन' चरण को क्लस्टर में उस नोड पर चलाने के लिए सेट करें जिसमें कम से कम 1 जीपीयू मौजूद हो.
train.set_gpu_limit(1)
इस पाइपलाइन का आखिरी चरण शर्तों के हिसाब से है. इसे इनलाइन भी तय किया गया है. यह 'serve' के बाद चलेगा चरण पूरा हो जाता है, लेकिन ट्रेनिंग चरण launch_server का आउटपुट स्ट्रिंग 'सही' होने पर ही मिलती है. इस मॉडल ने 'पूर्वानुमान वाला वेब ऐप्लिकेशन' लॉन्च किया. इसका इस्तेमाल हमने ट्रेनिंग वाले T2T मॉडल से, समस्या के बारे में जानकारी पाने का अनुरोध करने के लिए किया.
with dsl.Condition(train.outputs['launch_server'] == 'true'):
webapp = dsl.ContainerOp(
name='webapp',
image='gcr.io/google-samples/ml-pipeline-webapp-launcher:v1',
arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
"--github_token", github_token]
)
webapp.after(serve)
कॉम्पोनेंट कंटेनर इमेज की परिभाषाएं
Kubeflow Pipeline के दस्तावेज़ में, कॉम्पोनेंट बनाने के कुछ सबसे सही तरीके बताए गए हैं. इस प्रोसेस के तहत, आपको कंटेनर की इमेज तय करनी होगी और उसे बनाना होगा. इस कोडलैब की पाइपलाइन के लिए, कॉम्पोनेंट के चरण यहां देखे जा सकते हैं. Dockerfile की परिभाषाएं, containers सबडायरेक्ट्री में होती हैं, उदाहरण के लिए, यहां क्लिक करें.
ट्रेनिंग के लिए, जीपीयू के साथ रोके जा सकने वाले वीएम इस्तेमाल करना
रोके जा सकने वाले वीएम, Compute Engine VM के ऐसे इंस्टेंस होते हैं जो ज़्यादा से ज़्यादा 24 घंटे चलते हैं और इनके उपलब्ध होने की कोई गारंटी नहीं होती. रोके जा सकने वाले वीएम की कीमत, स्टैंडर्ड Compute Engine वीएम से कम होती है.
Google Kubernetes Engine (GKE) की मदद से, ऐसा क्लस्टर या नोड पूल सेट अप करना आसान होता है जो पहले से तय की जा सकने वाली वीएम का इस्तेमाल करता है. ऐसे नोड पूल को सेट अप किया जा सकता है, जिसमें जीपीयू को रोके जा सकने वाले इंस्टेंस से अटैच किया गया हो. ये सामान्य जीपीयू की सुविधा वाले नोड की तरह ही काम करते हैं, लेकिन जीपीयू सिर्फ़ इंस्टेंस की पूरी अवधि तक बने रहते हैं.
अपने क्लस्टर के लिए, पहले से तय किया जा सकने वाला नोड पूल सेट अप किया जा सकता है. इसके लिए, नीचे दिए गए कमांड जैसा निर्देश दें. नीचे दिए गए कमांड को अपने क्लस्टर के नाम और ज़ोन के साथ बदलें और अपनी ज़रूरत के हिसाब से एक्सीलेरेटर टाइप और संख्या में बदलाव करें. वैकल्पिक तौर पर, मौजूदा वर्कलोड के आधार पर नोड पूल को ऑटोस्केल में तय किया जा सकता है.
gcloud container node-pools create preemptible-gpu-pool \
--cluster=<your-cluster-name> \
--zone <your-cluster-zone> \
--enable-autoscaling --max-nodes=4 --min-nodes=0 \
--machine-type n1-highmem-8 \
--preemptible \
--node-taints=preemptible=true:NoSchedule \
--scopes cloud-platform --verbosity error \
--accelerator=type=nvidia-tesla-k80,count=4
Cloud Console के ज़रिए भी नोड पूल सेट अप किया जा सकता है.
Kubeflow पाइपलाइन तय करना, जो पहले से बनाए जा सकने वाले GKE (जीकेई) नोड का इस्तेमाल करती है
अगर GKE (जीकेई) पर Kubeflow चलाया जा रहा है, तो अब Kubeflow Pipelines को परिभाषित करना और चलाना आसान हो गया है. इसमें एक या इससे ज़्यादा पाइपलाइन चरण (कॉम्पोनेंट) पहले से हटाए जा सकने वाले नोड पर चलते हैं, जिससे काम करने में आने वाला खर्च कम हो जाता है. सही नतीजे देने के लिए, कुछ समय के लिए रोके जा सकने वाले वीएम का इस्तेमाल किया जा सकता है. इसके लिए, यह ज़रूरी है कि जिन चरणों को रोका गया है उनके तौर पर आपने पहले ही बता दिया हो. इसका मतलब है कि एक चरण को कई बार चलाने पर एक ही नतीजा मिलेगा. इसके अलावा, यह भी ज़रूरी है कि चेकपॉइंट काम करे, ताकि रुकावट आने पर वह वहीं से शुरू हो सके जहां उसे छोड़ा गया था.
जब आप किसी Kubeflow पाइपलाइन को परिभाषित करते हैं, तो आप यह बता सकते हैं कि दिया गया चरण किसी रोके जा सकने वाले नोड पर चलना चाहिए. इसके लिए ऑप को इस तरह से बदलें:
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
ज़्यादा जानकारी के लिए दस्तावेज़ देखें.
अगर नोड को पहले से ही हटा दिया गया है, तो शायद आप इस चरण को कुछ बार फिर से आज़माना चाहें. ऐसा करने के लिए, यह तरीका अपनाएं: यहां हमने पांच बार कोशिश की है.
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
इस कोडलैब में इस्तेमाल की गई, Kubeflow पाइपलाइन में बदलाव करने की कोशिश करें, ताकि कुछ समय के लिए रोके जा सकने वाले वीएम पर ट्रेनिंग के चरण को पूरा किया जा सके.
अगर आपको ऊपर दिए गए निर्देश के मुताबिक, पहले से तय किया जा सकने वाला नोडपूल बनाना है, तो पाइपलाइन की स्पेसिफ़िकेशन में नीचे दी गई लाइन में बदलाव करें. साथ ही, पांच बार फिर से कोशिश करने की कोशिश करें:
train.set_gpu_limit(1)
इसके बाद, पाइपलाइन को फिर से कंपाइल करें, नया वर्शन अपलोड करें (इसे एक नया नाम दें), और फिर पाइपलाइन का नया वर्शन चलाएं.