1. Genel Bakış
Bu laboratuvarda, TensorFlow'da özel bir Keras modeli eğiten bir ardışık düzen oluşturmak için Vertex AI'ı kullanacaksınız. Daha sonra, hangi hiperparametre kombinasyonunun en iyi performansı sağladığını belirlemek için Vertex AI Experiments'te bulunan yeni işlevleri kullanarak model çalıştırmalarını izleyip karşılaştıracağız.
Öğrenecekleriniz
Öğrenecekleriniz:
- Oyuncu puanlarını tahmin etmek için özel bir Keras modeli eğitme (ör. regresyon)
- Ölçeklenebilir makine öğrenimi ardışık düzenleri oluşturmak için Kubeflow Pipelines SDK'yı kullanma
- Cloud Storage'dan veri alan, verileri ölçeklendiren, modeli eğiten, değerlendiren ve sonuçtaki modeli tekrar Cloud Storage'a kaydeden 5 adımlı bir ardışık düzen oluşturup çalıştırma
- Modeller ve model metrikleri gibi model yapılarını kaydetmek için Vertex ML Metadata'dan yararlanma
- Çeşitli ardışık düzen çalıştırmalarının sonuçlarını karşılaştırmak için Vertex AI Experiments'i kullanma
Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 1 ABD dolarıdır.
2. Vertex AI'a giriş
Bu laboratuvarda, Google Cloud'da sunulan en yeni yapay zeka ürünü kullanılmaktadır. Vertex AI, Google Cloud'daki makine öğrenimi tekliflerini sorunsuz bir geliştirme deneyimi için entegre eder. Daha önce, AutoML ile eğitilmiş modeller ve özel modeller ayrı hizmetler üzerinden erişilebiliyordu. Yeni teklif, diğer yeni ürünlerle birlikte bu iki ürünü tek bir API'de birleştirir. Mevcut projeleri de Vertex AI'a taşıyabilirsiniz.
Vertex AI, uçtan uca makine öğrenimi iş akışlarını desteklemek için birçok farklı ürün içerir. Bu laboratuvarda aşağıdaki ürünler üzerinde durulacaktır: Experiments, Pipelines, ML Metadata ve Workbench
3. Kullanım Alanına Genel Bakış
EA Sports'un FIFA video oyunu serisinden alınan popüler bir futbol veri kümesini kullanacağız. 2008-2016 sezonlarına ait 25.000'den fazla futbol maçı ve 10.000'den fazla oyuncu içerir. Veriler önceden işlendiği için daha kolay bir başlangıç yapabilirsiniz. Bu veri kümesini laboratuvar boyunca kullanacaksınız. Veri kümesi artık herkese açık bir Cloud Storage paketinde bulunuyor. Veri kümesine erişme hakkında daha fazla bilgiyi ilerleyen bölümlerde paylaşacağız. Nihai hedefimiz, oyuncunun genel puanını top çalma ve penaltı gibi çeşitli oyun içi işlemlere göre tahmin etmektir.
Vertex AI Experiments, veri bilimi için neden faydalıdır?
Veri bilimi deneysel bir alandır. Bu alanda çalışanlara bilim insanı denmesinin nedeni de budur. İyi veri bilimciler, hipotez odaklıdır. Çeşitli hipotezleri test etmek için deneme yanılma yöntemini kullanır ve ardışık yinelemelerin daha iyi performans gösteren bir modelle sonuçlanacağını umar.
Veri bilimi ekipleri denemeleri benimsemiş olsa da genellikle çalışmalarını ve deneme çalışmalarıyla ortaya çıkarılan "sihirli formülü" takip etmekte zorlanırlar. Bunun birkaç nedeni vardır:
- Eğitim işlerinin takibi zorlaşabilir ve neyin işe yarayıp neyin yaramadığını anlamak güçleşebilir.
- Bu sorun, tüm üyeler deneyleri izlemeyebileceği veya sonuçlarını başkalarıyla paylaşmayabileceği için bir veri bilimi ekibine bakıldığında daha da artar.
- Veri yakalama zaman alıcıdır ve çoğu ekip, öğrenmek için tutarsız ve eksik bilgilerle sonuçlanan manuel yöntemlerden (ör.sayfalar veya dokümanlar) yararlanır.
tl;dr: Vertex AI Experiments, denemelerinizi daha kolay izlemenize ve karşılaştırmanıza yardımcı olarak işi sizin için yapar.
Oyun için Vertex AI Experiments'ın avantajları
Oyunlar, geçmişte makine öğrenimi ve ML denemeleri için bir oyun alanı olmuştur. Oyunlar yalnızca günde milyarlarca gerçek zamanlı etkinlik üretmekle kalmaz, aynı zamanda oyun içi deneyimleri iyileştirmek, oyuncuları elde tutmak ve platformlarındaki farklı oyuncuları değerlendirmek için makine öğrenimi ve makine öğrenimi denemelerinden yararlanarak bu verilerin tamamını kullanır. Bu nedenle, genel deneysel çalışmamıza bir oyun veri kümesinin iyi uyacağını düşündük.
4. Ortamınızı ayarlama
Bu codelab'i çalıştırmak için faturalandırmanın etkin olduğu bir Google Cloud Platform projesine ihtiyacınız vardır. Proje oluşturmak için buradaki talimatları uygulayın.
1. adım: Compute Engine API'yi etkinleştirin
Compute Engine'e gidin ve henüz etkinleştirilmemişse Etkinleştir'i seçin.
2. adım: Vertex AI API'yi etkinleştirin
Cloud Console'unuzun Vertex AI bölümüne gidin ve Vertex AI API'yi etkinleştir'i tıklayın.
3. adım: Vertex AI Workbench örneği oluşturma
Cloud Console'unuzun Vertex AI bölümünde Workbench'i tıklayın:
Henüz etkinleştirilmemişse Notebooks API'yi etkinleştirin.
Etkinleştirildikten sonra YÖNETİLEN NOT DEFTERLERİ'ni tıklayın:
Ardından YENİ NOT DEFTERİ'ni seçin.
Not defterinize bir ad verin ve Gelişmiş Ayarlar'ı tıklayın.
Gelişmiş Ayarlar'da boşta kalma durumunda kapatma özelliğini etkinleştirin ve süreyi 60 dakika olarak ayarlayın. Bu sayede, gereksiz maliyetlere yol açmamak için not defteriniz kullanılmadığında otomatik olarak kapatılır.
4. adım: Not defterinizi açın
Örnek oluşturulduktan sonra Open JupyterLab'i (JupyterLab'i aç) seçin.
5. adım: Kimlik doğrulama (yalnızca ilk kez)
Yeni bir örneği ilk kez kullandığınızda kimlik doğrulamanız istenir. Bunun için kullanıcı arayüzündeki adımları uygulayın.
6. adım: Uygun çekirdeği seçin
Yönetilen not defterleri, tek bir kullanıcı arayüzünde birden fazla çekirdek sağlar. Tensorflow 2 (yerel) için çekirdeği seçin.
5. Not defterinizdeki ilk kurulum adımları
İşlem hattınızı oluşturmadan önce not defterinizde ortamınızı ayarlamak için bir dizi ek adım uygulamanız gerekir. Bu adımlar arasında ek paketleri yükleme, değişkenleri ayarlama, bulut depolama paketinizi oluşturma, oyun veri kümesini herkese açık bir depolama paketinden kopyalama, kitaplıkları içe aktarma ve ek sabitleri tanımlama yer alır.
1. adım: Ek paketleri yükleyin
Şu anda not defteri ortamınızda yüklü olmayan ek paket bağımlılıklarını yüklememiz gerekecek. Örneğin, KFP SDK'sı.
!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts
Ardından, indirilen paketleri not defterinizde kullanabilmek için not defteri çekirdeğini yeniden başlatmanız gerekir.
# 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. adım: Değişkenleri ayarlayın
PROJECT_ID cihazımızı tanımlamak istiyoruz. Project_ID değerinizi bilmiyorsanız gcloud'u kullanarak PROJECT_ID değerinizi alabilirsiniz.
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)
Aksi halde PROJECT_ID öğesini buradan ayarlayın.
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
Bu not defterinin geri kalanında kullanılan REGION değişkenini de ayarlamak istiyoruz. Vertex AI'ın desteklendiği bölgeleri aşağıda bulabilirsiniz. Size en yakın bölgeyi seçmenizi öneririz.
- Kuzey ve Güney Amerika: us-central1
- Avrupa: europe-west4
- Asya Pasifik: asia-east1
Lütfen Vertex AI ile eğitim için çok bölgeli bir paket kullanmayın. Tüm bölgelerde tüm Vertex AI hizmetleri desteklenmez. Vertex AI bölgeleri hakkında daha fazla bilgi edinin.
#set your region
REGION = "us-central1" # @param {type: "string"}
Son olarak, bir TIMESTAMP değişkeni ayarlayacağız. Bu değişken, oluşturulan kaynaklarda kullanıcılar arasındaki ad çakışmalarını önlemek için kullanılır. Her örnek oturumu için bir TIMESTAMP oluşturur ve bunu bu eğitimde oluşturduğunuz kaynakların adına eklersiniz.
#set timestamp to avoid collisions between multiple users
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
3. adım: Cloud Storage paketi oluşturun
Bir Cloud Storage hazırlık paketi belirtmeniz ve kullanmanız gerekir. Hazırlama paketi, veri kümeniz ve model kaynaklarınızla ilişkili tüm verilerin oturumlar arasında saklandığı yerdir.
Cloud Storage paketinizin adını aşağıda ayarlayın. Paket adları, kuruluşunuzun dışındakiler de dahil olmak üzere tüm Google Cloud projelerinde global olarak benzersiz olmalıdır.
#set cloud storage bucket
BUCKET_NAME = "[insert bucket name here]" # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"
Paketiniz HALİHAZIRDA mevcut DEĞİLSE Cloud Storage paketinizi oluşturmak için aşağıdaki hücreyi çalıştırabilirsiniz.
! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI
Ardından aşağıdaki hücreyi çalıştırarak Cloud Storage paketinize erişimi doğrulayabilirsiniz.
#verify access
! gsutil ls -al $BUCKET_URI
4. adım: Oyun Veri Kümemizi kopyalayın
Daha önce de belirtildiği gibi, EA Sports'un popüler video oyunu FIFA'daki popüler bir oyun veri kümesinden yararlanacaksınız. Ön işleme çalışmasını sizin için yaptık. Bu nedenle, veri kümesini herkese açık depolama paketinden kopyalayıp oluşturduğunuz pakete taşımanız yeterlidir.
# 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. adım: Kitaplıkları içe aktarın ve ek sabitleri tanımlayın
Ardından, Vertex AI, KFP vb. için kitaplıklarımızı içe aktarmamız gerekir.
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
Ayrıca, not defterinin geri kalanında tekrar başvuracağımız ek sabitler(ör. eğitim verilerimizin dosya yolları) de tanımlayacağız.
#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. Ardışık Düzenimizi Oluşturalım
Artık eğlenceli kısma geçebilir ve eğitim ardışık düzenimizi oluşturmak için Vertex AI'dan yararlanmaya başlayabiliriz. Vertex AI SDK'yı başlatacak, eğitim işimizi bir ardışık düzen bileşeni olarak ayarlayacak, ardışık düzenimizi oluşturacak, ardışık düzen çalıştırmalarımızı gönderecek ve deneyleri görüntülemek ve durumlarını izlemek için Vertex AI SDK'dan yararlanacağız.
1. adım: Vertex AI SDK'yı başlatın
Vertex AI SDK'sını başlatın, PROJECT_ID ve BUCKET_URI değerlerini ayarlayın.
#initialize vertex AI SDK
vertex_ai.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)
2. adım: Eğitim işimizi bir ardışık düzen bileşeni olarak ayarlayın
Denemelerimizi çalıştırmaya başlamak için eğitim işimizi bir ardışık düzen bileşeni olarak tanımlayarak belirtmemiz gerekir. İşlem hattımız, giriş olarak eğitim verilerini ve hiperparametreleri (ör. DROPOUT_RATE, LEARNING_RATE, EPOCHS) alır ve çıkış olarak model metriklerini (ör. MAE ve RMSE) ve bir model yapıtı verir.
@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. adım: Satış hattımızı oluşturun
Şimdi KFP'de bulunan Domain Specific Language (DSL) kullanarak iş akışımızı kuracak ve ardışık düzenimizi JSON dosyasına derleyeceğiz.
# 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. adım: Ardışık düzen çalıştırmalarımızı gönderin
Bileşenimizi ayarlama ve ardışık düzenimizi tanımlama konusunda çok çalıştık. Yukarıda belirttiğimiz ardışık düzenin çeşitli çalıştırmalarını göndermeye hazırız. Bunu yapmak için farklı hiperparametrelerimizin değerlerini aşağıdaki gibi tanımlamamız gerekir:
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},
]
Hiperparametreler tanımlandıktan sonra, ardışık düzenin farklı çalıştırmalarını başarılı bir şekilde beslemek için for loop kullanabiliriz:
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. adım: Denemeleri görüntülemek için Vertex AI SDK'dan yararlanın
Vertex AI SDK, işlem hattı çalıştırmalarının durumunu izlemenize olanak tanır. Bu işlevi, Vertex AI denemesindeki ardışık düzen çalıştırmalarının parametrelerini ve metriklerini döndürmek için de kullanabilirsiniz. Çalıştırmalarınızla ilişkili parametreleri ve mevcut durumunu görmek için aşağıdaki kodu kullanın.
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
Aşağıdaki kodu kullanarak işlem hattı çalıştırmalarınızın durumuyla ilgili güncellemeler alabilirsiniz.
#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)
Ayrıca, run_name kullanarak belirli işlem hattı işlerini de çağırabilirsiniz.
# 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())
Son olarak, durumların RUNNING'dan FAILED veya COMPLETE'ye değiştiğini görmek için çalıştırmalarınızın durumunu belirli aralıklarla (ör. her 60 saniyede bir) yenileyebilirsiniz.
# wait 60 seconds and view state again
import time
time.sleep(60)
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
7. En İyi Performans Gösteren Koşuyu Belirleme
Harika, artık işlem hattı çalıştırmalarımızın sonuçlarını elde ettik. Sonuçlardan ne öğrenebilirim? diye soruyor olabilirsiniz. Denemelerinizin çıktısı beş satır içermelidir. Her satır, ardışık düzenin bir çalıştırmasına karşılık gelir. Şuna benzer bir şey görürsünüz:
Hem MAE hem de RMSE, ortalama model tahmin hatasının ölçüleri olduğundan çoğu durumda her iki metrik için de daha düşük bir değer istenir. Vertex AI Experiments'ın çıktısına göre, her iki metrikte de en başarılı çalıştırmamız 0,001 dropout_rate, 0,001 learning_rate ve toplam 20 epochs ile son çalıştırmaydı. Bu denemeye göre, en iyi model performansını sağladığı için bu model parametreleri nihayetinde üretimde kullanılacaktır.
Böylece laboratuvarı tamamladınız.
🎉 Tebrikler! 🎉
Vertex AI'ı kullanarak şunları yapmayı öğrendiniz:
- Oyuncu puanlarını tahmin etmek için özel bir Keras modeli eğitme (ör. regresyon)
- Ölçeklenebilir makine öğrenimi ardışık düzenleri oluşturmak için Kubeflow Pipelines SDK'yı kullanma
- GCS'den veri alan, verileri ölçeklendiren, modeli eğiten, değerlendiren ve sonuçta elde edilen modeli tekrar GCS'ye kaydeden 5 adımlı bir ardışık düzen oluşturup çalıştırma
- Modeller ve model metrikleri gibi model yapılarını kaydetmek için Vertex ML Metadata'dan yararlanma
- Çeşitli ardışık düzen çalıştırmalarının sonuçlarını karşılaştırmak için Vertex AI Experiments'i kullanma
Vertex'in farklı bölümleri hakkında daha fazla bilgi edinmek için belgelere göz atın.
8. Temizleme
Ücretlendirilmemek için bu laboratuvar boyunca oluşturulan kaynakları silmeniz önerilir.
1. adım: Not defteri örneğinizi durdurun veya silin
Bu laboratuvarda oluşturduğunuz not defterini kullanmaya devam etmek istiyorsanız kullanmadığınız zamanlarda kapatmanız önerilir. Cloud Console'daki Notebooks kullanıcı arayüzünde not defterini ve ardından Durdur'u seçin. Örneği tamamen silmek istiyorsanız Sil'i seçin:
2. adım: Cloud Storage paketinizi silin
Cloud Console'unuzdaki gezinme menüsünü kullanarak depolama paketini silmek için Storage'a gidin, paketinizi seçin ve Sil'i tıklayın:
