Kubeflow पाइपलाइन - GitHub से जुड़ी समस्या की खास जानकारी

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 Shell का ऐक्सेस. यह Google Cloud Platform (GCP) Console में उपलब्ध है

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 (बकेट बनाएं) कमांड का इस्तेमाल करके बकेट बनाएं:

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 का इस्तेमाल किया जा सकता है.

इंस्टॉल पूरा होने के बाद, AI Pipelines डैशबोर्ड में अपने इंस्टॉलेशन के लिए, 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 में नहीं हैं, तो पाइपलाइन पैनल पर जाएं. इसके बाद, अपने इंस्टॉलेशन के लिए "पाइपलाइन डैशबोर्ड खोलें" पर क्लिक करें. इसके बाद, बाईं ओर मौजूद मेन्यू बार में पाइपलाइन पर क्लिक करें. अगर आपको लोड करने से जुड़ी कोई गड़बड़ी मिलती है, तो टैब को रीफ़्रेश करें. आपको इस तरह का एक नया पेज दिखेगा:

पाइपलाइन का ब्यौरा

आपको जिस पाइपलाइन को चलाना है उसमें कई चरण हैं. ज़्यादा जानकारी के लिए, इस कोडलैब का अपेंडिक्स देखें:

मौजूदा मॉडल चेकपॉइंट को आपके बकेट में कॉपी किया जाता है.
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 से फ़ाइल अपलोड करने के लिए, कुछ और चरण पूरे करने होते हैं. इसलिए, हम शॉर्टकट का इस्तेमाल कर रहे हैं).

https://storage.googleapis.com/aju-dev-demos-codelabs/KF/compiled_pipelines/gh_summ_hosted_kfp.py.tar.gz

पाइपलाइन को कोई नाम दें (जैसे, 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 एपीआई चालू करने के लिए कहा जा सकता है. अगर ऐसा है, तो ‘y' जवाब दें.

कुछ मिनटों के बाद, आपका नोटबुक सर्वर चालू हो जाएगा. आपको अपने नोटबुक इंस्टेंस, Cloud Console में दिखेंगे.

कोडलैब नोटबुक अपलोड करना

नोटबुक इंस्टेंस बन जाने के बाद, कोडलैब के Jupyter notebook को अपलोड करने के लिए, इस लिंक पर क्लिक करें. इस्तेमाल करने के लिए नोटबुक इंस्टेंस चुनें. नोटबुक अपने-आप खुल जाएगी.

नोटबुक को एक्ज़ीक्यूट करना

लैब के बाकी बचे हिस्से के लिए, नोटबुक में दिए गए निर्देशों का पालन करें. ध्यान दें कि नोटबुक के "सेटअप" वाले हिस्से में, आपको नोटबुक के बाकी हिस्से को चलाने से पहले अपनी वैल्यू भरनी होंगी.

(अगर आपको अपने प्रोजेक्ट का इस्तेमाल करना है, तो इस लैब के "साफ़-सफ़ाई" सेक्शन को पूरा करना न भूलें).

5. व्यवस्थित करें

अगर आपको कुछ समय के लिए Codalab खाता इस्तेमाल करना है, तो आपको यह कार्रवाई करने की ज़रूरत नहीं है. हालांकि, अगर आपको अपने प्रोजेक्ट का इस्तेमाल करना है, तो Pipelines इंस्टॉलेशन और Notebook को बंद किया जा सकता है.

Pipelines GKE क्लस्टर को बंद करना

Cloud Console से Pipelines क्लस्टर को मिटाया जा सकता है. (अगर आपको GKE क्लस्टर का फिर से इस्तेमाल करना है, तो सिर्फ़ Pipelines इंस्टॉलेशन को मिटाने का विकल्प होता है).

AI Notebook इंस्टेंस मिटाना

अगर आपने कोडलैब का "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' हो. इससे ‘अनुमान लगाने वाला वेब ऐप्लिकेशन' लॉन्च होता है. इसका इस्तेमाल, ट्रेनिंग दिए गए 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 पाइपलाइन को तय करना, जो प्रीएम्प्टिबल 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)

इसके बाद, पाइपलाइन को फिर से कंपाइल करें, नया वर्शन अपलोड करें (इसे नया नाम दें), और फिर पाइपलाइन का नया वर्शन चलाएँ.