1. परिचय
| Kubeflow, Kubernetes के लिए मशीन लर्निंग टूलकिट है. इस प्रोजेक्ट का मकसद, Kubernetes पर मशीन लर्निंग (एमएल) वर्कफ़्लो के डिपार्टमेंट को आसान, पोर्टेबल, और स्केलेबल बनाना है. इसका मकसद, अलग-अलग इन्फ़्रास्ट्रक्चर में एमएल के लिए बेहतरीन ओपन-सोर्स सिस्टम को आसानी से डिप्लॉय करने का तरीका उपलब्ध कराना है. |
| मशीन लर्निंग के वर्कफ़्लो में कई चरण शामिल हो सकते हैं. ये चरण एक-दूसरे पर निर्भर होते हैं. जैसे, डेटा तैयार करना और उसका विश्लेषण करना, ट्रेनिंग देना, आकलन करना, डिप्लॉयमेंट करना वगैरह. इन प्रोसेस को किसी भी समय पर कंपोज़ करना और ट्रैक करना मुश्किल होता है. उदाहरण के लिए, नोटबुक या स्क्रिप्ट के सेट में. साथ ही, ऑडिट और दोहराने जैसी चीज़ें ज़्यादा मुश्किल हो जाती हैं.Kubeflow Pipelines (KFP) इन समस्याओं को हल करने में मदद करता है. इसके लिए, यह मशीन लर्निंग पाइपलाइन को बार-बार इस्तेमाल करने के साथ-साथ मॉनिटर करने, ऑडिट करने, वर्शन ट्रैक करने, और दोहराने का तरीका उपलब्ध कराता है. Cloud AI Pipelines की मदद से, KFP को आसानी से इंस्टॉल किया जा सकता है. |
आपको क्या बनाने को मिलेगा
इस कोडलैब में, आपको एक ऐसा वेब ऐप्लिकेशन बनाने का तरीका बताया जाएगा जो GitHub पर मौजूद समस्याओं की खास जानकारी देता है. इसके लिए, Kubeflow Pipelines का इस्तेमाल करके, मॉडल को ट्रेन किया जाता है और उसे इस्तेमाल के लिए उपलब्ध कराया जाता है. यह Kubeflow Examples repo में दिए गए उदाहरण पर आधारित है. सेटअप पूरा होने के बाद, आपके इन्फ़्रास्ट्रक्चर में ये चीज़ें शामिल होंगी:
- Kubeflow Pipelines इंस्टॉल किया गया Google Kubernetes Engine (GKE) क्लस्टर. इसे 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 Platform (GCP) Console में उपलब्ध Google Cloud Shell का ऐक्सेस
2. सेटअप
Cloud Shell
ब्राउज़र में GCP Console पर जाएं और अपने प्रोजेक्ट के क्रेडेंशियल से लॉग इन करें:
अगर ज़रूरी हो, तो "कोई प्रोजेक्ट चुनें" पर क्लिक करें, ताकि आप अपने कोडलैब प्रोजेक्ट पर काम कर सकें.
इसके बाद, कंसोल में सबसे ऊपर दाईं ओर मौजूद, "Cloud Shell चालू करें" आइकॉन पर क्लिक करके, Cloud Shell शुरू करें.
Cloud Shell शुरू करने पर, आपको उस प्रोजेक्ट का नाम दिखेगा जिसके लिए इसे सेट किया गया है. देखें कि यह सेटिंग सही है या नहीं.
अपना प्रोजेक्ट आईडी ढूंढने के लिए, GCP Console के होम पैनल पर जाएं. अगर स्क्रीन खाली है, तो डैशबोर्ड बनाने के लिए प्रॉम्प्ट में ‘हां' पर क्लिक करें.
इसके बाद, अगर ज़रूरी हो, तो Cloud Shell टर्मिनल में ये कमांड चलाएं, ताकि gcloud को सही प्रोजेक्ट का इस्तेमाल करने के लिए कॉन्फ़िगर किया जा सके:
export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}
स्टोरेज बकेट बनाना
पाइपलाइन फ़ाइलों को सेव करने के लिए, Cloud Storage बकेट बनाएं. आपको एक ऐसा आईडी इस्तेमाल करना होगा जो दुनिया भर में यूनीक हो. इसलिए, बकेट का ऐसा नाम तय करना आसान होता है जिसमें आपका प्रोजेक्ट आईडी शामिल हो. gsutil mb (make bucket) कमांड का इस्तेमाल करके बकेट बनाएं:
export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}
इसके अलावा, GCP Console के ज़रिए भी बकेट बनाई जा सकती है.
ज़रूरी नहीं**: GitHub टोकन बनाएं**
यह कोडलैब, सार्वजनिक तौर पर उपलब्ध डेटा को वापस पाने के लिए GitHub API को कॉल करता है. खास तौर पर उन इवेंट में जहां GitHub API को बड़ी संख्या में नाम छिपाकर अनुरोध भेजे जाते हैं, दर सीमित करने से रोकने के लिए, बिना किसी अनुमति वाला ऐक्सेस टोकन सेट अप करें. इसका मकसद सिर्फ़ आपको एक व्यक्ति के तौर पर अनुमति देना है, न कि किसी अज्ञात उपयोगकर्ता के तौर पर.
- https://github.com/settings/tokens पर जाएं और बिना स्कोप वाला नया टोकन जनरेट करें.
- इसे किसी सुरक्षित जगह पर सेव करें. अगर यह कोड खो जाता है, तो आपको इसे मिटाकर नया कोड बनाना होगा.
इस चरण को छोड़ने पर भी, लैब काम करेगी. हालांकि, मॉडल को टेस्ट करने के लिए इनपुट डेटा जनरेट करने के विकल्प थोड़े सीमित हो जाएंगे.
ज़रूरी नहीं: काम के डैशबोर्ड पिन करना
आसानी से ऐक्सेस करने के लिए, GCP Console में Kubernetes Engine और Storage डैशबोर्ड को पिन करें.
AI Platform Pipelines (होस्ट की गई Kubeflow Pipelines) का इंस्टॉलेशन बनाना
KFP इंस्टॉल किए गए GKE इंस्टेंस को सेट अप करने के लिए, ‘शुरू करने से पहले' और ‘अपना इंस्टेंस सेट अप करें' सेक्शन में दिए गए निर्देशों का पालन करें. ये निर्देश यहां दिए गए हैं. दस्तावेज़ में बताए गए तरीके के मुताबिक, इन 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 को कॉन्फ़िगर करें. इसके लिए, अपने Cloud Shell में यह कमांड चलाएं:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--project ${PROJECT_ID} \
--zone ${ZONE}
इसके अलावा, GKE पेज पर जाने के लिए, एआई पाइपलाइन के डैशबोर्ड में क्लस्टर के नाम पर क्लिक करें. इसके बाद, पेज पर सबसे ऊपर मौजूद "कनेक्ट करें" पर क्लिक करें. पॉप-अप में, Cloud Shell में कमांड चिपकाएं.
इससे आपके kubectl के कॉन्टेक्स्ट को कॉन्फ़िगर किया जाता है, ताकि आप अपने क्लस्टर से इंटरैक्ट कर सकें. कॉन्फ़िगरेशन की पुष्टि करने के लिए, यह कमांड चलाएं:
kubectl get nodes -o wide
आपको "Ready" स्टेटस वाले नोड दिखेंगे. साथ ही, नोड की उम्र, वर्शन, बाहरी आईपी पते, ओएस इमेज, कर्नल वर्शन, और कंटेनर रनटाइम के बारे में अन्य जानकारी दिखेगी.
जीपीयू की सुविधा वाले नोड पूल पर Nvidia ड्राइवर इंस्टॉल करने के लिए, क्लस्टर को कॉन्फ़िगर करना
इसके बाद, हम क्लस्टर पर daemonset लागू करेंगे. इससे, जीपीयू की सुविधा वाले किसी भी क्लस्टर नोड पर 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. पाइपलाइन डैशबोर्ड से पाइपलाइन चलाना
पाइपलाइन का डैशबोर्ड खोलना
अगर आप Cloud Console में नहीं हैं, तो Pipelines पैनल पर जाएं. इसके बाद, अपने इंस्टॉलेशन के लिए "पाइपलाइन डैशबोर्ड खोलें" पर क्लिक करें. इसके बाद, बाईं ओर मौजूद मेन्यू बार में पाइपलाइन पर क्लिक करें. अगर आपको लोड करने में गड़बड़ी का मैसेज मिलता है, तो टैब को रीफ़्रेश करें. आपको इस तरह का एक नया पेज दिखेगा:
पाइपलाइन का ब्यौरा
आपको जिस पाइपलाइन को चलाना है उसमें कई चरण हैं. ज़्यादा जानकारी के लिए, इस कोडलैब का अपेंडिक्स देखें:
- मौजूदा मॉडल चेकपॉइंट को आपके बकेट में कॉपी किया जाता है.
- Tensor2Tensor मॉडल को प्रीप्रोसेस किए गए डेटा का इस्तेमाल करके ट्रेन किया जाता है.
- ट्रेनिंग, पहले चरण में कॉपी किए गए मौजूदा मॉडल के चेकपॉइंट से शुरू होती है. इसके बाद, कुछ और चरणों के लिए ट्रेनिंग दी जाती है. (कोडलैब के दौरान, इसे पूरी तरह से ट्रेन करने में बहुत ज़्यादा समय लगेगा).
- ट्रेनिंग पूरी होने के बाद, पाइपलाइन का यह चरण मॉडल को ऐसे फ़ॉर्मैट में एक्सपोर्ट करता है जिसका इस्तेमाल TensorFlow Serving कर सकता है.
- उस मॉडल का इस्तेमाल करके, TensorFlow-serving इंस्टेंस को डिप्लॉय किया जाता है.
- अनुमान पाने के लिए, वेब ऐप्लिकेशन लॉन्च किया जाता है. इससे, दिखाए गए मॉडल के साथ इंटरैक्ट किया जा सकता है.
पाइपलाइन डाउनलोड और कंपाइल करना
इस सेक्शन में, हम पाइपलाइन की परिभाषा को कंपाइल करने का तरीका जानेंगे. सबसे पहले, हमें 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
working-dir के लिए, बनाए गए GCS बकेट में कोई पाथ डालें. ‘gs://' प्रीफ़िक्स शामिल करें. github-token फ़ील्ड के लिए, वह टोकन डालें जिसे आपने पहले जनरेट किया था. हालांकि, ऐसा करना ज़रूरी नहीं है. अगर आपने कोई टोकन जनरेट नहीं किया है, तो प्लेसहोल्डर स्ट्रिंग को वैसे ही छोड़ दें.
फ़ील्ड भरने के बाद, शुरू करें पर क्लिक करें. इसके बाद, सूची में दिए गए रन पर क्लिक करके उसकी जानकारी देखें. पाइपलाइन का कोई चरण पूरा होने के दौरान, उस पर क्लिक करके उसके बारे में ज़्यादा जानकारी पाई जा सकती है. इसमें उसके पॉड लॉग देखना भी शामिल है. (क्लस्टर नोड बंद होने के बाद भी, पाइपलाइन के किसी चरण के लॉग देखे जा सकते हैं. इसके लिए, Cloud Logging (Stackdriver) के लॉग के लिंक का इस्तेमाल करें).
पाइपलाइन की परिभाषा देखना
पाइपलाइन के चालू होने पर, आपको यह ध्यान से देखना होगा कि इसे कैसे बनाया गया है और यह क्या कर रही है. कोड लैब के अपेंडिक्स सेक्शन में ज़्यादा जानकारी दी गई है.
TensorBoard में मॉडल की ट्रेनिंग से जुड़ी जानकारी देखना
ट्रेनिंग का चरण पूरा होने के बाद, इसके विज़ुअलाइज़ेशन टैब को चुनें. इसके बाद, नीले रंग के TensorBoard शुरू करें बटन पर क्लिक करें. इसके बाद, तैयार हो जाने पर Tensorboard खोलें पर क्लिक करें.
आर्टफ़ैक्ट और एक्ज़ीक्यूशन डैशबोर्ड के बारे में ज़्यादा जानें
Kubeflow Pipelines, पाइपलाइन के चलने के दौरान पाइपलाइन के चरणों के बारे में मेटाडेटा को अपने-आप लॉग करता है. आर्टफ़ैक्ट और एक्ज़ीक्यूशन, दोनों की जानकारी रिकॉर्ड की जाती है. ज़्यादा जानने के लिए, डैशबोर्ड के बाईं ओर मौजूद नेविगेशन बार में मौजूद इन एंट्री पर क्लिक करें.
आर्टफ़ैक्ट के लिए, खास जानकारी देने वाला पैनल और लीनेज एक्सप्लोरर पैनल, दोनों देखे जा सकते हैं.
पाइपलाइन से बनाए गए वेब ऐप्लिकेशन को खोलना और कुछ अनुमान लगाना
पाइपलाइन के आखिरी चरण में, एक वेब ऐप्लिकेशन डिप्लॉय किया जाता है. यह ऐप्लिकेशन, ट्रेन किए गए मॉडल से क्वेरी करने के लिए यूज़र इंटरफ़ेस (यूआई) उपलब्ध कराता है. यह मॉडल, अनुमान लगाने के लिए TF Serving के ज़रिए उपलब्ध कराया जाता है.
पाइपलाइन पूरी होने के बाद, वेब ऐप्लिकेशन से कनेक्ट करने के लिए, उसकी सेवा को पोर्ट-फ़ॉरवर्डिंग करें. हम पोर्ट-फ़ॉरवर्डिंग इसलिए कर रहे हैं, क्योंकि इस कोडलैब के लिए, वेब ऐप्लिकेशन सेवा को बाहरी एंडपॉइंट के तौर पर सेट अप नहीं किया गया है.
Cloud Shell में यह कमांड चलाकर, सेवा का नाम ढूंढें:
kubectl get services
सूची में, इस तरह की सेवा का नाम ढूंढें: ghsumm-*-webappsvc.
इसके बाद, Cloud Shell में उस सेवा पर पोर्ट-फ़ॉरवर्ड करें. इसके लिए, यहां दिया गया तरीका अपनाएं. नीचे दिए गए कमांड में बदलाव करके, webappsvc का नाम इस्तेमाल करें:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
पोर्ट-फ़ॉरवर्डिंग चालू होने के बाद, Cloud Shell पैनल के ऊपर मौजूद ‘झलक' आइकॉन पर क्लिक करें. इसके बाद, ड्रॉपडाउन में "पोर्ट 8080 पर झलक देखें" पर क्लिक करें.
आपको नए टैब में कुछ इस तरह का पेज दिखेगा:
टेक्स्ट का कोई ब्लॉक पाने के लिए, Populate Random Issue बटन पर क्लिक करें. ट्रेन किए गए मॉडल को कॉल करने और अनुमान दिखाने के लिए, टाइटल जनरेट करें पर क्लिक करें.
अगर आपकी पाइपलाइन के पैरामीटर में मान्य GitHub टोकन शामिल है, तो दूसरे फ़ील्ड में GitHub यूआरएल डालकर देखें. इसके बाद, "टाइटल जनरेट करें" पर क्लिक करें. अगर आपने मान्य GitHub टोकन सेट अप नहीं किया है, तो सिर्फ़ "Populate Random Issue" फ़ील्ड का इस्तेमाल करें.
4. AI Platform Notebook से पाइपलाइन चलाना
KFP SDK का इस्तेमाल करके, Jupyter नोटबुक से 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 से नोटबुक इंस्टेंस बनाने के लिए यह कमांड चलाएं:
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 API चालू करने के लिए कहा जा सकता है. अगर ऐसा है, तो ‘y' जवाब दें.
कुछ मिनटों के बाद, आपका नोटबुक सर्वर चालू हो जाएगा. आपको अपने नोटबुक इंस्टेंस, Cloud Console में दिखेंगे.
कोडलैब नोटबुक अपलोड करना
नोटबुक इंस्टेंस बन जाने के बाद, codelab की Jupyter नोटबुक अपलोड करने के लिए, इस लिंक पर क्लिक करें. वह नोटबुक इंस्टेंस चुनें जिसका इस्तेमाल करना है. नोटबुक अपने-आप खुल जाएगी.
नोटबुक को एक्ज़ीक्यूट करना
लैब के बाकी बचे हिस्से के लिए, नोटबुक में दिए गए निर्देशों का पालन करें. ध्यान दें कि नोटबुक के "सेटअप" वाले हिस्से में, आपको नोटबुक के बाकी हिस्से को चलाने से पहले अपनी वैल्यू भरनी होंगी.
(अगर आपको अपने प्रोजेक्ट का इस्तेमाल करना है, तो वापस आकर इस लैब के "स्टोरेज में जगह बनाएं" सेक्शन को पूरा करना न भूलें).
5. व्यवस्थित करें
अगर आपको कुछ समय के लिए दिया गया Codalab खाता इस्तेमाल करना है, तो आपको यह कार्रवाई करने की ज़रूरत नहीं है. हालांकि, अगर आपको अपना प्रोजेक्ट इस्तेमाल करना है, तो Pipelines इंस्टॉलेशन और Notebook को बंद किया जा सकता है.
Pipelines GKE क्लस्टर को बंद करना
Cloud Console से Pipelines क्लस्टर को मिटाया जा सकता है. (अगर आपको GKE क्लस्टर का फिर से इस्तेमाल करना है, तो सिर्फ़ Pipelines इंस्टॉलेशन को मिटाने का विकल्प होता है).
एआई नोटबुक इंस्टेंस मिटाना
अगर आपने कोडलैब का "Notebook" हिस्सा पूरा कर लिया है, तो Cloud Console में जाकर, नोटबुक इंस्टेंस को मिटाया जा सकता है या बंद किया जा सकता है.
ज़रूरी नहीं: GitHub टोकन हटाना
https://github.com/settings/tokens पर जाएं और जनरेट किया गया टोकन हटाएं.
6. अपेंडिक्स
कोड की जानकारी
पाइपलाइन तय करना
इस कोडलैब में इस्तेमाल की गई पाइपलाइन के बारे में यहां बताया गया है.
आइए, देखते हैं कि इसे कैसे तय किया जाता है. साथ ही, इसके कॉम्पोनेंट (चरण) कैसे तय किए जाते हैं. हम कुछ खास बातों के बारे में बताएंगे. हालांकि, ज़्यादा जानकारी के लिए दस्तावेज़ देखें.
Kubeflow Pipeline के चरण, कंटेनर पर आधारित होते हैं. पाइपलाइन बनाते समय, पहले से बनाए गए कॉम्पोनेंट का इस्तेमाल किया जा सकता है. इनमें पहले से बनी कंटेनर इमेज शामिल होती हैं. इसके अलावा, अपने कॉम्पोनेंट भी बनाए जा सकते हैं. इस कोडलैब के लिए, हमने अपना खुद का मॉडल बनाया है.
पाइपलाइन के चार चरणों को फिर से इस्तेमाल किए जा सकने वाले कॉम्पोनेंट से तय किया जाता है. इन्हें कॉम्पोनेंट की परिभाषा वाली फ़ाइलों के ज़रिए ऐक्सेस किया जाता है. इस पहले कोड स्निपेट में, हम यूआरएल के ज़रिए कॉम्पोनेंट डेफ़िनिशन वाली इन फ़ाइलों को ऐक्सेस कर रहे हैं. साथ ही, इन डेफ़िनिशन का इस्तेमाल करके ‘ops' बना रहे हैं. इनका इस्तेमाल हम पाइपलाइन का चरण बनाने के लिए करेंगे.
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'
)
यहां ट्रेनिंग ऑप के लिए, कॉम्पोनेंट की परिभाषा दी गई है. यह परिभाषा YAML फ़ॉर्मैट में है. इसमें देखा जा सकता है कि इसके इनपुट, आउटपुट, कंटेनर इमेज, और कंटेनर एंट्रीपॉइंट आर्ग्युमेंट तय किए गए हैं.
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 के ज़रिए, ‘serve' चरण को भी इनलाइन तरीके से तय कर रहे हैं. इसमें कंटेनर इमेज और एंट्रीपॉइंट आर्ग्युमेंट सीधे तौर पर तय किए जा रहे हैं.
यहां देखा जा सकता है कि 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)
ध्यान दें कि हम ‘ट्रेन' चरण को क्लस्टर के ऐसे नोड पर चलाने के लिए कह रहे हैं जिसमें कम से कम एक जीपीयू उपलब्ध हो.
train.set_gpu_limit(1)
पाइपलाइन का आखिरी चरण, शर्त के हिसाब से होता है. इसे इनलाइन भी तय किया जाता है. यह ‘serve' चरण पूरा होने के बाद ही चलेगा. हालांकि, ऐसा सिर्फ़ तब होगा, जब ट्रेनिंग चरण launch_server का आउटपुट ‘true' स्ट्रिंग हो. इससे ‘prediction वेब ऐप्लिकेशन' लॉन्च होता है. इसका इस्तेमाल, ट्रेनिंग पाए हुए 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 वीएम इंस्टेंस होते हैं. ये ज़्यादा से ज़्यादा 24 घंटे तक चलते हैं. इनके उपलब्ध होने की कोई गारंटी नहीं होती. रोके जा सकने वाले वीएम की कीमत, Compute Engine के स्टैंडर्ड वीएम से कम होती है.
Google Kubernetes Engine (GKE) की मदद से, प्रीएम्प्टिबल वीएम का इस्तेमाल करने वाले क्लस्टर या नोड पूल को आसानी से सेट अप किया जा सकता है. प्रीएम्प्टिबल इंस्टेंस से जुड़े जीपीयू का इस्तेमाल करके, इस तरह का नोड पूल सेट अप किया जा सकता है. ये नोड, GPU की सुविधा वाले सामान्य नोड की तरह ही काम करते हैं. हालांकि, GPU सिर्फ़ इंस्टेंस के चालू रहने तक काम करते हैं.
अपने क्लस्टर के लिए, जीपीयू की सुविधा वाली नोड पूल को सेट अप किया जा सकता है. इसके लिए, यहां दिए गए उदाहरण की तरह कोई कमांड चलाएं. साथ ही, इस कमांड में अपने क्लस्टर का नाम और ज़ोन डालें. इसके अलावा, अपनी ज़रूरतों के हिसाब से ऐक्सेलरेटर का टाइप और संख्या अडजस्ट करें. मौजूदा वर्कलोड के आधार पर, अपने-आप स्केल होने के लिए नोड पूल को वैकल्पिक तौर पर तय किया जा सकता है.
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 Pipeline को तय करना, जो प्रीएम्प्टिबल GKE नोड का इस्तेमाल करता है
अगर GKE पर Kubeflow का इस्तेमाल किया जा रहा है, तो अब Kubeflow Pipelines को तय करना और उन्हें चलाना आसान हो गया है. इनमें एक या उससे ज़्यादा पाइपलाइन चरण (कॉम्पोनेंट) प्रीएम्प्टिबल नोड पर चलते हैं. इससे किसी जॉब को चलाने की लागत कम हो जाती है. सही नतीजे पाने के लिए, प्रीएम्प्टिबल वीएम का इस्तेमाल किया जाना चाहिए. इसके लिए, आपको उन चरणों की पहचान करनी होगी जिन्हें प्रीएम्प्टिबल के तौर पर इस्तेमाल किया जा सकता है. ये चरण या तो आईडंपोटेंट होने चाहिए. इसका मतलब है कि अगर किसी चरण को कई बार चलाया जाता है, तो उसका नतीजा एक जैसा होगा. इसके अलावा, इन चरणों में चेकपॉइंट का इस्तेमाल किया जाना चाहिए, ताकि अगर प्रोसेस में रुकावट आती है, तो चरण वहीं से शुरू हो सके जहां वह रुका था.
Kubeflow Pipeline तय करते समय, यह बताया जा सकता है कि कोई चरण, प्रीएम्प्टिबल नोड पर चलना चाहिए. इसके लिए, इस तरह से ऑप में बदलाव करें:
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)
इसके बाद, पाइपलाइन को फिर से कंपाइल करें, नया वर्शन अपलोड करें (इसे नया नाम दें), और फिर पाइपलाइन का नया वर्शन चलाएँ.