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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 सेक्शन में, वर्कबेंच पर क्लिक करें:

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

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

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

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

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

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

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

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

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

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

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

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

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

पहला चरण: दूसरे पैकेज इंस्टॉल करें

हमें ऐसी अतिरिक्त पैकेज डिपेंडेंसी इंस्टॉल करनी होगी जो आपके notebook के एनवायरमेंट में फ़िलहाल इंस्टॉल नहीं हैं. उदाहरण के लिए, 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 टूल को शुरू करना

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

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

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

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

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

@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 Experience में पाइपलाइन रन के पैरामीटर और मेट्रिक दिखाने के लिए भी किया जा सकता है. अपनी दौड़ और उसकी मौजूदा स्थिति से जुड़े पैरामीटर देखने के लिए, नीचे दिए गए कोड का इस्तेमाल करें.

# see state/status of all the pipeline runs

vertex_ai.get_experiment_df(EXPERIMENT_NAME)

फ़िलहाल, Python के लिए Vertex AI SDK टूल, 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())

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

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

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

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

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

इसके साथ ही, आपने लैब खत्म कर लिया है!

🎉 बधाई हो! 🎉

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

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

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

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

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

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

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

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

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