1. Giriş
Bu laboratuvarda, özel ön işleme ve son işleme mantığı yazmak için Vertex AI'da özel tahmin rutinlerini nasıl kullanacağınızı öğreneceksiniz. Bu örnekte Scikit-learn kullanılsa da özel tahmin rutinleri XGBoost, PyTorch ve TensorFlow gibi diğer Python ML çerçeveleriyle çalışabilir.
Neler öğreneceksiniz?
- Özel tahmin rutinleriyle özel tahmin mantığı yazma
- Özel sunum container'ını ve modeli yerel olarak test etme
- Özel sunma container'ını Vertex AI Predictions'da test etme
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 Tahminler ve Workbench üzerinde durulacaktır.
3. Kullanım Alanına Genel Bakış
Bu laboratuvarda, kesim, berraklık ve boyut gibi özelliklere göre bir elmasın fiyatını tahmin etmek için rastgele orman regresyon modeli oluşturacaksınız.
Hizmet aşamasındaki verilerin modelin beklediği biçimde olup olmadığını kontrol etmek için özel ön işleme mantığı yazarsınız. Ayrıca tahminleri yuvarlamak ve dizelere dönüştürmek için özel bir son işleme mantığı da yazacaksınız. Bu mantığı yazmak için özel tahmin rutinlerini kullanacaksınız.
Özel tahmin rutinlerine giriş
Vertex AI önceden oluşturulmuş kapsayıcıları, makine öğrenimi çerçevesinin tahmin işlemini gerçekleştirerek tahmin isteklerini işler. Özel tahmin rutinlerinden önce, tahmin gerçekleştirilmeden önce girişi önceden işlemek veya sonucu döndürmeden önce modelin tahminini sonradan işlemek istiyorsanız özel bir kapsayıcı oluşturmanız gerekirdi.
Özel bir yayın kapsayıcısı oluşturmak için eğitilmiş modeli sarmalayan, HTTP isteklerini model girişlerine ve model çıkışlarını yanıtlara çeviren bir HTTP sunucusu yazmanız gerekir.
Vertex AI, özel tahmin rutinleriyle sunmayla ilgili bileşenleri sizin için sağlar. Böylece modelinize ve veri dönüşümlerinize odaklanabilirsiniz.
Ne oluşturacaksınız?
Aşağıdaki Şekil 1'de gösterildiği gibi, kullanıcı tarafından yönetilen bir not defterini dağıtmak ve us-central1'de dağıtılan online tahmin ve model uç noktasına erişmek için kullanılan bir iş istasyonu alt ağından oluşan aiml-vpc adlı bir VPC ağı oluşturacaksınız.
Figure1
4. Eğitim API'lerini etkinleştirme
1. adım: Compute Engine API'yi etkinleştirin
Compute Engine'e gidin ve etkin değilse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için bu bilgiye ihtiyacınız vardır.
2. adım: Artifact Registry API'yi etkinleştirin
Artifact Registry'ye gidin ve henüz etkinleştirilmemişse Etkinleştir'i seçin. Bunu, özel bir yayın container'ı oluşturmak için kullanırsınız.
3. 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.
4. adım: Vertex AI Workbench örneği oluşturun
Henüz etkinleştirilmemişse Notebooks API'yi etkinleştirin.
5. aiml-vpc'yi oluşturun
Bu eğitimde, Cloud Shell'de gcloud yapılandırmasının uygulanmasına yardımcı olmak için $değişkenleri kullanılır.
Cloud Shell'de aşağıdakileri yapın:
gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid
aiml-vpc'yi oluşturma
Cloud Shell'de aşağıdakileri yapın:
gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom
Kullanıcı tarafından yönetilen not defteri alt ağı oluşturma
Cloud Shell'de workbench-subnet'i oluşturun.
gcloud compute networks subnets create workbench-subnet --project=$projectid --range=172.16.10.0/28 --network=aiml-vpc --region=us-central1 --enable-private-ip-google-access
Cloud Router ve NAT yapılandırması
Kullanıcı tarafından yönetilen not defterinde harici IP adresi olmadığından, yazılım paketlerini indirmek için eğitimde Cloud NAT kullanılır. Cloud NAT, çıkış NAT özellikleri sağlar. Bu nedenle, internet ana makinelerinin kullanıcı tarafından yönetilen bir not defteriyle iletişimi başlatmasına izin verilmez. Bu da Cloud NAT'i daha güvenli hale getirir.
Cloud Shell'de bölgesel Cloud Router'ı (us-central1) oluşturun.
gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1
Cloud Shell'de bölgesel Cloud NAT ağ geçidi olan us-central1'i oluşturun.
gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1-aiml-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1
6. Kullanıcı tarafından yönetilen not defterini oluşturma
Kullanıcı tarafından yönetilen hizmet hesabı (Notebook) oluşturma
Aşağıdaki bölümde, eğitimde kullanılan Vertex Workbench (Notebook) ile ilişkilendirilecek kullanıcı tarafından yönetilen bir hizmet hesabı oluşturacaksınız.
Eğitimde, hizmet hesabına aşağıdaki kurallar uygulanır:
Cloud Shell'de hizmet hesabını oluşturun.
gcloud iam service-accounts create user-managed-notebook-sa \
--display-name="user-managed-notebook-sa"
Cloud Shell'de hizmet hesabını Storage Admin rolüyle güncelleyin.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"
Cloud Shell'de hizmet hesabını Vertex AI Kullanıcısı rolüyle güncelleyin.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"
Cloud Shell'de hizmet hesabını Artifact Registry Yöneticisi rolüyle güncelleyin.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"
Cloud Shell'de hizmet hesabını listeleyin ve kullanıcı tarafından yönetilen not defteri oluşturulurken kullanılacak e-posta adresini not edin.
gcloud iam service-accounts list
Kullanıcı tarafından yönetilen not defterini oluşturma
Aşağıdaki bölümde, daha önce oluşturulan hizmet hesabını (user-managed-notebook-sa) içeren, kullanıcı tarafından yönetilen bir not defteri oluşturun.
Cloud Shell'de private-client örneğini oluşturun.
gcloud notebooks instances create workbench-tutorial \
--vm-image-project=deeplearning-platform-release \
--vm-image-family=common-cpu-notebooks \
--machine-type=n1-standard-4 \
--location=us-central1-a \
--shielded-secure-boot \
--subnet-region=us-central1 \
--subnet=workbench-subnet \
--no-public-ip --service-account=user-managed-notebook-sa@$projectid.iam.gserviceaccount.com
7. Eğitim kodu yazma
1. adım: Cloud Storage paketi oluşturun
Modeli ve ön işleme yapılarını bir Cloud Storage paketinde saklarsınız. Projenizde kullanmak istediğiniz bir paketiniz varsa bu adımı atlayabilirsiniz.
Başlatıcıdan yeni bir terminal oturumu açın.
Terminalinizde, projeniz için bir ortam değişkeni tanımlamak üzere aşağıdakileri çalıştırın. your-cloud-project kısmını projenizin kimliğiyle değiştirmeyi unutmayın:
PROJECT_ID='your-cloud-project'
Ardından, projenizde yeni bir paket oluşturmak için Terminal'inizde aşağıdakileri çalıştırın.
BUCKET="gs://${PROJECT_ID}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET
2. adım: Modeli eğitme
Terminalden cpr-codelab adlı yeni bir dizin oluşturun ve bu dizine gidin.
mkdir cpr-codelab
cd cpr-codelab
Dosya tarayıcısında yeni cpr-codelab dizinine gidin ve başlatıcıyı kullanarak task.ipynb adlı yeni bir Python 3 not defteri oluşturun.
cpr-codelab dizininiz artık şu şekilde görünmelidir:
+ cpr-codelab/
+ task.ipynb
Not defterine aşağıdaki kodu yapıştırın.
Öncelikle requirements.txt dosyası yazın.
%%writefile requirements.txt
fastapi
uvicorn==0.17.6
joblib~=1.1.1
numpy>=1.17.3, <1.24.0
scikit-learn~=1.0.0
pandas
google-cloud-storage>=2.2.1,<3.0.0dev
google-cloud-aiplatform[prediction]>=1.18.2
Dağıttığınız modelde, not defteri ortamınızdan farklı bir dizi önceden yüklenmiş bağımlılık bulunur. Bu nedenle, modelin tüm bağımlılıklarını requirements.txt dosyasında listelemeniz ve ardından pip'i kullanarak aynı bağımlılıkları not defterine yüklemeniz gerekir. Daha sonra, ortamların eşleştiğinden emin olmak için modeli Vertex AI'a dağıtmadan önce yerel olarak test edeceksiniz.
Pip, bağımlılıkları not defterine yükler.
!pip install -U --user -r requirements.txt
pip yükleme işlemi tamamlandıktan sonra çekirdeği yeniden başlatmanız gerektiğini unutmayın.
Ardından, modeli ve ön işleme yapılarını depolayacağınız dizinleri oluşturun.
USER_SRC_DIR = "src_dir"
!mkdir $USER_SRC_DIR
!mkdir model_artifacts
# copy the requirements to the source dir
!cp requirements.txt $USER_SRC_DIR/requirements.txt
cpr-codelab dizininiz artık şu şekilde görünmelidir:
+ cpr-codelab/
+ model_artifacts/
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
Dizin yapısı ayarlandığına göre artık bir modeli eğitme zamanı!
Öncelikle kitaplıkları içe aktarın.
import seaborn as sns
import numpy as np
import pandas as pd
from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import make_pipeline
from sklearn.compose import make_column_transformer
import joblib
import logging
# set logging to see the docker container logs
logging.basicConfig(level=logging.INFO)
Ardından aşağıdaki değişkenleri tanımlayın. PROJECT_ID'yi proje kimliğinizle, BUCKET_NAME'i ise önceki adımda oluşturduğunuz paketle değiştirdiğinizden emin olun.
REGION = "us-central1"
MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
REPOSITORY = "diamonds"
IMAGE = "sklearn-image"
MODEL_DISPLAY_NAME = "diamonds-cpr"
# Replace with your project
PROJECT_ID = "{PROJECT_ID}"
# Replace with your bucket
BUCKET_NAME = "gs://{BUCKET_NAME}"
Seaborn kitaplığındaki verileri yükleyin ve ardından biri özelliklerin, diğeri de etiketin bulunduğu iki veri çerçevesi oluşturun.
data = sns.load_dataset('diamonds', cache=True, data_home=None)
label = 'price'
y_train = data['price']
x_train = data.drop(columns=['price'])
Eğitim verilerine göz atalım. Her satırın bir elması temsil ettiğini görebilirsiniz.
x_train.head()
Ayrıca, karşılık gelen fiyatlar olan etiketler.
y_train.head()
Şimdi, kategorik özellikleri tek seferlik kodlamak ve sayısal özellikleri ölçeklendirmek için bir sklearn sütun dönüşümü tanımlayın.
column_transform = make_column_transformer(
(preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
(preprocessing.StandardScaler(), [0,4,5,6,7,8]))
Rastgele orman modelini tanımlama
regr = RandomForestRegressor(max_depth=10, random_state=0)
Ardından, sklearn ardışık düzeni oluşturun. Bu, bu işlem hattına aktarılan verilerin önce kodlanacağı/ölçeklendirileceği ve ardından modele aktarılacağı anlamına gelir.
my_pipeline = make_pipeline(column_transform, regr)
Ardışık düzeni eğitim verilerine uyarlama
my_pipeline.fit(x_train, y_train)
Beklendiği gibi çalıştığından emin olmak için modeli deneyelim. Modele bir test örneği ileterek predict yöntemini çağırın.
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
Artık ardışık düzeni model_artifacts dizinine kaydedip Cloud Storage paketine kopyalayabiliriz.
joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
!gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
3. adım: Ön işleme yapıtı kaydedin
Ardından bir ön işleme yapısı oluşturursunuz. Bu yapay nesne, model sunucusu başlatıldığında özel kapsayıcıya yüklenir. Ön işleme yapıtınız neredeyse her biçimde olabilir (ör. pickle dosyası). Ancak bu durumda, bir sözlüğü JSON dosyasına yazacaksınız.
clarity_dict={"Flawless": "FL",
"Internally Flawless": "IF",
"Very Very Slightly Included": "VVS1",
"Very Slightly Included": "VS2",
"Slightly Included": "S12",
"Included": "I3"}
Eğitim verilerimizdeki netlik özelliği her zaman kısaltılmış biçimdeydi (ör. "Kusursuz" yerine "KSZ"). Yayın sırasında, bu özelliğin verilerinin de kısaltılmış olmasını istiyoruz. Bunun nedeni, modelimizin "FL"yi tek sıcak kodlamayı bilmesi ancak "Flawless"ı bilmemesidir. Bu özel ön işleme mantığını daha sonra yazacaksınız. Ancak şimdilik bu arama tablosunu bir JSON dosyasına kaydedin ve ardından Cloud Storage paketine yazın.
import json
with open("model_artifacts/preprocessor.json", "w") as f:
json.dump(clarity_dict, f)
!gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
Yerel cpr-codelab dizininiz artık şöyle görünmelidir:
+ cpr-codelab/
+ model_artifacts/
+ model.joblib
+ preprocessor.json
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
8. CPR model sunucusunu kullanarak özel bir yayın container'ı oluşturma
Model eğitildiğine ve ön işleme yapıtı kaydedildiğine göre artık özel sunum container'ını oluşturabilirsiniz. Genellikle bir yayın kapsayıcısı oluşturmak için model sunucusu kodu yazılması gerekir. Ancak özel tahmin rutinleriyle Vertex AI Predictions, bir model sunucusu oluşturur ve sizin için özel bir kapsayıcı resmi oluşturur.
Özel bir yayın container'ı aşağıdaki 3 kod parçasını içerir:
- Model sunucusu (Bu, SDK tarafından otomatik olarak oluşturulur ve scr_dir/ içinde saklanır.)
- Modeli barındıran HTTP sunucusu
- Rotaları/bağlantı noktalarını vb. ayarlamaktan sorumludur.
- İstek gövdesinin seri durumdan çıkarma ve yanıtın seri hale getirme, yanıt başlıklarını ayarlama gibi bir isteği işleme ile ilgili web sunucusu yönlerinden sorumludur.
- Bu örnekte, SDK'da sağlanan varsayılan işleyici google.cloud.aiplatform.prediction.handler.PredictionHandler'ı kullanacaksınız.
- Tahmin isteğini işleme için makine öğrenimi mantığından sorumludur.
Bu bileşenlerin her biri, kullanım alanınızın gereksinimlerine göre özelleştirilebilir. Bu örnekte yalnızca tahmin ediciyi uygulayacaksınız.
Tahminci, özel ön işleme ve son işleme gibi bir tahmin isteğinin işlenmesiyle ilgili makine öğrenimi mantığından sorumludur. Özel tahmin mantığı yazmak için Vertex AI Predictor arayüzünü alt sınıfa ayırmanız gerekir.
Özel tahmin rutinlerinin bu sürümünde yeniden kullanılabilir XGBoost ve Sklearn tahmin edicileri bulunur. Ancak farklı bir çerçeve kullanmanız gerekiyorsa temel tahmin ediciyi alt sınıfa ayırarak kendi tahmin edicinizi oluşturabilirsiniz.
Sklearn tahmincisi örneğini aşağıda görebilirsiniz. Bu özel model sunucusunu oluşturmak için yazmanız gereken kodun tamamı budur.
SklearnPredictor'ı alt sınıfa ayırmak ve src_dir/ dizinindeki bir Python dosyasına yazmak için aşağıdaki kodu not defterinize yapıştırın. Bu örnekte yalnızca yükleme, ön işleme ve son işleme yöntemlerinin özelleştirildiğini, tahmin yönteminin özelleştirilmediğini unutmayın.
%%writefile $USER_SRC_DIR/predictor.py
import joblib
import numpy as np
import json
from google.cloud import storage
from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor
class CprPredictor(SklearnPredictor):
def __init__(self):
return
def load(self, artifacts_uri: str) -> None:
"""Loads the sklearn pipeline and preprocessing artifact."""
super().load(artifacts_uri)
# open preprocessing artifact
with open("preprocessor.json", "rb") as f:
self._preprocessor = json.load(f)
def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
"""Performs preprocessing by checking if clarity feature is in abbreviated form."""
inputs = super().preprocess(prediction_input)
for sample in inputs:
if sample[3] not in self._preprocessor.values():
sample[3] = self._preprocessor[sample[3]]
return inputs
def postprocess(self, prediction_results: np.ndarray) -> dict:
"""Performs postprocessing by rounding predictions and converting to str."""
return {"predictions": [f"${value}" for value in np.round(prediction_results)]}
Şimdi bu yöntemlerin her birini daha ayrıntılı olarak inceleyelim.
- Yükleme yöntemi, ön işleme yapıtını yükler. Bu yapıt, elmas berraklığı değerlerini kısaltmalarına eşleyen bir sözlüktür.
- Ön işleme yöntemi, yayın sırasında netlik özelliğinin kısaltılmış biçimde olmasını sağlamak için bu yapıyı kullanır. Aksi takdirde, tam dize kısaltmasına dönüştürülür.
- Postprocess yöntemi, tahmin edilen değeri $ işaretiyle birlikte bir dize olarak döndürür ve değeri yuvarlar.
Ardından, görüntüyü oluşturmak için Vertex AI Python SDK'sını kullanın. Özel tahmin rutinleri kullanıldığında Dockerfile oluşturulur ve sizin için bir görüntü oluşturulur.
from google.cloud import aiplatform
aiplatform.init(project=PROJECT_ID, location=REGION)
import os
from google.cloud.aiplatform.prediction import LocalModel
from src_dir.predictor import CprPredictor # Should be path of variable $USER_SRC_DIR
local_model = LocalModel.build_cpr_model(
USER_SRC_DIR,
f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
predictor=CprPredictor,
requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
)
Tahmin için iki örnek içeren bir test dosyası yazın. Örneklerden birinde kısaltılmış netlik adı var ancak diğerinin önce dönüştürülmesi gerekiyor.
import json
sample = {"instances": [
[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
[0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
with open('instances.json', 'w') as fp:
json.dump(sample, fp)
Yerel bir model dağıtarak kapsayıcıyı yerel olarak test edin.
with local_model.deploy_to_local_endpoint(
artifact_uri = 'model_artifacts/', # local path to artifacts
) as local_endpoint:
predict_response = local_endpoint.predict(
request_file='instances.json',
headers={"Content-Type": "application/json"},
)
health_check_response = local_endpoint.run_health_check()
Tahmin sonuçlarını şu şekilde görebilirsiniz:
predict_response.content
9. Modeli Vertex AI'da dağıtma
Container'ı yerel olarak test ettiğinize göre artık görüntüyü Artifact Registry'ye aktarabilir ve modeli Vertex AI Model Registry'ye yükleyebilirsiniz.
Öncelikle Docker'ı Artifact Registry'ye erişecek şekilde yapılandırın.
!gcloud artifacts repositories create {REPOSITORY} --repository-format=docker \
--location=us-central1 --description="Docker repository"
!gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet
Ardından görüntüyü gönderin.
local_model.push_image()
Ardından modeli yükleyin.
model = aiplatform.Model.upload(local_model = local_model,
display_name=MODEL_DISPLAY_NAME,
artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)
Model yüklendiğinde konsolda görünür:
Ardından, modeli online tahminler için kullanabilmek üzere dağıtın. Özel tahmin rutinleri, toplu tahminle de çalışır. Bu nedenle, kullanım alanınız online tahmin gerektirmiyorsa modeli dağıtmanız gerekmez.
Ardından görüntüyü gönderin.
endpoint = model.deploy(machine_type="n1-standard-2")
Son olarak, tahmin alarak dağıtılan modeli test edin.
endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])
🎉 Tebrikler! 🎉
Vertex AI'ı kullanarak şunları yapmayı öğrendiniz:
- Özel tahmin rutinleriyle özel ön işleme ve son işleme mantığı yazma
Cosmopup, codelab'lerin harika olduğunu düşünüyor.
Yapabilecekleriniz
Daha fazla bilgi ve videolar
- Vertex AI nedir?
- Vertex AI'ı kullanmaya başlama
- Vertex AI'daki hangi yapay zeka/makine öğrenimi çözümü benim için uygun?
- Vertex AI ile soru-cevap sistemi oluşturma