این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.

از آزمایش حداکثر استفاده را ببرید: آزمایش‌های یادگیری ماشین را با Vertex AI مدیریت کنید

1. بررسی اجمالی

در این آزمایشگاه، از Vertex AI برای ایجاد خط لوله ای استفاده می کنید که یک مدل Keras سفارشی را در TensorFlow آموزش می دهد. سپس از عملکرد جدید موجود در Vertex AI Experiments برای ردیابی و مقایسه اجراهای مدل استفاده خواهیم کرد تا تشخیص دهیم کدام ترکیبی از فراپارامترها بهترین عملکرد را دارند.

چیزی که یاد می گیرید

شما یاد خواهید گرفت که چگونه:

آموزش یک مدل Keras سفارشی برای پیش‌بینی رتبه‌بندی بازیکنان (به عنوان مثال، رگرسیون)
از Kubeflow Pipelines SDK برای ساخت خطوط لوله ML مقیاس پذیر استفاده کنید
یک خط لوله 5 مرحله‌ای ایجاد و اجرا کنید که داده‌ها را از فضای ذخیره‌سازی ابری دریافت می‌کند، داده‌ها را مقیاس‌بندی می‌کند، مدل را آموزش می‌دهد، آن را ارزیابی می‌کند و مدل حاصل را دوباره در فضای ذخیره‌سازی ابری ذخیره می‌کند.
از Vertex ML Metadata برای ذخیره مصنوعات مدل مانند Models و Model Metrics استفاده کنید
از آزمایش‌های هوش مصنوعی Vertex برای مقایسه نتایج اجرای خطوط لوله مختلف استفاده کنید

کل هزینه اجرای این آزمایشگاه در Google Cloud حدود 1 دلار است.

2. مقدمه ای بر Vertex AI

این آزمایشگاه از جدیدترین محصول هوش مصنوعی موجود در Google Cloud استفاده می کند. Vertex AI پیشنهادات ML را در سراسر Google Cloud در یک تجربه توسعه یکپارچه ادغام می کند. پیش از این، مدل‌های آموزش دیده با AutoML و مدل‌های سفارشی از طریق سرویس‌های جداگانه قابل دسترسی بودند. پیشنهاد جدید هر دو را به همراه سایر محصولات جدید در یک API واحد ترکیب می کند. همچنین می توانید پروژه های موجود را به Vertex AI منتقل کنید.

Vertex AI شامل بسیاری از محصولات مختلف برای پشتیبانی از گردش کار ML سرتاسر است. این آزمایشگاه بر روی محصولات برجسته شده در زیر تمرکز خواهد کرد: آزمایش‌ها ، خطوط لوله ، فراداده ML و میز کار

نمای کلی محصول Vertex

3. از Case Overview استفاده کنید

ما از یک مجموعه داده محبوب فوتبال استفاده خواهیم کرد که از سری بازی های ویدیویی FIFA EA Sports تهیه شده است. این شامل بیش از 25000 مسابقه فوتبال و 10000+ بازیکن برای فصول 2008-2016 است. داده‌ها از قبل پردازش شده‌اند تا بتوانید راحت‌تر به زمین برسید. شما از این مجموعه داده در سراسر آزمایشگاه استفاده خواهید کرد که اکنون می توانید آن را در یک سطل عمومی Cloud Storage پیدا کنید. ما جزئیات بیشتری را بعداً در نرم افزار کد در مورد نحوه دسترسی به مجموعه داده ارائه خواهیم داد. هدف نهایی ما این است که امتیاز کلی یک بازیکن را بر اساس اقدامات مختلف در بازی مانند مهار و پنالتی پیش بینی کنیم.

چرا Vertex AI Experiments برای Data Science مفید است؟

علم داده ماهیتی تجربی دارد - به هر حال آنها را دانشمندان می نامند. دانشمندان داده خوب فرضیه محور هستند و از آزمون و خطا برای آزمایش فرضیه های مختلف استفاده می کنند با این امید که تکرارهای متوالی منجر به مدلی کارآمدتر شود.

در حالی که تیم های علم داده آزمایش را پذیرفته اند، آنها اغلب برای پیگیری کار خود و "سس مخفی" که از طریق تلاش های آزمایشی آنها کشف شده است، تلاش می کنند. این به چند دلیل اتفاق می افتد:

ردیابی مشاغل آموزشی می تواند دست و پا گیر شود و به راحتی از چشم آنچه که کار می کند در مقابل آنچه که نیست، غافل شود.
این مشکل زمانی تشدید می‌شود که به یک تیم علم داده نگاه می‌کنید، زیرا ممکن است همه اعضا آزمایش‌ها را ردیابی یا حتی نتایج خود را با دیگران به اشتراک نگذارند.
جمع‌آوری داده‌ها زمان‌بر است و اکثر تیم‌ها از روش‌های دستی (مثلاً برگه‌ها یا اسناد) استفاده می‌کنند که منجر به اطلاعات ناسازگار و ناقص برای یادگیری می‌شود.

tl;dr: Vertex AI Experiments کار را برای شما انجام می دهد و به شما کمک می کند تا آزمایشات خود را به راحتی ردیابی و مقایسه کنید.

چرا آزمایش‌های هوش مصنوعی Vertex برای بازی؟

بازی از لحاظ تاریخی زمین بازی برای یادگیری ماشین و آزمایشات ML بوده است. بازی‌ها نه تنها میلیاردها رویداد بلادرنگ در روز تولید می‌کنند، بلکه از تمام این داده‌ها با استفاده از آزمایش‌های ML و ML برای بهبود تجربیات درون بازی، حفظ بازیکنان و ارزیابی بازیکنان مختلف در پلتفرم خود استفاده می‌کنند. از این رو ما فکر کردیم که مجموعه داده بازی به خوبی با تمرین کلی آزمایش ما مطابقت دارد.

4. محیط خود را تنظیم کنید

برای اجرای این کد لبه به یک پروژه Google Cloud Platform با فعال بودن صورتحساب نیاز دارید. برای ایجاد یک پروژه، دستورالعمل های اینجا را دنبال کنید.

مرحله 1: Compute Engine API را فعال کنید

به Compute Engine بروید و اگر قبلاً فعال نشده است Enable را انتخاب کنید.

مرحله ۲: Vertex AI API را فعال کنید

به بخش Vertex AI در Cloud Console خود بروید و روی Enable Vertex AI API کلیک کنید.

داشبورد Vertex AI

مرحله 3: یک نمونه Vertex AI Workbench ایجاد کنید

از بخش Vertex AI در Cloud Console خود، روی Workbench کلیک کنید:

اگر قبلاً API Notebooks وجود ندارد، آن را فعال کنید.

Notebook_api

پس از فعال شدن، روی دفترچه یادداشت مدیریت شده کلیک کنید:

Notebooks_UI

سپس NEW NOTEBOOK را انتخاب کنید.

نوت بوک

نوت بوک خود را نامی بگذارید و سپس روی تنظیمات پیشرفته کلیک کنید.

create_notebook

در قسمت تنظیمات پیشرفته، خاموش شدن بی‌حرکت را فعال کنید و تعداد دقیقه‌ها را روی 60 دقیقه تنظیم کنید. این بدان معناست که نوت بوک شما در صورت عدم استفاده به طور خودکار خاموش می‌شود تا هزینه‌های غیرضروری متحمل نشوید.

idle_timeout

مرحله 4: نوت بوک خود را باز کنید

پس از ایجاد نمونه، Open JupyterLab را انتخاب کنید.

open_jupyterlab

مرحله 5: احراز هویت (فقط برای اولین بار)

اولین باری که از یک نمونه جدید استفاده می کنید، از شما خواسته می شود که احراز هویت کنید. برای انجام این کار مراحل موجود در UI را دنبال کنید.

احراز هویت

مرحله 6: هسته مناسب را انتخاب کنید

نوت‌بوک‌های مدیریت‌شده چندین هسته را در یک رابط کاربری ارائه می‌کنند. هسته را برای Tensorflow 2 (محلی) انتخاب کنید.

tensorflow_kernel

5. مراحل راه اندازی اولیه در نوت بوک شما

قبل از ساخت خط لوله خود، باید یک سری مراحل اضافی را برای تنظیم محیط خود در نوت بوک خود انجام دهید. این مراحل عبارتند از: نصب هر بسته اضافی، تنظیم متغیرها، ایجاد سطل ذخیره سازی ابری شما، کپی کردن مجموعه داده بازی از یک سطل ذخیره سازی عمومی، و وارد کردن کتابخانه ها و تعریف ثابت های اضافی.

مرحله 1: بسته های اضافی را نصب کنید

ما نیاز به نصب وابستگی های بسته اضافی داریم که در حال حاضر در محیط نوت بوک شما نصب نشده اند. یک مثال شامل 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)

مرحله 2: متغیرها را تنظیم کنید

ما می خواهیم PROJECT_ID خود را تعریف کنیم. اگر Project_ID خود را نمی دانید، ممکن است بتوانید PROJECT_ID خود را با استفاده از gcloud دریافت کنید.

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

مرحله 3: یک سطل ذخیره سازی ابری ایجاد کنید

شما باید یک سطل مرحله‌بندی 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}"

اگر سطل شما از قبل وجود ندارد، می توانید سلول زیر را برای ایجاد سطل ذخیره سازی ابری خود اجرا کنید.

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

سپس می توانید با اجرای سلول زیر دسترسی به سطل فضای ذخیره سازی ابری خود را تأیید کنید.

#verify access 
! gsutil ls -al $BUCKET_URI

مرحله 4: مجموعه داده بازی ما را کپی کنید

همانطور که قبلا ذکر شد، شما از یک مجموعه داده بازی محبوب از بازی های ویدیویی موفق 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

مرحله 5: کتابخانه ها را وارد کنید و ثابت های اضافی را تعریف کنید

در مرحله بعد می خواهیم کتابخانه های خود را برای 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 برای مشاهده آزمایش ها و نظارت بر وضعیت آنها استفاده می کنیم.

مرحله 1: Vertex AI SDK را راه اندازی کنید

Vertex AI SDK را راه‌اندازی کنید، PROJECT_ID و BUCKET_URI خود را تنظیم کنید.

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

مرحله 2: کار آموزشی خود را به عنوان یک جزء خط لوله تنظیم کنید

برای شروع آزمایش های خود، باید کار آموزشی خود را با تعریف آن به عنوان یک جزء خط لوله مشخص کنیم. خط لوله ما داده ها و فراپارامترهای آموزشی (به عنوان مثال، DROPOUT_RATE ، LEARNING_RATE ، EPOCHS ) را به عنوان معیارهای مدل ورودی و خروجی (مانند MAE و RMSE ) و یک مصنوع مدل در نظر می گیرد.

@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

مرحله 3: خط لوله خود را بسازید

اکنون گردش کار خود را با استفاده از Domain Specific Language (DSL) موجود در KFP تنظیم می کنیم و خط لوله خود را در یک فایل 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")

مرحله 4: اجرای خط لوله (های) خود را ارسال کنید

کار سخت برای راه اندازی مولفه و تعریف خط لوله ما انجام شده است. ما آماده هستیم تا اجراهای مختلفی از خط لوله را که در بالا مشخص کردیم ارسال کنیم. برای انجام این کار، باید مقادیری را برای هایپرپارامترهای مختلف خود به صورت زیر تعریف کنیم:

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)

مرحله 5: از Vertex AI SDK برای مشاهده آزمایش ها استفاده کنید

Vertex AI SDK به شما امکان می دهد وضعیت اجرای خط لوله را نظارت کنید. همچنین می توانید از آن برای برگرداندن پارامترها و معیارهای Pipeline Runs در Vertex AI Experiment استفاده کنید. از کد زیر برای مشاهده پارامترهای مرتبط با اجراهای خود و وضعیت فعلی آن استفاده کنید.

# see state/status of all the pipeline runs

vertex_ai.get_experiment_df(EXPERIMENT_NAME)

می توانید از کد زیر برای دریافت به روز رسانی در مورد وضعیت اجرای خط لوله خود استفاده کنید.

#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 مشاهده کنیم که موفق‌ترین اجرای ما در هر دو معیار، اجرای نهایی با dropout_rate 0.001، learning_rate اگر 0.001 است، و تعداد کل epochs 20 است. بر اساس این آزمایش، این مدل‌ها پارامترها در نهایت در تولید استفاده خواهند شد زیرا بهترین عملکرد مدل را به همراه دارد.

با آن، شما آزمایشگاه را به پایان رساندید!

🎉 تبریک می گویم! 🎉

شما یاد گرفته اید که چگونه از Vertex AI برای موارد زیر استفاده کنید:

آموزش یک مدل Keras سفارشی برای پیش‌بینی رتبه‌بندی بازیکنان (به عنوان مثال، رگرسیون)
از Kubeflow Pipelines SDK برای ساخت خطوط لوله ML مقیاس پذیر استفاده کنید
یک خط لوله 5 مرحله ای ایجاد و اجرا کنید که داده ها را از GCS دریافت می کند، داده ها را مقیاس بندی می کند، مدل را آموزش می دهد، آن را ارزیابی می کند و مدل حاصل را دوباره در GCS ذخیره می کند.
از Vertex ML Metadata برای ذخیره مصنوعات مدل مانند Models و Model Metrics استفاده کنید
از آزمایش‌های هوش مصنوعی Vertex برای مقایسه نتایج اجرای خطوط لوله مختلف استفاده کنید

برای کسب اطلاعات بیشتر در مورد بخش های مختلف Vertex، مستندات را بررسی کنید.

8. پاکسازی

برای اینکه هزینه ای از شما دریافت نشود، توصیه می شود منابع ایجاد شده در سراسر این آزمایشگاه را حذف کنید.

مرحله 1: نمونه Notebook خود را متوقف یا حذف کنید

اگر می‌خواهید به استفاده از نوت‌بوکی که در این آزمایشگاه ایجاد کرده‌اید ادامه دهید، توصیه می‌شود در صورت عدم استفاده آن را خاموش کنید. از رابط کاربری Notebooks در Cloud Console، نوت بوک را انتخاب کنید و سپس Stop را انتخاب کنید. اگر می خواهید نمونه را به طور کامل حذف کنید، حذف را انتخاب کنید:

توقف نمونه

مرحله 2: سطل Cloud Storage خود را حذف کنید

برای حذف Storage Bucket، با استفاده از منوی Navigation در Cloud Console خود، به Storage بروید، سطل خود را انتخاب کنید و روی Delete کلیک کنید:

ذخیره سازی را حذف کنید