एक्सपेरिमेंट का ज़्यादा से ज़्यादा फ़ायदा पाएं: Vertex AI की मदद से मशीन लर्निंग के एक्सपेरिमेंट मैनेज करें

1. खास जानकारी

इस लैब में, Vertex AI का इस्तेमाल करके एक ऐसी पाइपलाइन बनाई जाएगी जो TensorFlow में कस्टम केरस मॉडल को ट्रेन करती है. इसके बाद, हम Vertex AI Experiments में उपलब्ध नई सुविधा का इस्तेमाल करके, मॉडल रन को ट्रैक और उनकी तुलना करेंगे. इससे यह पता लगाया जा सकेगा कि हाइपरपैरामीटर के किस कॉम्बिनेशन से सबसे अच्छी परफ़ॉर्मेंस मिलती है.

आपको ये सब सीखने को मिलेगा

आपको, इनके बारे में जानकारी मिलेगी:

• खिलाड़ी की रेटिंग का अनुमान लगाने के लिए, कस्टम Keras मॉडल को ट्रेन करें (जैसे, रिग्रेशन)
• स्केल की जा सकने वाली एमएल पाइपलाइन बनाने के लिए, Kubeflow Pipelines SDK का इस्तेमाल करना
• पांच चरणों वाली पाइपलाइन बनाएं और उसे चलाएं. यह पाइपलाइन, Cloud Storage से डेटा लेती है, डेटा को स्केल करती है, मॉडल को ट्रेन करती है, उसका आकलन करती है, और नतीजे के तौर पर मिले मॉडल को वापस Cloud Storage में सेव करती है
• मॉडल और मॉडल मेट्रिक जैसे मॉडल आर्टफ़ैक्ट सेव करने के लिए, Vertex ML Metadata का इस्तेमाल करें
• अलग-अलग पाइपलाइन रन के नतीजों की तुलना करने के लिए, Vertex AI Experiments का इस्तेमाल करना

इस लैब को Google Cloud पर चलाने की कुल लागत करीब 1 डॉलर है.

2. Vertex AI के बारे में जानकारी

इस लैब में, Google Cloud पर उपलब्ध एआई प्रॉडक्ट की नई सुविधा का इस्तेमाल किया जाता है. Vertex AI, Google Cloud के सभी एमएल प्रॉडक्ट को एक साथ इंटिग्रेट करता है, ताकि डेवलपर को बेहतर अनुभव मिल सके. पहले, AutoML और कस्टम मॉडल से ट्रेन किए गए मॉडल को अलग-अलग सेवाओं के ज़रिए ऐक्सेस किया जा सकता था. नए ऑफ़र में, इन दोनों को एक ही एपीआई में शामिल किया गया है. साथ ही, इसमें अन्य नए प्रॉडक्ट भी शामिल हैं. मौजूदा प्रोजेक्ट को भी Vertex AI पर माइग्रेट किया जा सकता है.

Vertex AI में कई अलग-अलग प्रॉडक्ट शामिल हैं, ताकि मशीन लर्निंग के वर्कफ़्लो को शुरू से लेकर आखिर तक सपोर्ट किया जा सके. इस लैब में, यहां हाइलाइट किए गए प्रॉडक्ट पर फ़ोकस किया जाएगा: एक्सपेरिमेंट, पाइपलाइन, एमएल मेटाडेटा, और Workbench

3. इस्तेमाल के उदाहरण की खास जानकारी

हम EA Sports की FIFA वीडियो गेम सीरीज़ से लिए गए, फ़ुटबॉल के लोकप्रिय डेटासेट का इस्तेमाल करेंगे. इसमें 2008 से 2016 के सीज़न के 25,000 से ज़्यादा सॉकर मैच और 10,000 से ज़्यादा खिलाड़ियों की जानकारी शामिल है. डेटा को पहले से प्रोसेस किया गया है, ताकि आप आसानी से काम शुरू कर सकें. आपको इस पूरे लैब में इस डेटासेट का इस्तेमाल करना होगा. यह अब सार्वजनिक Cloud Storage बकेट में मिल सकता है. डेटासेट को ऐक्सेस करने के तरीके के बारे में ज़्यादा जानकारी, हम बाद में कोडलैब में देंगे. हमारा मुख्य मकसद, गेम में की गई अलग-अलग कार्रवाइयों के आधार पर, किसी खिलाड़ी की कुल रेटिंग का अनुमान लगाना है. जैसे, इंटरसेप्शन और पेनल्टी.

डेटा साइंस के लिए, Vertex AI Experiments क्यों मददगार है?

डेटा साइंस, एक्सपेरिमेंट पर आधारित होती है. इसलिए, इन्हें वैज्ञानिक कहा जाता है. अच्छे डेटा साइंटिस्ट, हाइपॉथेसिस पर आधारित होते हैं. वे अलग-अलग हाइपॉथेसिस को आज़माने के लिए, ट्रायल-एंड-एरर का इस्तेमाल करते हैं. उन्हें उम्मीद होती है कि बार-बार किए जाने वाले बदलावों से, बेहतर परफ़ॉर्म करने वाला मॉडल मिलेगा.

डेटा साइंस की टीमें एक्सपेरिमेंट को अपना चुकी हैं. हालांकि, उन्हें अक्सर अपने काम और एक्सपेरिमेंट के ज़रिए पता चले "सीक्रेट सॉस" को ट्रैक करने में मुश्किल होती है. ऐसा इन वजहों से होता है:

• ट्रेनिंग जॉब को ट्रैक करना मुश्किल हो सकता है. इससे यह पता लगाना मुश्किल हो जाता है कि कौनसी चीज़ काम कर रही है और कौनसी नहीं
• डेटा साइंस टीम के सभी सदस्यों के लिए, यह समस्या और भी गंभीर हो जाती है. ऐसा इसलिए, क्योंकि हो सकता है कि सभी सदस्य एक्सपेरिमेंट को ट्रैक न कर रहे हों या अपने नतीजों को दूसरों के साथ शेयर न कर रहे हों
• डेटा इकट्ठा करने में समय लगता है.साथ ही, ज़्यादातर टीमें मैन्युअल तरीके (जैसे, शीट या दस्तावेज़) का इस्तेमाल करती हैं. इससे, सीखने के लिए अधूरी और अलग-अलग जानकारी मिलती है

संक्षेप में: Vertex AI Experiments आपके लिए काम करता है. इससे आपको अपने एक्सपेरिमेंट को आसानी से ट्रैक करने और उनकी तुलना करने में मदद मिलती है

गेमिंग के लिए Vertex AI Experiments क्यों?

गेमिंग, मशीन लर्निंग और एमएल एक्सपेरिमेंट के लिए हमेशा से एक बेहतरीन प्लैटफ़ॉर्म रहा है. गेम न सिर्फ़ हर दिन अरबों रीयल टाइम इवेंट जनरेट करते हैं, बल्कि वे एमएल और एमएल एक्सपेरिमेंट का इस्तेमाल करके, उस पूरे डेटा का इस्तेमाल करते हैं. इससे उन्हें गेम में लोगों के अनुभव को बेहतर बनाने, खिलाड़ियों को बनाए रखने, और अपने प्लैटफ़ॉर्म पर अलग-अलग खिलाड़ियों का आकलन करने में मदद मिलती है. इसलिए, हमें लगा कि गेमिंग डेटासेट, हमारे सभी एक्सपेरिमेंट के लिए सही रहेगा.

4. अपना एनवायरमेंट सेट अप करने का तरीका

इस कोडलैब को चलाने के लिए, आपके पास बिलिंग की सुविधा वाला Google Cloud Platform प्रोजेक्ट होना चाहिए. प्रोजेक्ट बनाने के लिए, यहां दिए गए निर्देशों का पालन करें.

पहला चरण: Compute Engine API चालू करना

Compute Engine पर जाएं. अगर यह पहले से चालू नहीं है, तो चालू करें को चुनें.

दूसरा चरण: Vertex AI API चालू करना

Cloud Console के Vertex AI सेक्शन पर जाएं और Vertex AI API चालू करें पर क्लिक करें.

तीसरा चरण: Vertex AI Workbench इंस्टेंस बनाना

Cloud Console के Vertex AI सेक्शन में जाकर, Workbench पर क्लिक करें:

अगर Notebooks API पहले से चालू नहीं है, तो इसे चालू करें.

चालू होने के बाद, मैनेज की गई नोटबुक पर क्लिक करें:

इसके बाद, नई नोटबुक चुनें.

अपनी नोटबुक को कोई नाम दें. इसके बाद, बेहतर सेटिंग पर क्लिक करें.

ऐडवांस सेटिंग में जाकर, डिवाइस के बंद होने की सुविधा चालू करें. इसके बाद, डिवाइस के बंद होने का समय 60 मिनट पर सेट करें. इसका मतलब है कि इस्तेमाल न किए जाने पर, आपकी नोटबुक अपने-आप बंद हो जाएगी, ताकि आपको बिना वजह शुल्क न देना पड़े.

चौथा चरण: अपनी नोटबुक खोलें

इंस्टेंस बन जाने के बाद, JupyterLab खोलें को चुनें.

पांचवां चरण: पुष्टि करना (सिर्फ़ पहली बार)

पहली बार किसी नए इंस्टेंस का इस्तेमाल करते समय, आपसे पुष्टि करने के लिए कहा जाएगा. इसके लिए, यूज़र इंटरफ़ेस (यूआई) में दिया गया तरीका अपनाएं.

छठा चरण: सही कर्नल चुनना

मैनेज की गई नोटबुक, एक ही यूज़र इंटरफ़ेस (यूआई) में कई कर्नल उपलब्ध कराती हैं. Tensorflow 2 (लोकल) के लिए कर्नल चुनें.

5. नोटबुक में शुरुआती सेटअप करने का तरीका

पाइपलाइन बनाने से पहले, आपको नोटबुक में अपना एनवायरमेंट सेट अप करने के लिए, कुछ और चरण पूरे करने होंगे. इन चरणों में ये काम शामिल हैं: कोई अतिरिक्त पैकेज इंस्टॉल करना, वैरिएबल सेट करना, क्लाउड स्टोरेज बकेट बनाना, सार्वजनिक स्टोरेज बकेट से गेमिंग डेटासेट कॉपी करना, और लाइब्रेरी इंपोर्ट करना और अतिरिक्त कॉन्स्टेंट तय करना.

पहला चरण: अतिरिक्त पैकेज इंस्टॉल करना

हमें कुछ और पैकेज इंस्टॉल करने होंगे. ये पैकेज, फ़िलहाल आपके नोटबुक एनवायरमेंट में इंस्टॉल नहीं हैं. उदाहरण के लिए, KFP SDK शामिल है.

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

इसके बाद, आपको Notebook कर्नेल को फिर से शुरू करना होगा, ताकि डाउनलोड किए गए पैकेज का इस्तेमाल अपनी नोटबुक में किया जा सके.

# 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
• यूरोप: europe-west4
• एशिया पैसिफ़िक: asia-east1

कृपया 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")

तीसरा चरण: Cloud Storage बकेट बनाना

आपको Cloud Storage के किसी स्टेसिंग बकेट का इस्तेमाल करना होगा. स्टेजिंग बकेट में, आपके डेटासेट और मॉडल संसाधनों से जुड़ा सारा डेटा सेव रहता है. यह डेटा, सभी सेशन में सेव रहता है.

यहां Cloud Storage बकेट का नाम सेट करें. बकेट के नाम, सभी Google Cloud प्रोजेक्ट में यूनीक होने चाहिए. इनमें आपके संगठन के बाहर के प्रोजेक्ट भी शामिल हैं.

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

अगर आपकी बकेट पहले से मौजूद नहीं है, तो Cloud Storage बकेट बनाने के लिए, नीचे दिए गए सेल को चलाएं.

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

इसके बाद, नीचे दिए गए सेल को चलाकर, Cloud Storage बकेट के ऐक्सेस की पुष्टि की जा सकती है.

#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"

6. पाइपलाइन बनाना

अब हम Vertex AI का इस्तेमाल करके, ट्रेनिंग पाइपलाइन बनाना शुरू कर सकते हैं. हम Vertex AI SDK को शुरू करेंगे, ट्रेनिंग के काम को पाइपलाइन कॉम्पोनेंट के तौर पर सेट अप करेंगे, पाइपलाइन बनाएंगे, पाइपलाइन रन सबमिट करेंगे, और एक्सपेरिमेंट देखने और उनकी स्थिति पर नज़र रखने के लिए Vertex AI SDK का इस्तेमाल करेंगे.

पहला चरण: Vertex AI SDK टूल को शुरू करना

Vertex AI SDK टूल को शुरू करें. इसके लिए, PROJECT_ID और BUCKET_URI सेट करें.

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

दूसरा चरण: ट्रेनिंग जॉब को पाइपलाइन कॉम्पोनेंट के तौर पर सेट अप करना

एक्सपेरिमेंट शुरू करने के लिए, हमें अपने ट्रेनिंग जॉब के बारे में बताना होगा. इसके लिए, हमें इसे पाइपलाइन कॉम्पोनेंट के तौर पर तय करना होगा. हमारी पाइपलाइन, ट्रेनिंग डेटा और हाइपरपैरामीटर (जैसे, DROPOUT_RATE, LEARNING_RATE, EPOCHS) को इनपुट के तौर पर लेगी. साथ ही, मॉडल मेट्रिक (जैसे, MAE और RMSE) और मॉडल आर्टफ़ैक्ट को आउटपुट के तौर पर दिखाएगी.

क्या आपको यह जानना है कि पाइपलाइन और अन्य तरह के मॉडल के बाहर, Vertex AI Experiments का इस्तेमाल कैसे किया जा सकता है? इस सैंपल को देखें. इसमें बताया गया है कि स्थानीय तौर पर ट्रेन किए गए मॉडल को कैसे आज़माया जा सकता है (स्थानीय तौर पर ट्रेन किए गए मॉडल की तुलना करने का उदाहरण देखें.)

@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)

पांचवां चरण: एक्सपेरिमेंट देखने के लिए, Vertex AI SDK का इस्तेमाल करना

Vertex AI SDK की मदद से, पाइपलाइन रन की स्थिति को मॉनिटर किया जा सकता है. इसका इस्तेमाल, Vertex AI Experiment में पाइपलाइन रन के पैरामीटर और मेट्रिक दिखाने के लिए भी किया जा सकता है. अपनी रन से जुड़े पैरामीटर और उसकी मौजूदा स्थिति देखने के लिए, इस कोड का इस्तेमाल करें.

# see state/status of all the pipeline runs

vertex_ai.get_experiment_df(EXPERIMENT_NAME)

Python के लिए Vertex AI SDK, फ़िलहाल get_experiment_df तरीके के साथ काम करता है. इससे आपके रन के बारे में जानकारी मिलती है. इसका इस्तेमाल, Pipelinejob के अन्य तरीकों के साथ किया जा सकता है, ताकि पाइपलाइन से जुड़ी नौकरियों के बारे में जानकारी मिल सके. सबमिट करने के बाद, रन होने में सिर्फ़ ~5 मिनट या उससे कम समय लगना चाहिए.

पाइपलाइन रन की स्थिति के बारे में अपडेट पाने के लिए, यहां दिया गया कोड इस्तेमाल करें.

#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())

आखिर में, सेट किए गए इंटरवल (जैसे, हर 60 सेकंड) पर अपने रन की स्थिति को रीफ़्रेश किया जा सकता है. इससे, आपको स्थितियों में RUNNING से FAILED या COMPLETE में बदलाव दिखेगा.

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

7. सबसे अच्छी परफ़ॉर्म करने वाली रन की पहचान करना

बहुत बढ़िया, अब हमारे पास पाइपलाइन रन के नतीजे हैं. आपके मन में यह सवाल आ सकता है कि मुझे नतीजों से क्या सीखने को मिल सकता है? आपके एक्सपेरिमेंट के आउटपुट में पांच लाइनें होनी चाहिए. हर लाइन, पाइपलाइन के एक रन के लिए होनी चाहिए. यह कुछ इस तरह दिखेगा:

MAE और RMSE, दोनों ही मॉडल की अनुमानित वैल्यू में हुई औसत गड़बड़ी को मेज़र करते हैं. इसलिए, ज़्यादातर मामलों में दोनों मेट्रिक की वैल्यू कम होना बेहतर होता है. Vertex AI Experiments के आउटपुट के आधार पर, हम देख सकते हैं कि दोनों मेट्रिक के हिसाब से हमारा सबसे सफल रन, आखिरी रन था. इसमें dropout_rate 0.001, learning_rate 0.001, और epochs की कुल संख्या 20 थी. इस एक्सपेरिमेंट के आधार पर, इन मॉडल पैरामीटर का इस्तेमाल प्रोडक्शन में किया जाएगा. ऐसा इसलिए, क्योंकि इससे मॉडल की परफ़ॉर्मेंस सबसे अच्छी होती है.

अब आपने यह लैब पूरी कर ली है!

🎉 बधाई हो! 🎉

आपने Vertex AI का इस्तेमाल करके ये काम करने का तरीका सीखा है:

• खिलाड़ी की रेटिंग का अनुमान लगाने के लिए, कस्टम Keras मॉडल को ट्रेन करें (जैसे, रिग्रेशन)
• स्केल की जा सकने वाली एमएल पाइपलाइन बनाने के लिए, Kubeflow Pipelines SDK का इस्तेमाल करना
• पाँच चरणों वाली पाइपलाइन बनाएं और उसे चलाएं. यह पाइपलाइन, GCS से डेटा लेती है, डेटा को स्केल करती है, मॉडल को ट्रेन करती है, उसका आकलन करती है, और नतीजे के तौर पर मिले मॉडल को वापस GCS में सेव करती है
• मॉडल और मॉडल मेट्रिक जैसे मॉडल आर्टफ़ैक्ट सेव करने के लिए, Vertex ML Metadata का इस्तेमाल करें
• अलग-अलग पाइपलाइन रन के नतीजों की तुलना करने के लिए, Vertex AI Experiments का इस्तेमाल करना

Vertex के अलग-अलग हिस्सों के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.

8. साफ़-सफ़ाई सेवा

इसलिए, हमारा सुझाव है कि आप इस लैब में बनाए गए संसाधनों को मिटा दें, ताकि आपसे शुल्क न लिया जाए.

पहला चरण: Notebooks इंस्टेंस को रोकना या मिटाना

अगर आपको इस लैब में बनाई गई नोटबुक का इस्तेमाल जारी रखना है, तो हमारा सुझाव है कि इस्तेमाल न करने पर इसे बंद कर दें. Cloud Console में Notebooks के यूज़र इंटरफ़ेस (यूआई) में जाकर, नोटबुक चुनें. इसके बाद, बंद करें को चुनें. अगर आपको इंस्टेंस को पूरी तरह से मिटाना है, तो मिटाएं को चुनें:

दूसरा चरण: Cloud Storage बकेट मिटाना

स्टोरेज बकेट को मिटाने के लिए, Cloud Console में नेविगेशन मेन्यू का इस्तेमाल करके, स्टोरेज पर जाएं. इसके बाद, अपनी बकेट चुनें और मिटाएं पर क्लिक करें: