ভার্টেক্স পাইপলাইনের ভূমিকা

১. সংক্ষিপ্ত বিবরণ

এই ল্যাবে আপনারা শিখবেন কীভাবে ভার্টেক্স পাইপলাইন ব্যবহার করে এমএল পাইপলাইন তৈরি ও চালানো যায়।

আপনি যা শিখবেন

আপনি শিখবেন কীভাবে:

• স্কেলেবল এমএল পাইপলাইন তৈরি করতে কুবেফ্লো পাইপলাইনস এসডিকে ব্যবহার করুন
• একটি ৩-ধাপের পরিচিতি পাইপলাইন তৈরি ও চালান যা টেক্সট ইনপুট গ্রহণ করে।
• একটি পাইপলাইন তৈরি ও চালান যা একটি অটোএমএল ক্লাসিফিকেশন মডেলকে প্রশিক্ষণ, মূল্যায়ন এবং স্থাপন করে।
• Vertex AI পরিষেবাগুলির সাথে ইন্টারঅ্যাক্ট করার জন্য google_cloud_pipeline_components লাইব্রেরির মাধ্যমে প্রদত্ত পূর্ব-নির্মিত উপাদানগুলি ব্যবহার করুন।
• ক্লাউড শিডিউলার দিয়ে একটি পাইপলাইন জব শিডিউল করুন

গুগল ক্লাউডে এই ল্যাবটি চালানোর মোট খরচ প্রায় ২৫ ডলার ।

২. ভার্টেক্স এআই-এর পরিচিতি

এই ল্যাবটি গুগল ক্লাউডে উপলব্ধ সর্বাধুনিক এআই প্রোডাক্টটি ব্যবহার করে। ভার্টেক্স এআই গুগল ক্লাউডের এমএল অফারিংগুলোকে একটি নির্বিঘ্ন ডেভেলপমেন্ট অভিজ্ঞতায় একীভূত করে। পূর্বে, অটোএমএল (AutoML) দিয়ে প্রশিক্ষিত মডেল এবং কাস্টম মডেলগুলো আলাদা সার্ভিসের মাধ্যমে অ্যাক্সেস করা যেত। নতুন অফারিংটি অন্যান্য নতুন প্রোডাক্টের সাথে উভয়কে একটি একক এপিআই-তে একত্রিত করেছে। আপনি আপনার বিদ্যমান প্রোজেক্টগুলোও ভার্টেক্স এআই-তে মাইগ্রেট করতে পারেন।

মডেল প্রশিক্ষণ এবং ডেপ্লয়মেন্ট পরিষেবা ছাড়াও, ভার্টেক্স এআই-এর বিভিন্ন ধরনের এমএলওপিএস (MLOps) পণ্য রয়েছে, যার মধ্যে ভার্টেক্স পাইপলাইন (এই ল্যাবের মূল বিষয়), মডেল মনিটরিং, ফিচার স্টোর এবং আরও অনেক কিছু অন্তর্ভুক্ত। নিচের ডায়াগ্রামে আপনি ভার্টেক্স এআই-এর সমস্ত পণ্য দেখতে পারেন।

আপনার কোনো মতামত থাকলে, অনুগ্রহ করে সহায়তা পৃষ্ঠাটি দেখুন।

এমএল পাইপলাইনগুলো কেন দরকারি?

বিস্তারিত আলোচনার আগে, চলুন প্রথমে বুঝে নিই কেন আপনি একটি পাইপলাইন ব্যবহার করতে চাইবেন। কল্পনা করুন, আপনি একটি এমএল (ML) ওয়ার্কফ্লো তৈরি করছেন, যার মধ্যে রয়েছে ডেটা প্রসেসিং, মডেল ট্রেনিং, হাইপারপ্যারামিটার টিউনিং, ইভ্যালুয়েশন এবং মডেল ডেপ্লয়মেন্ট। এই প্রতিটি ধাপের মধ্যে বিভিন্ন নির্ভরশীলতা থাকতে পারে, যা পুরো ওয়ার্কফ্লোটিকে একটি একক সত্তা হিসেবে বিবেচনা করলে নিয়ন্ত্রণ করা কঠিন হয়ে উঠতে পারে। যখন আপনি আপনার এমএল প্রসেসকে বড় পরিসরে নিয়ে যেতে শুরু করবেন, তখন আপনি আপনার টিমের অন্যদের সাথে আপনার এমএল ওয়ার্কফ্লো শেয়ার করতে চাইতে পারেন, যাতে তারা এটি চালাতে পারে এবং কোড দিয়ে অবদান রাখতে পারে। একটি নির্ভরযোগ্য ও পুনরাবৃত্তিযোগ্য প্রসেস ছাড়া এটি কঠিন হয়ে উঠতে পারে। পাইপলাইনের মাধ্যমে, আপনার এমএল প্রসেসের প্রতিটি ধাপই তার নিজস্ব একটি কন্টেইনার। এটি আপনাকে ধাপগুলো স্বাধীনভাবে তৈরি করতে এবং প্রতিটি ধাপের ইনপুট ও আউটপুটকে একটি পুনরাবৃত্তিযোগ্য উপায়ে ট্র্যাক করতে দেয়। এছাড়াও আপনি আপনার ক্লাউড এনভায়রনমেন্টের অন্যান্য ইভেন্টের উপর ভিত্তি করে আপনার পাইপলাইনের রান শিডিউল বা ট্রিগার করতে পারেন, যেমন নতুন ট্রেনিং ডেটা উপলব্ধ হলে একটি পাইপলাইন রান শুরু করা।

সারসংক্ষেপ হলো : পাইপলাইন আপনাকে আপনার এমএল ওয়ার্কফ্লো স্বয়ংক্রিয় করতে এবং এর পুনরাবৃত্তি করতে সাহায্য করে।

৩. ক্লাউড পরিবেশ সেটআপ

এই কোডল্যাবটি চালানোর জন্য আপনার বিলিং চালু করা একটি গুগল ক্লাউড প্ল্যাটফর্ম প্রজেক্ট প্রয়োজন হবে। প্রজেক্ট তৈরি করতে, এখানের নির্দেশাবলী অনুসরণ করুন।

ধাপ ১: ক্লাউড শেল চালু করুন

এই ল্যাবে আপনি একটি ক্লাউড শেল সেশনে কাজ করবেন, যা গুগলের ক্লাউডে চলমান একটি ভার্চুয়াল মেশিনে হোস্ট করা একটি কমান্ড ইন্টারপ্রেটার। আপনি চাইলে এই অংশটি আপনার নিজের কম্পিউটারেও চালাতে পারতেন, কিন্তু ক্লাউড শেল ব্যবহার করলে প্রত্যেকেই একটি সামঞ্জস্যপূর্ণ পরিবেশে পুনরায় করার মতো অভিজ্ঞতা লাভ করতে পারে। ল্যাবের পরে, আপনি আপনার নিজের কম্পিউটারে এই অংশটি আবার চেষ্টা করতে পারেন।

ক্লাউড শেলে প্রথমবার অনুমোদনের প্রয়োজন এমন কোনো অনুরোধ করার সময়, আপনি নীচে দেখানোটির মতো একটি "Authorize Cloud Shell" ডায়ালগ দেখতে পাবেন, যেখানে আপনি নিরাপদে "Authorize" বোতামটি ক্লিক করতে পারেন।

ক্লাউড শেল সক্রিয় করুন

ক্লাউড কনসোলের উপরের ডান দিক থেকে, ক্লাউড শেল সক্রিয় করতে নিচের বোতামটিতে ক্লিক করুন:

আপনি যদি আগে কখনো ক্লাউড শেল চালু না করে থাকেন, তাহলে এটি কী তা বর্ণনা করে একটি মধ্যবর্তী স্ক্রিন (নিচে দেওয়া আছে) আপনার সামনে আসবে। যদি তাই হয়, তাহলে 'Continue'-তে ক্লিক করুন (এবং আপনি এটি আর কখনো দেখতে পাবেন না)। একবারের জন্য আসা সেই স্ক্রিনটি দেখতে এইরকম:

ক্লাউড শেল প্রস্তুত করতে এবং এর সাথে সংযোগ স্থাপন করতে মাত্র কয়েক মুহূর্ত সময় লাগা উচিত।

এই ভার্চুয়াল মেশিনটিতে আপনার প্রয়োজনীয় সমস্ত ডেভেলপমেন্ট টুলস লোড করা আছে। এটি একটি স্থায়ী ৫ জিবি হোম ডিরেক্টরি প্রদান করে এবং গুগল ক্লাউডে চলে, যা নেটওয়ার্ক পারফরম্যান্স ও অথেনটিকেশনকে ব্যাপকভাবে উন্নত করে। এই কোডল্যাবে আপনার প্রায় সমস্ত কাজই শুধুমাত্র একটি ব্রাউজার বা আপনার ক্রোমবুক দিয়ে করা সম্ভব।

ক্লাউড শেলে সংযুক্ত হওয়ার পর আপনি দেখতে পাবেন যে, আপনাকে ইতিমধ্যেই প্রমাণীকৃত করা হয়েছে এবং প্রজেক্টটি আপনার প্রজেক্ট আইডিতে সেট করা আছে।

আপনি প্রমাণীকৃত কিনা তা নিশ্চিত করতে ক্লাউড শেলে নিম্নলিখিত কমান্ডটি চালান:

gcloud auth list

কমান্ড আউটপুটে আপনি এইরকম কিছু দেখতে পাবেন:

দ্রষ্টব্য: gcloud কমান্ড-লাইন টুল হলো গুগল ক্লাউডের শক্তিশালী এবং সমন্বিত কমান্ড-লাইন টুল। এটি ক্লাউড শেলে আগে থেকেই ইনস্টল করা থাকে। আপনি এতে ট্যাব কমপ্লিশনের সুবিধা লক্ষ্য করবেন। আরও তথ্যের জন্য, gcloud কমান্ড-লাইন টুলের ওভারভিউ দেখুন।

gcloud কমান্ডটি আপনার প্রজেক্ট সম্পর্কে জানে কিনা তা নিশ্চিত করতে ক্লাউড শেলে নিম্নলিখিত কমান্ডটি চালান:

gcloud config list project

কমান্ড আউটপুট

[core]
project = <PROJECT_ID>

যদি তা না থাকে, তবে আপনি এই কমান্ডটি দিয়ে এটি সেট করতে পারেন:

gcloud config set project <PROJECT_ID>

কমান্ড আউটপুট

Updated property [core/project].

ক্লাউড শেলে কয়েকটি এনভায়রনমেন্ট ভেরিয়েবল আছে, যার মধ্যে GOOGLE_CLOUD_PROJECT অন্যতম, যেটিতে আমাদের বর্তমান ক্লাউড প্রজেক্টের নামটি রয়েছে। এই ল্যাব জুড়ে আমরা বিভিন্ন জায়গায় এটি ব্যবহার করব। নিম্নলিখিত কমান্ডটি চালিয়ে আপনি এটি দেখতে পারেন:

echo $GOOGLE_CLOUD_PROJECT

ধাপ ২: এপিআই সক্রিয় করুন

পরবর্তী ধাপগুলোতে আপনি দেখতে পাবেন এই সার্ভিসগুলো কোথায় (এবং কেন) প্রয়োজন, কিন্তু আপাতত, আপনার প্রোজেক্টকে Compute Engine, Container Registry, এবং Vertex AI সার্ভিসগুলোতে অ্যাক্সেস দেওয়ার জন্য এই কমান্ডটি চালান:

gcloud services enable compute.googleapis.com         \
                       containerregistry.googleapis.com  \
                       aiplatform.googleapis.com  \
                       cloudbuild.googleapis.com \
                       cloudfunctions.googleapis.com

এর ফলে এইটির মতো একটি সফল বার্তা তৈরি হওয়া উচিত:

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

ধাপ ৩: একটি ক্লাউড স্টোরেজ বাকেট তৈরি করুন

Vertex AI-তে একটি ট্রেনিং জব চালানোর জন্য, আমাদের সংরক্ষিত মডেল অ্যাসেটগুলো রাখার জন্য একটি স্টোরেজ বাকেট প্রয়োজন হবে। বাকেটটি আঞ্চলিক হতে হবে। আমরা এখানে us-central ব্যবহার করছি, কিন্তু আপনি অন্য কোনো অঞ্চলও ব্যবহার করতে পারেন (শুধু এই ল্যাব জুড়ে সেটি পরিবর্তন করে দেবেন)। আপনার যদি আগে থেকেই একটি বাকেট থাকে, তাহলে আপনি এই ধাপটি বাদ দিতে পারেন।

একটি বাকেট তৈরি করতে আপনার ক্লাউড শেল টার্মিনালে নিম্নলিখিত কমান্ডগুলি চালান:

BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME

এরপর আমরা আমাদের কম্পিউট সার্ভিস অ্যাকাউন্টকে এই বাকেটটিতে অ্যাক্সেস দেব। এর মাধ্যমে নিশ্চিত হবে যে, এই বাকেটটিতে ফাইল লেখার জন্য ভার্টেক্স পাইপলাইনস-এর প্রয়োজনীয় অনুমতি রয়েছে। এই অনুমতিটি যোগ করতে নিম্নলিখিত কমান্ডটি চালান:

gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}[e-mail]"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin

ধাপ ৪: একটি Vertex AI Workbench ইনস্ট্যান্স তৈরি করুন

আপনার ক্লাউড কনসোলের Vertex AI সেকশন থেকে Workbench-এ ক্লিক করুন:

সেখান থেকে, ব্যবহারকারী-পরিচালিত নোটবুকগুলোর মধ্যে, নতুন নোটবুক-এ ক্লিক করুন:

তারপর GPU ছাড়া TensorFlow Enterprise 2.3 (LTS সহ) ইনস্ট্যান্স টাইপটি নির্বাচন করুন:

ডিফল্ট অপশনগুলো ব্যবহার করুন এবং তারপর তৈরি করুন-এ ক্লিক করুন।

ধাপ ৫: আপনার নোটবুকটি খুলুন।

ইনস্ট্যান্সটি তৈরি হয়ে গেলে, Open JupyterLab নির্বাচন করুন:

৪. ভার্টেক্স পাইপলাইন সেটআপ

ভার্টেক্স পাইপলাইন ব্যবহার করার জন্য আমাদের আরও কয়েকটি লাইব্রেরি ইনস্টল করতে হবে:

• কুবেফ্লো পাইপলাইনস : এটি সেই এসডিকে যা আমরা আমাদের পাইপলাইন তৈরি করতে ব্যবহার করব। ভার্টেক্স পাইপলাইনস কুবেফ্লো পাইপলাইনস বা টিএফএক্স উভয় দিয়েই তৈরি পাইপলাইন চালানো সমর্থন করে।
• গুগল ক্লাউড পাইপলাইন কম্পোনেন্টস : এই লাইব্রেরিটি আগে থেকে তৈরি কম্পোনেন্ট সরবরাহ করে, যা আপনার পাইপলাইন ধাপগুলো থেকে ভার্টেক্স এআই পরিষেবাগুলোর সাথে যোগাযোগ করা সহজ করে তোলে।

ধাপ ১: পাইথন নোটবুক তৈরি করুন এবং লাইব্রেরিগুলো ইনস্টল করুন।

প্রথমে, আপনার নোটবুক ইনস্ট্যান্সের লঞ্চার মেনু থেকে পাইথন ৩ নির্বাচন করে একটি নোটবুক তৈরি করুন:

আপনার নোটবুক ইনস্ট্যান্সের উপরের বাম দিকে থাকা + চিহ্নে ক্লিক করে আপনি লঞ্চার মেনুতে প্রবেশ করতে পারেন।

এই ল্যাবে আমরা যে দুটি সার্ভিস ব্যবহার করব তা ইনস্টল করার জন্য, প্রথমে একটি নোটবুক সেলে ইউজার ফ্ল্যাগটি সেট করুন:

USER_FLAG = "--user"

তারপর আপনার নোটবুক থেকে নিম্নলিখিতটি চালান:

!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0

এই প্যাকেজগুলো ইনস্টল করার পর আপনাকে কার্নেলটি পুনরায় চালু করতে হবে:

import os

if not os.getenv("IS_TESTING"):
    # Automatically restart kernel after installs
    import IPython

    app = IPython.Application.instance()
    app.kernel.do_shutdown(True)

অবশেষে, প্যাকেজগুলো সঠিকভাবে ইনস্টল করেছেন কিনা তা যাচাই করুন। KFP SDK ভার্সনটি অবশ্যই >=1.8 হতে হবে:

!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"

ধাপ ২: আপনার প্রজেক্ট আইডি এবং বাকেট সেট করুন।

এই ল্যাব জুড়ে আপনি আপনার ক্লাউড প্রজেক্ট আইডি এবং পূর্বে তৈরি করা বাকেটটি ব্যবহার করবেন। এরপর আমরা সেগুলোর প্রত্যেকটির জন্য ভ্যারিয়েবল তৈরি করব।

আপনি যদি আপনার প্রজেক্ট আইডি না জানেন, তাহলে নিম্নলিখিত কমান্ডটি চালিয়ে তা পেতে পারেন:

import os
PROJECT_ID = ""

# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
    shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
    PROJECT_ID = shell_output[0]
    print("Project ID: ", PROJECT_ID)

অন্যথায়, এটি এখানে সেট করুন:

if PROJECT_ID == "" or PROJECT_ID is None:
    PROJECT_ID = "your-project-id"  # @param {type:"string"}

এরপর আপনার বাকেটের নাম সংরক্ষণের জন্য একটি ভ্যারিয়েবল তৈরি করুন। যদি আপনি এই ল্যাবে এটি তৈরি করে থাকেন, তাহলে নিম্নলিখিতটি কাজ করবে। অন্যথায়, আপনাকে এটি ম্যানুয়ালি সেট করতে হবে:

BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"

ধাপ ৩: লাইব্রেরিগুলো ইম্পোর্ট করুন

এই কোডল্যাব জুড়ে আমরা যে লাইব্রেরিগুলো ব্যবহার করব, সেগুলো ইম্পোর্ট করতে নিম্নলিখিতগুলো যোগ করুন:

import kfp

from kfp.v2 import compiler, dsl
from kfp.v2.dsl import component, pipeline, Artifact, ClassificationMetrics, Input, Output, Model, Metrics

from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
from typing import NamedTuple

ধাপ ৪: ধ্রুবকগুলো সংজ্ঞায়িত করুন

আমাদের পাইপলাইন তৈরি করার আগে শেষ যে কাজটি করতে হবে তা হলো কিছু ধ্রুবক ভেরিয়েবল নির্ধারণ করা। PIPELINE_ROOT হলো ক্লাউড স্টোরেজের সেই পাথ, যেখানে আমাদের পাইপলাইন দ্বারা তৈরি আর্টিফ্যাক্টগুলো লেখা হবে। আমরা এখানে অঞ্চল হিসেবে us-central1 ব্যবহার করছি, কিন্তু আপনি যদি আপনার বাকেট তৈরি করার সময় অন্য কোনো অঞ্চল ব্যবহার করে থাকেন, তাহলে নিচের কোডে REGION ভেরিয়েবলটি আপডেট করুন:

PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"

PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT

উপরের কোডটি চালানোর পর, আপনার পাইপলাইনের রুট ডিরেক্টরিটি প্রিন্ট হতে দেখবেন। এটি হলো ক্লাউড স্টোরেজের সেই অবস্থান যেখানে আপনার পাইপলাইনের আর্টিফ্যাক্টগুলো লেখা হবে। এটি gs://YOUR-BUCKET-NAME/pipeline_root/ ফরম্যাটে থাকবে।

৫. আপনার প্রথম পাইপলাইন তৈরি করা

ভার্টেক্স পাইপলাইন কীভাবে কাজ করে সে সম্পর্কে পরিচিত হওয়ার জন্য, আমরা প্রথমে KFP SDK ব্যবহার করে একটি ছোট পাইপলাইন তৈরি করব। এই পাইপলাইনটি মেশিন লার্নিং (ML) সম্পর্কিত কোনো কাজ করে না (চিন্তা করবেন না, আমরা সেদিকেও যাবো!), আমরা এটি ব্যবহার করছি আপনাকে শেখানোর জন্য:

• KFP SDK-তে কীভাবে কাস্টম কম্পোনেন্ট তৈরি করবেন
• ভার্টেক্স পাইপলাইনে কীভাবে একটি পাইপলাইন চালানো এবং মনিটর করা যায়

আমরা এমন একটি পাইপলাইন তৈরি করব যা দুটি আউটপুট ব্যবহার করে একটি বাক্য প্রিন্ট করবে: একটি পণ্যের নাম এবং একটি ইমোজি বিবরণ। এই পাইপলাইনটি তিনটি উপাদান নিয়ে গঠিত হবে:

• product_name : এই কম্পোনেন্টটি ইনপুট হিসেবে একটি পণ্যের নাম (অথবা আপনার ইচ্ছামতো যেকোনো বিশেষ্য) নেবে এবং আউটপুট হিসেবে সেই স্ট্রিংটি ফেরত দেবে।
• emoji : এই কম্পোনেন্টটি একটি ইমোজির টেক্সট বিবরণ নিয়ে সেটিকে একটি ইমোজিতে রূপান্তর করবে। উদাহরণস্বরূপ, ✨ এর টেক্সট কোড হলো "sparkles"। এই কম্পোনেন্টটি একটি ইমোজি লাইব্রেরি ব্যবহার করে আপনাকে দেখায় যে কীভাবে আপনার পাইপলাইনে এক্সটার্নাল ডিপেন্ডেন্সিগুলো পরিচালনা করতে হয়।
• build_sentence : এই শেষ অংশটি আগের দুটির আউটপুট ব্যবহার করে ইমোজি দিয়ে একটি বাক্য তৈরি করবে। উদাহরণস্বরূপ, এর ফলে যে আউটপুটটি আসবে তা হলো "Vertex Pipelines is ✨"।

চলুন কোডিং শুরু করা যাক!

ধাপ ১: একটি পাইথন ফাংশন ভিত্তিক কম্পোনেন্ট তৈরি করুন

KFP SDK ব্যবহার করে, আমরা পাইথন ফাংশনের উপর ভিত্তি করে কম্পোনেন্ট তৈরি করতে পারি। আমাদের প্রথম পাইপলাইনের ৩টি কম্পোনেন্টের জন্য আমরা এটি ব্যবহার করব। আমরা প্রথমে product_name কম্পোনেন্টটি তৈরি করব, যা ইনপুট হিসেবে কেবল একটি স্ট্রিং নেয় এবং সেই স্ট্রিংটিই রিটার্ন করে। আপনার নোটবুকে নিম্নলিখিত কোডটি যোগ করুন:

@component(base_image="python:3.9", output_component_file="first-component.yaml")
def product_name(text: str) -> str:
    return text

চলুন এখানকার সিনট্যাক্সটি আরও ভালোভাবে দেখে নেওয়া যাক:

• @component ডেকোরেটরটি পাইপলাইন রান করার সময় এই ফাংশনটিকে একটি কম্পোনেন্টে কম্পাইল করে। আপনি যখনই কোনো কাস্টম কম্পোনেন্ট লিখবেন, তখনই এটি ব্যবহার করবেন।
• base_image প্যারামিটারটি নির্দিষ্ট করে যে এই কম্পোনেন্টটি কোন কন্টেইনার ইমেজ ব্যবহার করবে।
• output_component_file প্যারামিটারটি ঐচ্ছিক, এবং এটি সেই yaml ফাইলটি নির্দিষ্ট করে যেখানে কম্পাইল করা কম্পোনেন্টটি লেখা হবে। সেলটি রান করার পর আপনি আপনার নোটবুক ইনস্ট্যান্সে ফাইলটি লেখা দেখতে পাবেন। আপনি যদি এই কম্পোনেন্টটি কারও সাথে শেয়ার করতে চান, তাহলে আপনি তাদের তৈরি করা yaml ফাইলটি পাঠাতে পারেন এবং নিম্নলিখিত কমান্ড ব্যবহার করে তাদের এটি লোড করতে বলতে পারেন:

product_name_component = kfp.components.load_component_from_file('./first-component.yaml')

• ফাংশন সংজ্ঞার পরে -> str এই কম্পোনেন্টের আউটপুট টাইপ নির্দিষ্ট করে।

ধাপ ২: আরও দুটি উপাদান তৈরি করুন

আমাদের পাইপলাইনটি সম্পূর্ণ করতে, আমরা আরও দুটি কম্পোনেন্ট তৈরি করব। প্রথমটি আমরা এমনভাবে সংজ্ঞায়িত করব যা ইনপুট হিসাবে একটি স্ট্রিং গ্রহণ করে এবং যদি সংশ্লিষ্ট ইমোজি থাকে, তবে সেই স্ট্রিংটিকে তাতে রূপান্তর করে। এটি প্রদত্ত ইনপুট টেক্সট এবং ফলাফলস্বরূপ প্রাপ্ত ইমোজি সহ একটি টাপল রিটার্ন করে।

@component(packages_to_install=["emoji"])
def emoji(
    text: str,
) -> NamedTuple(
    "Outputs",
    [
        ("emoji_text", str),  # Return parameters
        ("emoji", str),
    ],
):
    import emoji

    emoji_text = text
    emoji_str = emoji.emojize(':' + emoji_text + ':', language='alias')
    print("output one: {}; output_two: {}".format(emoji_text, emoji_str))
    return (emoji_text, emoji_str)

এই কম্পোনেন্টটি আমাদের আগেরটির চেয়ে কিছুটা বেশি জটিল। চলুন, নতুন কী কী আছে তা বিস্তারিতভাবে আলোচনা করা যাক:

• packages_to_install প্যারামিটারটি কম্পোনেন্টকে এই কন্টেইনারের জন্য প্রয়োজনীয় যেকোনো বাহ্যিক লাইব্রেরি নির্ভরতা সম্পর্কে জানিয়ে দেয়। এক্ষেত্রে, আমরা `emoji` নামের একটি লাইব্রেরি ব্যবহার করছি।
• এই কম্পোনেন্টটি Outputs নামের একটি NamedTuple রিটার্ন করে। লক্ষ্য করুন যে, এই টাপলের প্রতিটি স্ট্রিং-এর emoji_text এবং emoji নামে দুটি কী (key) আছে। আমরা আমাদের পরবর্তী কম্পোনেন্টে আউটপুট অ্যাক্সেস করার জন্য এগুলো ব্যবহার করব।

এই পাইপলাইনের শেষ অংশটি প্রথম দুটির আউটপুট গ্রহণ করে সেগুলোকে একত্রিত করে একটি স্ট্রিং ফেরত দেবে:

@component
def build_sentence(
    product: str,
    emoji: str,
    emojitext: str
) -> str:
    print("We completed the pipeline, hooray!")
    end_str = product + " is "
    if len(emoji) > 0:
        end_str += emoji
    else:
        end_str += emojitext
    return(end_str)

আপনি হয়তো ভাবছেন: আপনার সংজ্ঞায়িত করা পূর্ববর্তী ধাপগুলোর আউটপুট ব্যবহার করতে এই কম্পোনেন্টটি কীভাবে জানে? চমৎকার প্রশ্ন! আমরা পরবর্তী ধাপে এই সবকিছুকে একসাথে যুক্ত করব।

ধাপ ৩: উপাদানগুলোকে একত্রিত করে একটি পাইপলাইন তৈরি করা

আমরা উপরে যে কম্পোনেন্ট ডেফিনিশনগুলো নির্ধারণ করেছি, সেগুলো ফ্যাক্টরি ফাংশন তৈরি করে যা একটি পাইপলাইন ডেফিনিশনে স্টেপ তৈরি করতে ব্যবহার করা যেতে পারে। একটি পাইপলাইন সেট আপ করতে, @pipeline ডেকোরেটরটি ব্যবহার করুন, পাইপলাইনটির একটি নাম ও বিবরণ দিন এবং রুট পাথটি প্রদান করুন যেখানে আপনার পাইপলাইনের আর্টিফ্যাক্টগুলো লেখা হবে। আর্টিফ্যাক্ট বলতে আমরা আপনার পাইপলাইন দ্বারা তৈরি যেকোনো আউটপুট ফাইলকে বোঝাই। এই ইন্ট্রো পাইপলাইনটি কোনো ফাইল তৈরি করে না, কিন্তু আমাদের পরবর্তী পাইপলাইনটি করবে।

পরবর্তী কোড ব্লকে আমরা একটি intro_pipeline ফাংশন সংজ্ঞায়িত করি। এখানেই আমরা আমাদের প্রাথমিক পাইপলাইন ধাপগুলোর ইনপুট এবং ধাপগুলো একে অপরের সাথে কীভাবে সংযুক্ত হবে তা নির্দিষ্ট করি:

• product_task ইনপুট হিসেবে একটি পণ্যের নাম গ্রহণ করে। এখানে আমরা 'Vertex Pipelines' পাস করছি, কিন্তু আপনি এটি আপনার পছন্দমতো পরিবর্তন করতে পারেন।
• emoji_task ইনপুট হিসেবে একটি ইমোজির টেক্সট কোড গ্রহণ করে। আপনি চাইলে এটি আপনার পছন্দমতো যেকোনো কিছুতে পরিবর্তন করতে পারেন। উদাহরণস্বরূপ, "party_face" বলতে 🥳 ইমোজিকে বোঝায়। উল্লেখ্য যে, যেহেতু এই কম্পোনেন্ট এবং product_task উভয়েরই এমন কোনো ধাপ নেই যা এদের মধ্যে ইনপুট পাঠায়, তাই আমরা যখন আমাদের পাইপলাইন সংজ্ঞায়িত করি, তখন এগুলোর জন্য ইনপুট ম্যানুয়ালি নির্দিষ্ট করে দিই।
• আমাদের পাইপলাইনের শেষ ধাপ – consumer_task তিনটি ইনপুট প্যারামিটার রয়েছে:
  • product_task এর আউটপুট। যেহেতু এই ধাপে কেবল একটিই আউটপুট তৈরি হয়, তাই আমরা product_task.output এর মাধ্যমে এটিকে উল্লেখ করতে পারি।
  • আমাদের emoji_task ধাপের emoji আউটপুট। উপরে সংজ্ঞায়িত emoji কম্পোনেন্টটি দেখুন, যেখানে আমরা আউটপুট প্যারামিটারগুলোর নাম দিয়েছি।
  • একইভাবে, emoji কম্পোনেন্ট থেকে emoji_text নামের আউটপুট পাওয়া যায়। যদি আমাদের পাইপলাইনে এমন কোনো টেক্সট পাঠানো হয় যা কোনো ইমোজির সাথে মেলে না, তবে এটি সেই টেক্সট ব্যবহার করে একটি বাক্য তৈরি করবে।

@pipeline(
    name="hello-world",
    description="An intro pipeline",
    pipeline_root=PIPELINE_ROOT,
)

# You can change the `text` and `emoji_str` parameters here to update the pipeline output
def intro_pipeline(text: str = "Vertex Pipelines", emoji_str: str = "sparkles"):
    product_task = product_name(text)
    emoji_task = emoji(emoji_str)
    consumer_task = build_sentence(
        product_task.output,
        emoji_task.outputs["emoji"],
        emoji_task.outputs["emoji_text"],
    )

ধাপ ৪: পাইপলাইনটি কম্পাইল ও রান করুন।

আপনার পাইপলাইন সংজ্ঞায়িত হয়ে গেলে, আপনি এটি কম্পাইল করার জন্য প্রস্তুত। নিম্নলিখিতটি একটি JSON ফাইল তৈরি করবে যা আপনি পাইপলাইনটি চালানোর জন্য ব্যবহার করবেন:

compiler.Compiler().compile(
    pipeline_func=intro_pipeline, package_path="intro_pipeline_job.json"
)

এরপর, একটি TIMESTAMP ভেরিয়েবল তৈরি করুন। আমরা এটি আমাদের জব আইডিতে ব্যবহার করব:

from datetime import datetime

TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")

এরপর আপনার পাইপলাইন জবটি সংজ্ঞায়িত করুন:

job = aiplatform.PipelineJob(
    display_name="hello-world-pipeline",
    template_path="intro_pipeline_job.json",
    job_id="hello-world-pipeline-{0}".format(TIMESTAMP),
    enable_caching=True
)

অবশেষে, একটি নতুন পাইপলাইন এক্সিকিউশন তৈরি করতে জবটি চালান:

job.submit()

এই সেলটি চালানোর পর, আপনি আপনার কনসোলে পাইপলাইন রানটি দেখার জন্য একটি লিঙ্কসহ লগ দেখতে পাবেন:

ওই লিঙ্কে যান। সম্পূর্ণ হলে আপনার পাইপলাইনটি দেখতে এইরকম হবে:

এই পাইপলাইনটি চলতে ৫-৬ মিনিট সময় নেবে। সম্পূর্ণ হলে, চূড়ান্ত আউটপুট দেখতে আপনি build-sentence কম্পোনেন্টটিতে ক্লিক করতে পারেন:

এখন যেহেতু আপনি KFP SDK এবং Vertex Pipelines কীভাবে কাজ করে সে সম্পর্কে পরিচিত, আপনি অন্যান্য Vertex AI পরিষেবা ব্যবহার করে একটি ML মডেল তৈরি ও স্থাপন করার জন্য একটি পাইপলাইন তৈরি করতে প্রস্তুত। চলুন শুরু করা যাক!

৬. একটি এন্ড-টু-এন্ড এমএল পাইপলাইন তৈরি করা

এখন আপনার প্রথম এমএল পাইপলাইন তৈরি করার সময়। এই পাইপলাইনে, আমরা ইউসিআই মেশিন লার্নিং ড্রাই বিনস ডেটাসেটটি ব্যবহার করব, যা নিম্নোক্ত উৎস থেকে নেওয়া হয়েছে: কোকলু, এম. এবং ওজকান, আইএ, (২০২০), "কম্পিউটার ভিশন এবং মেশিন লার্নিং কৌশল ব্যবহার করে শুকনো মটরশুঁটির বহু-শ্রেণী শ্রেণিবিন্যাস।" কম্পিউটারস অ্যান্ড ইলেকট্রনিকস ইন এগ্রিকালচার, ১৭৪, ১০৫৫০৭। ডিওআই ।

এটি একটি সারণীভিত্তিক ডেটাসেট, এবং আমাদের পাইপলাইনে আমরা এই ডেটাসেটটি ব্যবহার করে একটি অটোএমএল মডেলকে প্রশিক্ষণ, মূল্যায়ন এবং স্থাপন করব, যা শিমের বৈশিষ্ট্যের উপর ভিত্তি করে সেগুলোকে ৭টি প্রকারের মধ্যে যেকোনো একটিতে শ্রেণীবদ্ধ করবে।

এই পাইপলাইনটি করবে:

• এ একটি ডেটাসেট তৈরি করুন
• AutoML ব্যবহার করে একটি টেবুলার ক্লাসিফিকেশন মডেলকে প্রশিক্ষণ দিন
• এই মডেলের মূল্যায়ন মেট্রিক্স পান
• মূল্যায়ন মেট্রিক্সের উপর ভিত্তি করে, ভার্টেক্স পাইপলাইনে কন্ডিশনাল লজিক ব্যবহার করে মডেলটি ডেপ্লয় করা হবে কিনা, সে বিষয়ে সিদ্ধান্ত নিন।
• ভার্টেক্স প্রেডিকশন ব্যবহার করে মডেলটিকে একটি এন্ডপয়েন্টে স্থাপন করুন।

বর্ণিত প্রতিটি ধাপ একটি কম্পোনেন্ট হবে। এই কোডল্যাবে আমরা আগে ইম্পোর্ট করা google_cloud_pipeline_components লাইব্রেরির মাধ্যমে ভার্টেক্স এআই সার্ভিসের জন্য বেশিরভাগ পাইপলাইন ধাপে প্রি-বিল্ট কম্পোনেন্ট ব্যবহার করব। এই অংশে, আমরা প্রথমে একটি কাস্টম কম্পোনেন্ট সংজ্ঞায়িত করব। তারপর, আমরা প্রি-বিল্ট কম্পোনেন্ট ব্যবহার করে বাকি পাইপলাইন ধাপগুলো সংজ্ঞায়িত করব। প্রি-বিল্ট কম্পোনেন্টগুলো মডেল ট্রেনিং এবং ডেপ্লয়মেন্টের মতো ভার্টেক্স এআই সার্ভিসগুলো অ্যাক্সেস করা সহজ করে তোলে।

এই ধাপের বেশিরভাগ সময়ই পাইপলাইনের অটোএমএল (AutoML) প্রশিক্ষণ অংশের জন্য ব্যয় হয়, যাতে প্রায় এক ঘণ্টা সময় লাগবে।

ধাপ ১: মডেল মূল্যায়নের জন্য একটি কাস্টম উপাদান

আমরা যে কাস্টম কম্পোনেন্টটি তৈরি করব, সেটি আমাদের পাইপলাইনের শেষের দিকে মডেল প্রশিক্ষণ সম্পন্ন হওয়ার পর ব্যবহৃত হবে। এই কম্পোনেন্টটি কয়েকটি কাজ করবে:

• প্রশিক্ষিত AutoML ক্লাসিফিকেশন মডেল থেকে মূল্যায়ন মেট্রিকগুলো নিন।
• মেট্রিকগুলো পার্স করুন এবং ভার্টেক্স পাইপলাইন UI-তে সেগুলো রেন্ডার করুন।
• মডেলটি স্থাপন করা উচিত কিনা তা নির্ধারণ করতে মেট্রিকগুলোকে একটি থ্রেশহোল্ডের সাথে তুলনা করুন।

কম্পোনেন্টটি সংজ্ঞায়িত করার আগে, চলুন এর ইনপুট এবং আউটপুট প্যারামিটারগুলো বুঝে নিই। ইনপুট হিসেবে, এই পাইপলাইনটি আমাদের ক্লাউড প্রজেক্টের কিছু মেটাডেটা, প্রশিক্ষিত মডেল (আমরা এই কম্পোনেন্টটি পরে সংজ্ঞায়িত করব), মডেলের ইভ্যালুয়েশন মেট্রিকস এবং একটি thresholds_dict_str গ্রহণ করে। thresholds_dict_str হলো এমন একটি বিষয় যা আমরা আমাদের পাইপলাইন চালানোর সময় সংজ্ঞায়িত করব। এই ক্লাসিফিকেশন মডেলের ক্ষেত্রে, এটি হবে ROC কার্ভের নিচের ক্ষেত্রফলের (area under the ROC curve) মান, যার ভিত্তিতে আমাদের মডেলটি ডেপ্লয় করা উচিত। উদাহরণস্বরূপ, যদি আমরা ০.৯৫ পাস করি, তার মানে হলো আমরা চাই আমাদের পাইপলাইনটি কেবল তখনই মডেলটি ডেপ্লয় করুক যখন এই মেট্রিকটি ৯৫%-এর উপরে থাকবে।

আমাদের ইভ্যালুয়েশন কম্পোনেন্টটি মডেলটি ডেপ্লয় করা হবে কি না, তা নির্দেশ করে একটি স্ট্রিং রিটার্ন করে। এই কাস্টম কম্পোনেন্টটি তৈরি করতে একটি নোটবুক সেলে নিম্নলিখিত কোডটি যোগ করুন:

@component(
    base_image="gcr.io/deeplearning-platform-release/tf2-cpu.2-3:latest",
    output_component_file="tabular_eval_component.yaml",
    packages_to_install=["google-cloud-aiplatform"],
)
def classification_model_eval_metrics(
    project: str,
    location: str,  # "us-central1",
    api_endpoint: str,  # "us-central1-aiplatform.googleapis.com",
    thresholds_dict_str: str,
    model: Input[Artifact],
    metrics: Output[Metrics],
    metricsc: Output[ClassificationMetrics],
) -> NamedTuple("Outputs", [("dep_decision", str)]):  # Return parameter.

    import json
    import logging

    from google.cloud import aiplatform as aip

    # Fetch model eval info
    def get_eval_info(client, model_name):
        from google.protobuf.json_format import MessageToDict

        response = client.list_model_evaluations(parent=model_name)
        metrics_list = []
        metrics_string_list = []
        for evaluation in response:
            print("model_evaluation")
            print(" name:", evaluation.name)
            print(" metrics_schema_uri:", evaluation.metrics_schema_uri)
            metrics = MessageToDict(evaluation._pb.metrics)
            for metric in metrics.keys():
                logging.info("metric: %s, value: %s", metric, metrics[metric])
            metrics_str = json.dumps(metrics)
            metrics_list.append(metrics)
            metrics_string_list.append(metrics_str)

        return (
            evaluation.name,
            metrics_list,
            metrics_string_list,
        )

    # Use the given metrics threshold(s) to determine whether the model is
    # accurate enough to deploy.
    def classification_thresholds_check(metrics_dict, thresholds_dict):
        for k, v in thresholds_dict.items():
            logging.info("k {}, v {}".format(k, v))
            if k in ["auRoc", "auPrc"]:  # higher is better
                if metrics_dict[k] < v:  # if under threshold, don't deploy
                    logging.info("{} < {}; returning False".format(metrics_dict[k], v))
                    return False
        logging.info("threshold checks passed.")
        return True

    def log_metrics(metrics_list, metricsc):
        test_confusion_matrix = metrics_list[0]["confusionMatrix"]
        logging.info("rows: %s", test_confusion_matrix["rows"])

        # log the ROC curve
        fpr = []
        tpr = []
        thresholds = []
        for item in metrics_list[0]["confidenceMetrics"]:
            fpr.append(item.get("falsePositiveRate", 0.0))
            tpr.append(item.get("recall", 0.0))
            thresholds.append(item.get("confidenceThreshold", 0.0))
        print(f"fpr: {fpr}")
        print(f"tpr: {tpr}")
        print(f"thresholds: {thresholds}")
        metricsc.log_roc_curve(fpr, tpr, thresholds)

        # log the confusion matrix
        annotations = []
        for item in test_confusion_matrix["annotationSpecs"]:
            annotations.append(item["displayName"])
        logging.info("confusion matrix annotations: %s", annotations)
        metricsc.log_confusion_matrix(
            annotations,
            test_confusion_matrix["rows"],
        )

        # log textual metrics info as well
        for metric in metrics_list[0].keys():
            if metric != "confidenceMetrics":
                val_string = json.dumps(metrics_list[0][metric])
                metrics.log_metric(metric, val_string)
        # metrics.metadata["model_type"] = "AutoML Tabular classification"

    logging.getLogger().setLevel(logging.INFO)
    aip.init(project=project)
    # extract the model resource name from the input Model Artifact
    model_resource_path = model.metadata["resourceName"]
    logging.info("model path: %s", model_resource_path)

    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    client = aip.gapic.ModelServiceClient(client_options=client_options)
    eval_name, metrics_list, metrics_str_list = get_eval_info(
        client, model_resource_path
    )
    logging.info("got evaluation name: %s", eval_name)
    logging.info("got metrics list: %s", metrics_list)
    log_metrics(metrics_list, metricsc)

    thresholds_dict = json.loads(thresholds_dict_str)
    deploy = classification_thresholds_check(metrics_list[0], thresholds_dict)
    if deploy:
        dep_decision = "true"
    else:
        dep_decision = "false"
    logging.info("deployment decision is %s", dep_decision)

    return (dep_decision,)

ধাপ ২: গুগল ক্লাউডের আগে থেকে তৈরি উপাদানগুলো যোগ করা

এই ধাপে আমরা আমাদের পাইপলাইনের বাকি উপাদানগুলো নির্ধারণ করব এবং দেখব সেগুলো কীভাবে একসাথে কাজ করে। প্রথমে, একটি টাইমস্ট্যাম্প ব্যবহার করে আপনার পাইপলাইন রানের জন্য প্রদর্শিত নামটি নির্ধারণ করুন:

import time
DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time())))
print(DISPLAY_NAME)

তারপর নিচের লেখাটি একটি নতুন নোটবুক সেলে কপি করুন:

@pipeline(name="automl-tab-beans-training-v2",
                  pipeline_root=PIPELINE_ROOT)
def pipeline(
    bq_source: str = "bq://aju-dev-demos.beans.beans1",
    display_name: str = DISPLAY_NAME,
    project: str = PROJECT_ID,
    gcp_region: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    thresholds_dict_str: str = '{"auRoc": 0.95}',
):
    dataset_create_op = gcc_aip.TabularDatasetCreateOp(
        project=project, display_name=display_name, bq_source=bq_source
    )

    training_op = gcc_aip.AutoMLTabularTrainingJobRunOp(
        project=project,
        display_name=display_name,
        optimization_prediction_type="classification",
        budget_milli_node_hours=1000,
        column_transformations=[
            {"numeric": {"column_name": "Area"}},
            {"numeric": {"column_name": "Perimeter"}},
            {"numeric": {"column_name": "MajorAxisLength"}},
            {"numeric": {"column_name": "MinorAxisLength"}},
            {"numeric": {"column_name": "AspectRation"}},
            {"numeric": {"column_name": "Eccentricity"}},
            {"numeric": {"column_name": "ConvexArea"}},
            {"numeric": {"column_name": "EquivDiameter"}},
            {"numeric": {"column_name": "Extent"}},
            {"numeric": {"column_name": "Solidity"}},
            {"numeric": {"column_name": "roundness"}},
            {"numeric": {"column_name": "Compactness"}},
            {"numeric": {"column_name": "ShapeFactor1"}},
            {"numeric": {"column_name": "ShapeFactor2"}},
            {"numeric": {"column_name": "ShapeFactor3"}},
            {"numeric": {"column_name": "ShapeFactor4"}},
            {"categorical": {"column_name": "Class"}},
        ],
        dataset=dataset_create_op.outputs["dataset"],
        target_column="Class",
    )
    model_eval_task = classification_model_eval_metrics(
        project,
        gcp_region,
        api_endpoint,
        thresholds_dict_str,
        training_op.outputs["model"],
    )

    with dsl.Condition(
        model_eval_task.outputs["dep_decision"] == "true",
        name="deploy_decision",
    ):

        endpoint_op = gcc_aip.EndpointCreateOp(
            project=project,
            location=gcp_region,
            display_name="train-automl-beans",
        )

        gcc_aip.ModelDeployOp(
            model=training_op.outputs["model"],
            endpoint=endpoint_op.outputs["endpoint"],
            dedicated_resources_min_replica_count=1,
            dedicated_resources_max_replica_count=1,
            dedicated_resources_machine_type="n1-standard-4",
        )

চলুন দেখি এই কোডে কী ঘটছে:

• প্রথমে, আমাদের আগের পাইপলাইনের মতোই, আমরা এই পাইপলাইনের জন্য প্রয়োজনীয় ইনপুট প্যারামিটারগুলো নির্ধারণ করি। আমাদের এগুলো ম্যানুয়ালি সেট করতে হবে, কারণ এগুলো পাইপলাইনের অন্য ধাপগুলোর আউটপুটের উপর নির্ভর করে না।
• পাইপলাইনের বাকি অংশটি ভার্টেক্স এআই সার্ভিসগুলোর সাথে যোগাযোগের জন্য কয়েকটি পূর্ব-নির্মিত কম্পোনেন্ট ব্যবহার করে:
  • TabularDatasetCreateOp ক্লাউড স্টোরেজ বা বিগকোয়েরি থেকে নেওয়া ডেটাসেট সোর্সের উপর ভিত্তি করে ভার্টেক্স এআই-তে একটি টেবুলার ডেটাসেট তৈরি করে। এই পাইপলাইনে, আমরা একটি বিগকোয়েরি টেবিল ইউআরএল-এর মাধ্যমে ডেটা পাস করছি।
  • AutoMLTabularTrainingJobRunOp একটি টেবুলার ডেটাসেটের জন্য একটি অটোএমএল ট্রেনিং জব শুরু করে। আমরা এই কম্পোনেন্টে কয়েকটি কনফিগারেশন প্যারামিটার পাস করি, যার মধ্যে রয়েছে মডেলের ধরন (এই ক্ষেত্রে, ক্লাসিফিকেশন), কলামগুলোর কিছু ডেটা, কতক্ষণ ধরে ট্রেনিং চালাতে চাই এবং ডেটাসেটের একটি পয়েন্টার। লক্ষ্য করুন যে, এই কম্পোনেন্টে ডেটাসেটটি পাস করার জন্য, আমরা dataset_create_op.outputs["dataset"] এর মাধ্যমে পূর্ববর্তী কম্পোনেন্টের আউটপুট প্রদান করছি।
  • EndpointCreateOp ভার্টেক্স এআই-তে একটি এন্ডপয়েন্ট তৈরি করে। এই ধাপে তৈরি এন্ডপয়েন্টটি পরবর্তী কম্পোনেন্টে ইনপুট হিসেবে পাঠানো হবে।
  • ModelDeployOp একটি নির্দিষ্ট মডেলকে Vertex AI-এর একটি এন্ডপয়েন্টে ডেপ্লয় করে। এক্ষেত্রে, আমরা আগের ধাপে তৈরি করা এন্ডপয়েন্টটি ব্যবহার করছি। আরও অতিরিক্ত কনফিগারেশন অপশন রয়েছে, কিন্তু এখানে আমরা এন্ডপয়েন্টের মেশিন টাইপ এবং যে মডেলটি ডেপ্লয় করতে চাই, তা উল্লেখ করছি। আমরা আমাদের পাইপলাইনের ট্রেনিং ধাপের আউটপুটগুলো অ্যাক্সেস করে মডেলটি পাস করছি।
• এই পাইপলাইনটি কন্ডিশনাল লজিকও ব্যবহার করে, যা ভার্টেক্স পাইপলাইনের একটি বৈশিষ্ট্য। এটি আপনাকে একটি শর্ত নির্ধারণ করতে দেয় এবং সেই শর্তের ফলাফলের উপর ভিত্তি করে বিভিন্ন শাখা তৈরি করতে দেয়। মনে রাখবেন, যখন আমরা আমাদের পাইপলাইনটি সংজ্ঞায়িত করেছিলাম, তখন আমরা একটি thresholds_dict_str প্যারামিটার পাস করেছিলাম। এটি হলো সেই অ্যাকুরেসি থ্রেশহোল্ড যা আমরা আমাদের মডেলটিকে কোনো এন্ডপয়েন্টে ডেপ্লয় করব কিনা তা নির্ধারণ করতে ব্যবহার করছি। এটি বাস্তবায়ন করতে, আমরা KFP SDK-এর Condition ক্লাসটি ব্যবহার করি। আমরা যে শর্তটি পাস করি, তা হলো এই কোডল্যাবের শুরুতে আমাদের সংজ্ঞায়িত করা কাস্টম eval কম্পোনেন্টের আউটপুট। যদি এই শর্তটি সত্য হয়, তাহলে পাইপলাইনটি deploy_op কম্পোনেন্টটি কার্যকর করতে থাকবে। যদি অ্যাকুরেসি আমাদের পূর্বনির্ধারিত থ্রেশহোল্ড পূরণ না করে, তাহলে পাইপলাইনটি এখানেই থেমে যাবে এবং কোনো মডেল ডেপ্লয় করবে না।

ধাপ ৩: এন্ড-টু-এন্ড এমএল পাইপলাইনটি কম্পাইল এবং রান করুন।

আমাদের সম্পূর্ণ পাইপলাইন সংজ্ঞায়িত হয়ে গেলে, এখন এটি কম্পাইল করার পালা:

compiler.Compiler().compile(
    pipeline_func=pipeline, package_path="tab_classif_pipeline.json"
)

এরপর, কাজটি সংজ্ঞায়িত করুন:

ml_pipeline_job = aiplatform.PipelineJob(
    display_name="automl-tab-beans-training",
    template_path="tab_classif_pipeline.json",
    pipeline_root=PIPELINE_ROOT,
    parameter_values={"project": PROJECT_ID, "display_name": DISPLAY_NAME},
    enable_caching=True
)

এবং সবশেষে, কাজটি চালান:

ml_pipeline_job.submit()

উপরের সেলটি রান করার পর লগ-এ দেখানো লিঙ্কে গিয়ে কনসোলে আপনার পাইপলাইনটি দেখুন। এই পাইপলাইনটি রান হতে এক ঘণ্টার কিছু বেশি সময় লাগবে। বেশিরভাগ সময় ব্যয় হয় অটোএমএল (AutoML) ট্রেনিং ধাপে। সম্পূর্ণ পাইপলাইনটি দেখতে অনেকটা এইরকম হবে:

আপনি যদি উপরের "Expand artifacts" বাটনটি টগল করেন, তাহলে আপনার পাইপলাইন থেকে তৈরি হওয়া বিভিন্ন আর্টিফ্যাক্টের বিবরণ দেখতে পারবেন। উদাহরণস্বরূপ, আপনি যদি dataset আর্টিফ্যাক্টে ক্লিক করেন, তাহলে তৈরি হওয়া Vertex AI ডেটাসেটটির বিবরণ দেখতে পাবেন। সেই ডেটাসেটের পেজে যেতে আপনি এখানের লিঙ্কে ক্লিক করতে পারেন:

একইভাবে, আমাদের কাস্টম ইভ্যালুয়েশন কম্পোনেন্ট থেকে প্রাপ্ত মেট্রিক ভিজ্যুয়ালাইজেশনগুলো দেখতে, metricsc নামের আর্টিফ্যাক্টটিতে ক্লিক করুন। আপনার ড্যাশবোর্ডের ডানদিকে, আপনি এই মডেলটির কনফিউশন ম্যাট্রিক্স দেখতে পাবেন:

এই পাইপলাইন রান থেকে তৈরি মডেল এবং এন্ডপয়েন্ট দেখতে, মডেলস সেকশনে যান এবং automl-beans নামের মডেলটিতে ক্লিক করুন। automl-beans সেখানে আপনি এই মডেলটিকে একটি এন্ডপয়েন্টে ডেপ্লয় করা দেখতে পাবেন:

আপনার পাইপলাইন গ্রাফে থাকা এন্ডপয়েন্ট আর্টিফ্যাক্ট-এ ক্লিক করেও আপনি এই পেজটি অ্যাক্সেস করতে পারেন।

কনসোলে পাইপলাইন গ্রাফ দেখার পাশাপাশি, আপনি লিনিয়েজ ট্র্যাকিংয়ের জন্য ভার্টেক্স পাইপলাইনও ব্যবহার করতে পারেন। লিনিয়েজ ট্র্যাকিং বলতে আমরা আপনার পাইপলাইন জুড়ে তৈরি হওয়া আর্টিফ্যাক্টগুলোর ট্র্যাকিং বুঝি। এটি আমাদের বুঝতে সাহায্য করে যে আর্টিফ্যাক্টগুলো কোথায় তৈরি হয়েছিল এবং একটি এমএল ওয়ার্কফ্লো জুড়ে সেগুলো কীভাবে ব্যবহৃত হচ্ছে। উদাহরণস্বরূপ, এই পাইপলাইনে তৈরি হওয়া ডেটাসেটের লিনিয়েজ ট্র্যাকিং দেখতে, ডেটাসেট আর্টিফ্যাক্টটিতে ক্লিক করুন এবং তারপরে 'ভিউ লিনিয়েজ'-এ যান ।

এটি আমাদের সেই সমস্ত স্থান দেখায় যেখানে এই প্রত্নবস্তুটি ব্যবহৃত হচ্ছে:

ধাপ ৪: পাইপলাইন রানগুলোর মধ্যে মেট্রিকগুলোর তুলনা করা

আপনি যদি এই পাইপলাইনটি একাধিকবার চালান, তাহলে বিভিন্ন রানের মেট্রিকগুলো তুলনা করতে চাইতে পারেন। রানের মেটাডেটা অ্যাক্সেস করার জন্য আপনি aiplatform.get_pipeline_df() মেথডটি ব্যবহার করতে পারেন। এখানে, আমরা এই পাইপলাইনের সমস্ত রানের মেটাডেটা সংগ্রহ করে একটি Pandas DataFrame-এ লোড করব:

pipeline_df = aiplatform.get_pipeline_df(pipeline="automl-tab-beans-training-v2")
small_pipeline_df = pipeline_df.head(2)
small_pipeline_df

এর সাথেই, আপনার ল্যাব শেষ হলো!

🎉 অভিনন্দন! 🎉

আপনি শিখেছেন কীভাবে ভার্টেক্স এআই ব্যবহার করে:

• কাস্টম কম্পোনেন্ট ব্যবহার করে এন্ড-টু-এন্ড পাইপলাইন তৈরি করতে কুবেফ্লো পাইপলাইনস এসডিকে (Kubeflow Pipelines SDK) ব্যবহার করুন।
• আপনার পাইপলাইনগুলি Vertex Pipelines-এ চালান এবং SDK ব্যবহার করে পাইপলাইন রান শুরু করুন।
• কনসোলে আপনার ভার্টেক্স পাইপলাইন গ্রাফ দেখুন এবং বিশ্লেষণ করুন।
• আপনার পাইপলাইনে Vertex AI পরিষেবা যোগ করতে আগে থেকে তৈরি পাইপলাইন উপাদানগুলি ব্যবহার করুন।
• পুনরাবৃত্তিমূলক পাইপলাইন কাজের সময়সূচী নির্ধারণ করুন

Vertex-এর বিভিন্ন অংশ সম্পর্কে আরও জানতে ডকুমেন্টেশন দেখুন।

৭. পরিচ্ছন্নতা

যাতে আপনাকে চার্জ করা না হয়, সেজন্য এই ল্যাব জুড়ে তৈরি করা রিসোর্সগুলো মুছে ফেলার পরামর্শ দেওয়া হচ্ছে।

ধাপ ১: আপনার নোটবুক ইনস্ট্যান্সটি বন্ধ করুন বা মুছে ফেলুন।

আপনি যদি এই ল্যাবে তৈরি করা নোটবুকটি ব্যবহার করা চালিয়ে যেতে চান, তবে ব্যবহার না করার সময় এটি বন্ধ করে রাখার পরামর্শ দেওয়া হচ্ছে। আপনার ক্লাউড কনসোলের নোটবুকস UI থেকে, নোটবুকটি নির্বাচন করুন এবং তারপরে স্টপ (Stop) নির্বাচন করুন। আপনি যদি ইনস্ট্যান্সটি সম্পূর্ণরূপে মুছে ফেলতে চান, তাহলে ডিলিট (Delete ) নির্বাচন করুন।

ধাপ ২: আপনার এন্ডপয়েন্টটি মুছে ফেলুন।

আপনার স্থাপন করা এন্ডপয়েন্টটি মুছে ফেলতে, আপনার Vertex AI কনসোলের এন্ডপয়েন্টস বিভাগে যান এবং ডিলিট আইকনে ক্লিক করুন:

তারপর, নিচের প্রম্পট থেকে Undeploy-এ ক্লিক করুন:

অবশেষে, আপনার কনসোলের মডেলস (Models) বিভাগে যান, সেই মডেলটি খুঁজুন এবং ডানদিকের তিন ডট মেনু থেকে ' ডিলিট মডেল' (Delete model) এ ক্লিক করুন।

ধাপ ৩: আপনার ক্লাউড স্টোরেজ বাকেটটি মুছে ফেলুন

স্টোরেজ বাকেটটি ডিলিট করতে, আপনার ক্লাউড কনসোলের নেভিগেশন মেনু ব্যবহার করে স্টোরেজ-এ যান, আপনার বাকেটটি সিলেক্ট করুন এবং ডিলিট-এ ক্লিক করুন: