পরীক্ষা-নিরীক্ষার সর্বোচ্চ সুবিধা নিন: Vertex AI-এর সাহায্যে মেশিন লার্নিং পরীক্ষাগুলি পরিচালনা করুন

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

এই ল্যাবে, আপনি Vertex AI ব্যবহার করে একটি পাইপলাইন তৈরি করবেন যা TensorFlow-তে একটি কাস্টম Keras মডেলকে প্রশিক্ষণ দেবে। এরপর আমরা Vertex AI Experiments- এ উপলব্ধ নতুন কার্যকারিতা ব্যবহার করে মডেল রানগুলো ট্র্যাক ও তুলনা করব, যাতে হাইপারপ্যারামিটারের কোন সংমিশ্রণটি সেরা পারফরম্যান্স দেয় তা শনাক্ত করা যায়।

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

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

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

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

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

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

ভার্টেক্স এআই-এর এন্ড-টু-এন্ড এমএল ওয়ার্কফ্লো সমর্থন করার জন্য বিভিন্ন পণ্য রয়েছে। এই ল্যাবটি নিচে উল্লেখিত পণ্যগুলোর উপর আলোকপাত করবে: এক্সপেরিমেন্টস , পাইপলাইনস , এমএল মেটাডেটা এবং ওয়ার্কবেঞ্চ।

৩. ব্যবহারের ক্ষেত্রের সংক্ষিপ্ত বিবরণ

আমরা EA Sports-এর FIFA ভিডিও গেম সিরিজ থেকে সংগৃহীত একটি জনপ্রিয় সকার ডেটাসেট ব্যবহার করব। এতে ২০০৮-২০১৬ মৌসুমের ২৫,০০০-এর বেশি সকার ম্যাচ এবং ১০,০০০-এর বেশি খেলোয়াড় অন্তর্ভুক্ত রয়েছে। ডেটাটি আগে থেকেই প্রি-প্রসেস করা হয়েছে, যাতে আপনি আরও সহজে কাজ শুরু করতে পারেন। আপনি এই ল্যাব জুড়ে এই ডেটাসেটটি ব্যবহার করবেন, যা এখন একটি পাবলিক ক্লাউড স্টোরেজ বাকেটে পাওয়া যাবে। ডেটাসেটটি কীভাবে অ্যাক্সেস করতে হয় সে সম্পর্কে আমরা কোডল্যাবের পরবর্তী অংশে আরও বিস্তারিত জানাব। আমাদের চূড়ান্ত লক্ষ্য হলো খেলার বিভিন্ন কার্যকলাপ, যেমন ইন্টারসেপশন এবং পেনাল্টির উপর ভিত্তি করে একজন খেলোয়াড়ের সামগ্রিক রেটিং অনুমান করা।

ডেটা সায়েন্সের জন্য ভার্টেক্স এআই এক্সপেরিমেন্টস কেন উপকারী?

ডেটা সায়েন্স স্বভাবতই পরীক্ষামূলক — সর্বোপরি, তাঁদেরকে বিজ্ঞানীই বলা হয়। ভালো ডেটা সায়েন্টিস্টরা অনুমান-চালিত হন এবং বারবার চেষ্টার মাধ্যমে বিভিন্ন অনুমান পরীক্ষা করে দেখেন, এই আশায় যে ধারাবাহিক পুনরাবৃত্তির ফলে আরও উন্নত কর্মক্ষম একটি মডেল তৈরি হবে।

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

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

সংক্ষেপে বলতে গেলে: Vertex AI Experiments আপনার হয়ে কাজটি করে দেয়, যা আপনাকে আপনার এক্সপেরিমেন্টগুলো আরও সহজে ট্র্যাক ও তুলনা করতে সাহায্য করে।

গেমিংয়ের জন্য ভার্টেক্স এআই এক্সপেরিমেন্ট কেন?

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

৪. আপনার পরিবেশ প্রস্তুত করুন

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

ধাপ ১: কম্পিউট ইঞ্জিন এপিআই সক্রিয় করুন

Compute Engine- এ যান এবং যদি এটি আগে থেকে চালু না থাকে, তাহলে Enable নির্বাচন করুন।

ধাপ ২: Vertex AI API সক্রিয় করুন

আপনার ক্লাউড কনসোলের Vertex AI বিভাগে যান এবং Enable Vertex AI API-তে ক্লিক করুন।

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

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

নোটবুকস এপিআই (Notebooks API) সক্রিয় করুন, যদি আগে থেকে সক্রিয় করা না থাকে।

একবার চালু হয়ে গেলে, ম্যানেজড নোটবুকস-এ ক্লিক করুন:

তারপর নতুন নোটবুক নির্বাচন করুন।

আপনার নোটবুকটির একটি নাম দিন, এবং তারপর অ্যাডভান্সড সেটিংস-এ ক্লিক করুন।

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

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

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

ধাপ ৫: প্রমাণীকরণ করুন (শুধুমাত্র প্রথমবার)

আপনি যখন প্রথমবার একটি নতুন ইনস্ট্যান্স ব্যবহার করবেন, তখন আপনাকে প্রমাণীকরণের জন্য বলা হবে। এটি করার জন্য UI-তে দেওয়া ধাপগুলো অনুসরণ করুন।

ধাপ ৬: উপযুক্ত কার্নেল নির্বাচন করুন

ম্যানেজড-নোটবুকস একটি একক UI-তে একাধিক কার্নেল প্রদান করে। Tensorflow 2 (লোকাল)-এর জন্য কার্নেলটি নির্বাচন করুন।

৫. আপনার নোটবুকে প্রাথমিক সেটআপের ধাপসমূহ

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

ধাপ ১: অতিরিক্ত প্যাকেজ ইনস্টল করুন

আপনার নোটবুক পরিবেশে বর্তমানে ইনস্টল করা নেই এমন অতিরিক্ত প্যাকেজ নির্ভরতা আমাদের ইনস্টল করতে হবে। উদাহরণস্বরূপ, কেএফপি এসডিকে (KFP SDK) উল্লেখ করা যায়।

!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts

এরপর আপনাকে নোটবুক কার্নেলটি রিস্টার্ট করতে হবে, যাতে আপনি আপনার নোটবুকের মধ্যে ডাউনলোড করা প্যাকেজগুলো ব্যবহার করতে পারেন।

# Automatically restart kernel after installs
import os

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

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

ধাপ ২: ভেরিয়েবল সেট করুন

আমরা আমাদের PROJECT_ID নির্ধারণ করতে চাই। আপনি যদি আপনার Project_ID না জানেন, তাহলে gcloud ব্যবহার করে PROJECT_ID পেতে পারেন।

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)

অন্যথায়, এখানে আপনার PROJECT_ID সেট করুন।

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

আমরা REGION ভেরিয়েবলটিও সেট করতে চাইব, যা এই নোটবুকের বাকি অংশে ব্যবহৃত হয়েছে। নিচে Vertex AI-এর জন্য সমর্থিত অঞ্চলগুলো দেওয়া হলো। আমরা আপনাকে আপনার সবচেয়ে কাছের অঞ্চলটি বেছে নেওয়ার পরামর্শ দিচ্ছি।

• আমেরিকা: us-central1
• ইউরোপ: ইউরোপ-পশ্চিম৪
• এশিয়া প্যাসিফিক: এশিয়া-পূর্ব১

অনুগ্রহ করে Vertex AI দিয়ে প্রশিক্ষণের জন্য মাল্টি-রিজিওনাল বাকেট ব্যবহার করবেন না। সব রিজিয়ন Vertex AI-এর সকল পরিষেবা সমর্থন করে না। Vertex AI রিজিয়ন সম্পর্কে আরও জানুন।

#set your region 
REGION = "us-central1"  # @param {type: "string"}

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

#set timestamp to avoid collisions between multiple users

from datetime import datetime

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

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

আপনাকে একটি ক্লাউড স্টোরেজ স্টেজিং বাকেট নির্দিষ্ট করতে হবে এবং ব্যবহার করতে হবে। স্টেজিং বাকেট হলো এমন একটি জায়গা যেখানে আপনার ডেটাসেট এবং মডেল রিসোর্সের সাথে সম্পর্কিত সমস্ত ডেটা বিভিন্ন সেশন জুড়ে সংরক্ষিত থাকে।

নিচে আপনার ক্লাউড স্টোরেজ বাকেটের নাম সেট করুন। আপনার প্রতিষ্ঠানের বাইরের প্রজেক্টগুলো সহ সমস্ত গুগল ক্লাউড প্রজেক্ট জুড়ে বাকেটের নাম অবশ্যই বিশ্বব্যাপী অনন্য হতে হবে।

#set cloud storage bucket 
BUCKET_NAME = "[insert bucket name here]"  # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"

আপনার বাকেটটি যদি আগে থেকে বিদ্যমান না থাকে, তাহলে আপনার ক্লাউড স্টোরেজ বাকেট তৈরি করতে আপনি নিম্নলিখিত সেলটি চালাতে পারেন।

! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI

এরপর আপনি নিচের সেলটি চালিয়ে আপনার ক্লাউড স্টোরেজ বাকেটে অ্যাক্সেস যাচাই করতে পারেন।

#verify access 
! gsutil ls -al $BUCKET_URI

ধাপ ৪: আমাদের গেমিং ডেটাসেটটি কপি করুন

যেমনটি আগে উল্লেখ করা হয়েছে, আপনি EA Sports-এর জনপ্রিয় ভিডিও গেম FIFA-এর একটি ডেটাসেট ব্যবহার করবেন। আমরা আপনার জন্য প্রি-প্রসেসিং-এর কাজ করে দিয়েছি, তাই আপনাকে শুধু পাবলিক স্টোরেজ বাকেট থেকে ডেটাসেটটি কপি করে আপনার তৈরি করা স্টোরেজে স্থানান্তর করতে হবে।

# copy the data over to your cloud storage bucket
DATASET_URI = "gs://cloud-samples-data/vertex-ai/structured_data/player_data" 

!gsutil cp -r $DATASET_URI $BUCKET_URI

ধাপ ৫: লাইব্রেরি ইম্পোর্ট করুন এবং অতিরিক্ত কনস্ট্যান্ট নির্ধারণ করুন

এরপর আমরা Vertex AI, KFP ইত্যাদির জন্য আমাদের লাইব্রেরিগুলো ইম্পোর্ট করতে চাইব।

import logging
import os
import time

logger = logging.getLogger("logger")
logging.basicConfig(level=logging.INFO)

import kfp.v2.compiler as compiler
# Pipeline Experiments
import kfp.v2.dsl as dsl
# Vertex AI
from google.cloud import aiplatform as vertex_ai
from kfp.v2.dsl import Artifact, Input, Metrics, Model, Output, component
from typing import NamedTuple

আমরা আরও কিছু ধ্রুবক নির্ধারণ করব, যেগুলো আমরা নোটবুকের বাকি অংশে উল্লেখ করব, যেমন আমাদের প্রশিক্ষণ ডেটার ফাইল পাথ(গুলো)।

#import libraries and define constants
# Experiments

TASK = "regression"
MODEL_TYPE = "tensorflow"
EXPERIMENT_NAME = f"{PROJECT_ID}-{TASK}-{MODEL_TYPE}-{TIMESTAMP}"

# Pipeline
PIPELINE_URI = f"{BUCKET_URI}/pipelines"
TRAIN_URI = f"{BUCKET_URI}/player_data/data.csv"
LABEL_URI = f"{BUCKET_URI}/player_data/labels.csv"
MODEL_URI = f"{BUCKET_URI}/model"
DISPLAY_NAME = "experiments-demo-gaming-data"
BQ_DATASET = "player_data"
BQ_LOCATION = "US"  
VIEW_NAME = 'dataset_test'
PIPELINE_JSON_PKG_PATH = "experiments_demo_gaming_data.json"
PIPELINE_ROOT = f"gs://{BUCKET_URI}/pipeline_root"

৬. চলুন আমাদের পাইপলাইন তৈরি করি

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

ধাপ ১: ভার্টেক্স এআই এসডিকে চালু করুন

আপনার PROJECT_ID এবং BUCKET_URI সেট করে Vertex AI SDK চালু করুন।

#initialize vertex AI SDK 
vertex_ai.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)

ধাপ ২: আমাদের ট্রেনিং জবটিকে একটি পাইপলাইন কম্পোনেন্ট হিসেবে সেটআপ করুন।

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

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

@component(
    packages_to_install=[
        "numpy==1.21.0",
        "pandas==1.3.5", 
        "scikit-learn==1.0.2",
        "tensorflow==2.9.0",
    ]
)
def custom_trainer(
    train_uri: str,
    label_uri: str,
    dropout_rate: float,
    learning_rate: float,
    epochs: int,
    model_uri: str,
    metrics: Output[Metrics], 
    model_metadata: Output[Model], 
    

):

    # import libraries
    import logging
    import uuid
    from pathlib import Path as path

    import pandas as pd
    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense
    from tensorflow.keras.layers import Dropout
    from tensorflow.keras.metrics import Metric 
    from sklearn.metrics import accuracy_score
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import mean_absolute_error
    import numpy as np
    from math import sqrt
    import os
    import tempfile

    # set variables and use gcsfuse to update prefixes
    gs_prefix = "gs://"
    gcsfuse_prefix = "/gcs/"
    train_path = train_uri.replace(gs_prefix, gcsfuse_prefix)
    label_path = label_uri.replace(gs_prefix, gcsfuse_prefix)
    model_path = model_uri.replace(gs_prefix, gcsfuse_prefix)

    def get_logger():

        logger = logging.getLogger(__name__)
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        handler.setFormatter(
            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
        )
        logger.addHandler(handler)
        return logger

    def get_data(
        train_path: str, 
        label_path: str
    ) -> (pd.DataFrame): 
        
        
        #load data into pandas dataframe
        data_0 = pd.read_csv(train_path)
        labels_0 = pd.read_csv(label_path)
        
        #drop unnecessary leading columns
        
        data = data_0.drop('Unnamed: 0', axis=1)
        labels = labels_0.drop('Unnamed: 0', axis=1)
        
        #save as numpy array for reshaping of data 
        
        labels = labels.values
        data = data.values
    
        # Split the data
        labels = labels.reshape((labels.size,))
        train_data, test_data, train_labels, test_labels = train_test_split(data, labels, test_size=0.2, shuffle=True, random_state=7)
    
        #Convert data back to pandas dataframe for scaling
        
        train_data = pd.DataFrame(train_data)
        test_data = pd.DataFrame(test_data)
        train_labels = pd.DataFrame(train_labels)
        test_labels = pd.DataFrame(test_labels)
        
        #Scale and normalize the training dataset
        
        scaler = StandardScaler()
        scaler.fit(train_data)
        train_data = pd.DataFrame(scaler.transform(train_data), index=train_data.index, columns=train_data.columns)
        test_data = pd.DataFrame(scaler.transform(test_data), index=test_data.index, columns=test_data.columns)
        
        return train_data,train_labels, test_data, test_labels 
    
        """ Train your Keras model passing in the training data and values for learning rate, dropout rate,and the number of epochs """

    def train_model(
        learning_rate: float, 
        dropout_rate: float,
        epochs: float,
        train_data: pd.DataFrame,
        train_labels: pd.DataFrame):
 
        # Train tensorflow model
        param = {"learning_rate": learning_rate, "dropout_rate": dropout_rate, "epochs": epochs}
        model = Sequential()
        model.add(Dense(500, input_dim=train_data.shape[1], activation= "relu"))
        model.add(Dropout(param['dropout_rate']))
        model.add(Dense(100, activation= "relu"))
        model.add(Dense(50, activation= "relu"))
        model.add(Dense(1))
            
        model.compile(
        tf.keras.optimizers.Adam(learning_rate= param['learning_rate']),
        loss='mse',
        metrics=[tf.keras.metrics.RootMeanSquaredError(),tf.keras.metrics.MeanAbsoluteError()])
        
        model.fit(train_data, train_labels, epochs= param['epochs'])
        
        return model

    # Get Predictions
    def get_predictions(model, test_data):

        dtest = pd.DataFrame(test_data)
        pred = model.predict(dtest)
        return pred

    # Evaluate predictions with MAE
    def evaluate_model_mae(pred, test_labels):
        
        mae = mean_absolute_error(test_labels, pred)
        return mae
    
    # Evaluate predictions with RMSE
    def evaluate_model_rmse(pred, test_labels):

        rmse = np.sqrt(np.mean((test_labels - pred)**2))
        return rmse    
 
    
    #Save your trained model in GCS     
    def save_model(model, model_path):

        model_id = str(uuid.uuid1())
        model_path = f"{model_path}/{model_id}"        
        path(model_path).parent.mkdir(parents=True, exist_ok=True)
        model.save(model_path + '/model_tensorflow')

        
    # Main ----------------------------------------------
    
    train_data, train_labels, test_data, test_labels = get_data(train_path, label_path)
    model = train_model(learning_rate, dropout_rate, epochs, train_data,train_labels )
    pred = get_predictions(model, test_data)
    mae = evaluate_model_mae(pred, test_labels)
    rmse = evaluate_model_rmse(pred, test_labels)
    save_model(model, model_path)

    # Metadata ------------------------------------------

    #convert numpy array to pandas series
    mae = pd.Series(mae)
    rmse = pd.Series(rmse)

    #log metrics and model artifacts with ML Metadata. Save metrics as a list. 
    metrics.log_metric("mae", mae.to_list()) 
    metrics.log_metric("rmse", rmse.to_list()) 
    model_metadata.uri = model_uri

ধাপ ৩: আমাদের পাইপলাইন তৈরি করুন

এখন আমরা KFP-তে উপলব্ধ Domain Specific Language (DSL) ব্যবহার করে আমাদের ওয়ার্কফ্লো সেটআপ করব এবং আমাদের পাইপলাইনটিকে একটি JSON ফাইলে কম্পাইল করব।

# define our workflow

@dsl.pipeline(name="gaming-custom-training-pipeline")
def pipeline(
    train_uri: str,
    label_uri: str,
    dropout_rate: float,
    learning_rate: float,
    epochs: int,
    model_uri: str,
):

    custom_trainer(
        train_uri,label_uri, dropout_rate,learning_rate,epochs, model_uri
    )

#compile our pipeline
compiler.Compiler().compile(pipeline_func=pipeline, package_path="gaming_pipeline.json")

ধাপ ৪: আমাদের পাইপলাইন রান(গুলি) জমা দিন

আমাদের কম্পোনেন্ট সেট আপ করা এবং পাইপলাইন সংজ্ঞায়িত করার কঠিন কাজটি সম্পন্ন হয়েছে। আমরা উপরে উল্লেখিত পাইপলাইনের বিভিন্ন রান জমা দেওয়ার জন্য প্রস্তুত। এটি করার জন্য, আমাদের বিভিন্ন হাইপারপ্যারামিটারের মানগুলি নিম্নরূপভাবে সংজ্ঞায়িত করতে হবে:

runs = [
    {"dropout_rate": 0.001, "learning_rate": 0.001,"epochs": 20},
    {"dropout_rate": 0.002, "learning_rate": 0.002,"epochs": 25},
    {"dropout_rate": 0.003, "learning_rate": 0.003,"epochs": 30},
    {"dropout_rate": 0.004, "learning_rate": 0.004,"epochs": 35},
    {"dropout_rate": 0.005, "learning_rate": 0.005,"epochs": 40},
]

হাইপারপ্যারামিটারগুলো সংজ্ঞায়িত করা হয়ে গেলে, আমরা একটি for loop ব্যবহার করে পাইপলাইনের বিভিন্ন রান সফলভাবে ইনপুট করতে পারি:

for i, run in enumerate(runs):

    job = vertex_ai.PipelineJob(
        display_name=f"{EXPERIMENT_NAME}-pipeline-run-{i}",
        template_path="gaming_pipeline.json",
        pipeline_root=PIPELINE_URI,
        parameter_values={
            "train_uri": TRAIN_URI,
            "label_uri": LABEL_URI,
            "model_uri": MODEL_URI,
            **run,
        },
    )
    job.submit(experiment=EXPERIMENT_NAME)

ধাপ ৫: এক্সপেরিমেন্টগুলো দেখার জন্য ভার্টেক্স এআই এসডিকে ব্যবহার করুন

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

# see state/status of all the pipeline runs

vertex_ai.get_experiment_df(EXPERIMENT_NAME)

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

আপনার পাইপলাইন রানগুলোর অবস্থা সম্পর্কে আপডেট পেতে আপনি নিচের কোডটি ব্যবহার করতে পারেন।

#check on current status
while True:
    pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
    if all(
        pipeline_state != "COMPLETE" for pipeline_state in pipeline_experiments_df.state
    ):
        print("Pipeline runs are still running...")
        if any(
            pipeline_state == "FAILED"
            for pipeline_state in pipeline_experiments_df.state
        ):
            print("At least one Pipeline run failed")
            break
    else:
        print("Pipeline experiment runs have completed")
        break
    time.sleep(60)

আপনি run_name ব্যবহার করে নির্দিষ্ট পাইপলাইন জবগুলোও কল করতে পারেন।

# Call the pipeline runs based on the experiment run name
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
job = vertex_ai.PipelineJob.get(pipeline_experiments_df.run_name[0])
print(job.resource_name)
print(job._dashboard_uri())

অবশেষে, আপনি নির্দিষ্ট বিরতিতে (যেমন প্রতি ৬০ সেকেন্ডে) আপনার রানগুলোর অবস্থা রিফ্রেশ করতে পারেন, যাতে অবস্থাটি RUNNING থেকে FAILED বা COMPLETE পরিবর্তিত হতে দেখা যায়।

# wait 60 seconds and view state again
import time
time.sleep(60)
vertex_ai.get_experiment_df(EXPERIMENT_NAME)

৭. সেরা পারফর্মিং রানটি শনাক্ত করুন

চমৎকার, আমরা এখন আমাদের পাইপলাইন রানগুলোর ফলাফল পেয়েছি। আপনি হয়তো জিজ্ঞাসা করছেন, এই ফলাফল থেকে আমি কী শিখতে পারি? আপনার পরীক্ষাগুলোর আউটপুটে পাঁচটি সারি থাকা উচিত, পাইপলাইনের প্রতিটি রানের জন্য একটি করে। এটি দেখতে নিচের মতো হবে:

MAE এবং RMSE উভয়ই মডেলের গড় প্রেডিকশন এররের পরিমাপ, তাই বেশিরভাগ ক্ষেত্রেই উভয় মেট্রিকের জন্য একটি নিম্ন মান কাম্য। আমরা Vertex AI Experiments-এর আউটপুটের উপর ভিত্তি করে দেখতে পাচ্ছি যে, উভয় মেট্রিক জুড়ে আমাদের সবচেয়ে সফল রানটি ছিল চূড়ান্ত রান, যেখানে dropout_rate ছিল 0.001, learning_rate ছিল 0.001 এবং মোট epochs সংখ্যা ছিল 20। এই পরীক্ষার উপর ভিত্তি করে, এই মডেল প্যারামিটারগুলোই চূড়ান্তভাবে প্রোডাকশনে ব্যবহার করা হবে, কারণ এটি মডেলের সেরা পারফরম্যান্স প্রদান করে।

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

🎉 অভিনন্দন! 🎉

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

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

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

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

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

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

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

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

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