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 örnek Scikit-learn kullanırken ö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
- Vertex AI Predictions'da özel sunum container'ını test etme
2. Vertex AI'a giriş
Bu laboratuvarda, Google Cloud'daki en yeni AI ürün teklifi kullanılmaktadır. Vertex AI, Google Cloud'daki makine öğrenimi tekliflerini sorunsuz bir geliştirme deneyimiyle entegre eder. Önceden, AutoML ve özel modellerle eğitilen modellere ayrı hizmetler üzerinden erişilebiliyordu. Yeni teklif, her ikisi de tek bir API'de ve diğer yeni ürünlerle birleştirilir. Dilerseniz mevcut projeleri Vertex AI'a taşıyabilirsiniz.
Vertex AI, uçtan uca makine öğrenimi iş akışlarını destekleyen birçok farklı ürün içerir. Bu laboratuvar, Predictions ve Workbench'e odaklanmaktadır.
3. Kullanım Alanına Genel Bakış
Bu laboratuvarda kesim, netlik ve boyut gibi özelliklere dayanarak bir elmasın fiyatını tahmin etmek için rastgele bir orman regresyon modeli oluşturacaksınız.
Sunum sırasında verilerin modelin beklediği biçimde olup olmadığını kontrol etmek için özel bir ön işleme mantığı yazacaksınız. Ayrıca, tahminleri yuvarlamak ve dizelere dönüştürmek için özel bir son işleme mantığı yazacaksınız. Bu mantığı yazmak için özel tahmin rutinleri kullanırsınız.
Özel tahmin rutinlerine giriş
Önceden oluşturulmuş Vertex AI container'ları, makine öğrenimi çerçevesinin tahmin işlemini gerçekleştirerek tahmin isteklerini yönetir. Ö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 isterseniz özel bir container oluşturmanız gerekir.
Özel bir sunum kapsayıcısı oluşturmak için eğitilen modeli sarmalayan, HTTP isteklerini model girişlerine çeviren ve model çıkışlarını yanıtlara çeviren bir HTTP sunucusu yazılması gerekir.
Vertex AI, özel tahmin rutinleri sayesinde sunumla ilgili bileşenleri sizin için sağlar. Böylece modelinize ve veri dönüşümlerinize odaklanabilirsiniz.
Oluşturacaklarınız
Kullanıcı tarafından yönetilen not defterini dağıtmak ve us-central1'de dağıtılan online tahmin ile model uç noktasına erişmek için kullanılan aiml-vpc adında bir VPC ağı oluşturacaksınız. Bu ağ, aşağıdaki şekilde 1. şekilde gösterilmiştir.
Figure1
4. Eğitim API'lerini etkinleştir
1. Adım: Compute Engine API'yi etkinleştirin
Compute Engine'e gidin ve zaten etkinleştirilmemişse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için buna ihtiyacınız olacaktı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. Özel bir sunum kapsayıcısı oluşturmak için bunu kullanacaksınız.
3. Adım: Vertex AI API'yi etkinleştirin
Cloud Console'un Vertex AI bölümüne gidip Vertex AI API'yi etkinleştir'i tıklayın.
4. Adım: Vertex AI Workbench örneği oluşturun
Etkin durumda değilse Notebooks API'yi etkinleştirin.
5. aiml-vpc'yi oluşturma
Bu eğiticide, Cloud Shell'de gcloud yapılandırması uygulamasına yardımcı olmak için $variables kullanımı açıklanmaktadır.
Cloud Shell'in içinde aşağıdaki işlemleri gerçekleştirin:
gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid
aiml-vpc'yi oluşturma
Cloud Shell'in içinde aşağıdaki işlemleri gerçekleştirin:
gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom
Kullanıcı tarafından yönetilen not defteri alt ağını oluşturma
Cloud Shell'in içinde workbench alt ağını 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 Yönlendirici ve NAT yapılandırması
Kullanıcı tarafından yönetilen not defterinin harici IP adresi olmadığından, eğitimde yazılım paketlerini indirmek için Cloud NAT kullanılır. Cloud NAT, çıkış NAT özellikleri sunar. Bu nedenle, internet ana makinelerinin kullanıcı tarafından yönetilen bir not defteriyle iletişim başlatmasına izin verilmez. Bu sayede not defteri daha güvenli hale gelir.
Cloud Shell'in içinde us-central1 adlı bölgesel bulut yönlendiricisini oluşturun.
gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1
Cloud Shell'in içinde us-central1 adlı bölgesel bulut nat ağ geçidini 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ı oluşturma (Not defteri)
Aşağıdaki bölümde, eğitimde kullanılan Vertex Workbench (Notebook) ile ilişkilendirilecek kullanıcı tarafından yönetilen hizmet hesabı oluşturacaksınız.
Eğiticide, hizmet hesabına aşağıdaki kurallar uygulanır:
Cloud Shell'in içinde hizmet hesabını oluşturun.
gcloud iam service-accounts create user-managed-notebook-sa \
--display-name="user-managed-notebook-sa"
Cloud Shell'in içinde, hizmet hesabını Depolama Alanı 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/storage.admin"
Cloud Shell'in içinde 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'in içinde 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 defterini oluştururken 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, önceden oluşturulmuş hizmet hesabını (user-managed-notebook-sa) içeren, kullanıcı tarafından yönetilen bir not defteri oluşturun.
Cloud Shell'in içinde özel istemci ö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 kodunu yazma
1. Adım: Bir Cloud Storage paketi oluşturun
Modeli ve ön işleme yapılarını bir Cloud Storage paketinde depolayacaksınız. Projenizde kullanmak istediğiniz bir paket zaten varsa bu adımı atlayabilirsiniz.
Başlatıcıdan yeni bir terminal oturumu açın.
Terminalinizde projeniz için bir env değişkeni tanımlamak üzere aşağıdaki komutu çalıştırın. Bunun için Cloud projenizi, projenizin kimliğiyle değiştirin:
PROJECT_ID='your-cloud-project'
Ardından projenizde yeni bir paket oluşturmak için aşağıdaki komutu Terminal'de çalıştırın.
BUCKET="gs://${PROJECT_ID}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET
2. Adım: Modeli eğitin
Terminalde cpr-codelab adında yeni bir dizin oluşturun ve cd'ye yapıştırın.
mkdir cpr-codelab
cd cpr-codelab
Dosya tarayıcısında yeni cpr-codelab dizinine gidin, ardından başlatıcıyı kullanarak görev.ipynb adında yeni bir Python 3 not defteri oluşturun.
cpr-codelab dizininiz artık şu şekilde görünmelidir:
+ cpr-codelab/
+ task.ipynb
Aşağıdaki kodu not defterine yapıştırın.
Öncelikle birrequirements.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 önceden yüklenmiş farklı bağımlılıklar bulunur. Bu nedenle, gereklilikler.txt dosyasında modelin tüm bağımlılıklarını listelemek, sonra da pip kullanarak not defterine tam olarak aynı bağımlılıkları yüklemek isteyebilirsiniz. Ardından, ortamların eşleştiğinden emin olmak için Vertex AI'a dağıtmadan önce modeli 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ı oluşturulduğuna göre artık bir model eğitmenin zamanı geldi.
İlk olarak 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)
Daha sonra aşağıdaki değişkenleri tanımlayın. PROJECT_ID kısmını proje kimliğinizle ve BUCKET_NAME projesini de bir ö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}"
Deniz doğumu kitaplığından verileri yükleyip ardından biri özelliklere, diğeri de etikete sahip 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()
İlgili fiyatlar olan etiketler.
y_train.head()
Şimdi, kategorik özellikleri kodlamak ve sayısal özellikleri ölçeklendirmek için bir sklearn sütun dönüşümü değerini 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 bir sklearn ardışık düzeni oluşturun. Bu, bu ardışık düzene aktarılan verilerin önce kodlanacağı/ölçileceği ve ardından modele iletileceği anlamına gelir.
my_pipeline = make_pipeline(column_transform, regr)
Ardışık düzeni eğitim verilerine sığdırma
my_pipeline.fit(x_train, y_train)
Beklendiği gibi çalıştığından emin olmak için modeli deneyelim. Bir test örneğinden geçirerek modelde tahmin 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: Bir ön işleme yapısını kaydedin
Şimdi, bir ön işleme yapısı oluşturacaksınız. Bu yapı, model sunucusu başlatıldığında özel container'a yüklenir. Ön işleme yapısınız hemen hemen her biçimde (ör. turşu dosyası) olabilir. Ancak bu durumda, bir JSON dosyasına bir sözlük 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 "FL"). Yayın sırasında, bu özelliğe ait verilerin de kısaltılmış olup olmadığını kontrol etmek istiyoruz. Bunun nedeni, modelimizin "FL"yi sıcak bir şekilde nasıl kodlayacağını bilmesidir. Ancak "Kusursuz" değil. Bu özel ön işleme mantığını daha sonra yazacaksınız. Ancak şimdilik bu arama tablosunu bir json dosyasına kaydedip Cloud Storage paketine yazmanız yeterlidir.
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 şu şekilde 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 sunum container'ı oluşturma
Model eğitilip ön işleme yapısının kaydedildiğine göre şimdi özel sunum container'ını derleme zamanı geldi. Genel olarak bir sunum kapsayıcısı oluşturmak için model sunucu kodunun yazılması gerekir. Bununla birlikte, Vertex AI Predictions özel tahmin rutinleri ile bir model sunucusu oluşturur ve sizin için özel bir container görüntüsü hazırlar.
Özel bir sunum kapsayıcısı aşağıdaki 3 kod parçasını içerir:
- Model sunucusu (bu kod SDK tarafından otomatik olarak oluşturulur ve scr_dir/ konumunda saklanır)
- Modeli barındıran HTTP sunucusu
- Rota/bağlantı noktası vb. kurulumundan sorumludur
- İstek gövdesinin serisini kaldırma, yanıtı serileştirme, yanıt başlıklarını ayarlama gibi istekleri ele almayla ilgili web sunucusu yönlerinden sorumludur.
- Bu örnekte, SDK'da sağlanan varsayılan işleyici olan google.cloud.aiplatform.prediction.handler.EstimateionHandler'ı kullanacaksınız.
- Tahmin isteğinin işlenmesi 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 tahminciyi uygulayacaksınız.
Tahmin aracı, özel ön işleme ve son işleme gibi tahmin isteklerinin işlenmesi için ML mantığından sorumludur. Özel tahmin mantığı yazmak için Vertex AI Tahminci arayüzünü alt sınıfa gireceksiniz.
Bu özel tahmin rutinleri sürümü, yeniden kullanılabilir XGBoost ve Sklearn tahmincileri içerir. Ancak farklı bir çerçeve kullanmanız gerekirse temel tahmin ediciyi alt sınıflandırarak kendi çerçevenizi oluşturabilirsiniz.
Aşağıda Sklearn tahmin edici için bir örnek görebilirsiniz. Bu özel model sunucusunu oluşturmak için yazmanız gereken tüm kod budur.
SklearnEstimateor'ı alt sınıflandırmak için aşağıdaki kodu not defterinize yapıştırın ve bunu src_dir/ dizinindeki bir Python dosyasına yazın. Bu örnekte tahmin yöntemini değil, yalnızca yükleme, ön işlem ve işlem sonrası yöntemlerini özelleştirdiğimizi 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)]}
Bu yöntemlerin her birine daha yakından bakalım.
- Yükleme yöntemi, ön işleme yapısında yüklenir. Bu yapı, bu örnekte elmas netliği değerlerini kısaltmalarıyla eşleyen bir sözlüktür.
- Ön işlem yöntemi, yayınlama sırasında netlik özelliğinin kısaltılmış biçimde olmasını sağlamak için bu yapıyı kullanır. Aksi takdirde, tüm dizeyi kısaltmasına dönüştürür.
- PostProcess yöntemi, tahmin edilen değeri $ işareti içeren 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'yı kullanın. Özel tahmin rutinleri kullanılarak Dockerfile oluşturulur ve sizin için bir görüntü hazırlanır.
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ı yazma. Örneklerden biri kısaltılmış netlik adına sahip, ancak önce diğerinin 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 model dağıtarak container'ı 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'a dağıtma
Container'ı yerel olarak test ettiğinize göre şimdi görüntüyü Artifact Registry'ye aktarıp modeli Vertex AI Model Registry'ye yükleyin.
Ö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 resmi aktarın.
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 bunu görürsünüz:
Ardından, online tahminlerde kullanabilmeniz için modeli dağıtın. Özel tahmin rutinleri toplu tahmin ile de çalışır. Bu nedenle, kullanım alanınız online tahmin gerektirmiyorsa modeli dağıtmanız gerekmez.
Ardından resmi aktarın.
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ı öğrendiniz:
- Özel tahmin rutinleriyle özel ön işleme ve son işleme mantığı yazma
Cosmopup, codelab'lerin muhteşem olduğunu düşünüyor!!
Sırada ne var?
Daha fazla bilgi ve Videolar
- Vertex AI nedir?
- Vertex AI'ı kullanmaya başlama
- Vertex AI'daki bana uygun yapay zeka/makine öğrenimi çözümü hangisi?
- Vertex AI ile soru yanıtlama sistemi geliştirme