1. Genel Bakış
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.
Öğrenecekleriniz
Öğrenecekleriniz:
- Özel tahmin rutinleriyle özel tahmin mantığı yazma
- Özel sunum container'ını ve modeli yerel olarak test etme
- Vertex AI Predictions'de özel sunma kapsayıcısını test etme
Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 1 ABD doları.
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 deneyiminde birleştirir. Daha önce, AutoML ile eğitilen modellere ve özel modellere ayrı hizmetler üzerinden erişilebiliyordu. Yeni teklif, diğer yeni ürünlerle birlikte her ikisini de tek bir API'de birleştirir. Mevcut projeleri Vertex AI'a da 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'e odaklanacağız.
3. Kullanım Alanına Genel Bakış
Kullanım Örneği
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.
Sunma zamanındaki verilerin model tarafından beklenen 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şlem mantığı da yazarsınız. Bu mantığı yazmak için özel tahmin rutinlerini kullanırsı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 yapılmadan önce girişi ön işleme almak veya sonucu döndürmeden önce modelin tahminini son işleme almak istiyorsanız özel bir kapsayıcı oluşturmanız gerekir.
Özel bir yayınlama 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 rutinleri sayesinde sunumla ilgili bileşenleri sizin için sağlar. Böylece modelinize ve veri dönüşümlerinize odaklanabilirsiniz.
4. Ortamınızı ayarlama
Bu kod laboratuvarını çalıştırmak için faturalandırmanın etkin olduğu bir Google Cloud Platform projeniz olmalıdır. Proje oluşturmak için buradaki talimatları uygulayın.
1. Adım: Compute Engine API'yi etkinleştirin
Compute Engine'a gidin ve etkin değilse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için bu anahtara ihtiyacınız vardır.
2. Adım: Artifact Registry API'yi etkinleştirin
Artifact Registry'ye gidin ve henüz etkinleştirilmediyse Etkinleştir'i seçin. Özel bir yayınlama kapsayıcısı oluşturmak için bunu kullanırsınız.
3. Adım: Vertex AI API'yi etkinleştirin
Cloud Console'un Vertex AI bölümüne gidip Enable Vertex AI API'yi (Vertex AI API'yi etkinleştir) tıklayın.
4. Adım: Vertex AI Workbench örneği oluşturun
Cloud Console'unuzun Vertex AI bölümünden Workbench'i tıklayın:
Henüz etkinleştirilmediyse Notebooks API'yi etkinleştirin.
Etkinleştirildikten sonra ÖRNEKLER'i tıklayın ve YENİ OLUŞTUR'u seçin.
Varsayılan seçenekleri kabul edin ve Oluştur'u tıklayın.
Örnek hazır olduğunda JUPYTERLAB'İ AÇ'ı tıklayarak örneği açın.
5. Eğitim kodu yazma
1. adım: 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 paketiniz varsa bu adımı atlayabilirsiniz.
Başlatıcıdan yeni bir terminal oturumu açın.
Projeniz için bir env değişkeni tanımlamak üzere terminalinizde aşağıdaki komutu çalıştırın. your-cloud-project yerine projenizin kimliğini yazın:
PROJECT_ID='your-cloud-project'
Ardından, projenizde yeni bir paket oluşturmak için Terminal'de aşağıdakileri çalıştırın.
BUCKET="gs://${PROJECT_ID}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET
2. Adım: Modeli eğitin
Terminalden cpr-codelab adında yeni bir dizin oluşturun ve cd'ye yapıştırın.
mkdir cpr-codelab
cd cpr-codelab
Dosya gezgininde yeni cpr-codelab dizine gidin ve ardından başlatıcıyı kullanarak task.ipynb adlı yeni bir Python 3 not defteri oluşturun.
cpr-codelab dizininiz artık şöyle görünecektir:
+ cpr-codelab/
+ task.ipynb
Aşağıdaki kodu not defterine yapıştırın.
Öncelikle bir requirements.txt dosyası yazın.
%%writefile requirements.txt
fastapi
uvicorn==0.17.6
joblib~=1.0
numpy~=1.20
scikit-learn>=1.2.2
pandas
google-cloud-storage>=1.26.0,<2.0.0dev
google-cloud-aiplatform[prediction]>=1.16.0
Dağıttığınız modelde, not defteri ortamınızdan farklı bir ön yüklü bağımlılık grubu bulunur. Bu nedenle, modelin tüm bağımlılıklarını requirements.txt içinde listelemeniz ve ardından not defterine tam olarak aynı bağımlılıkları yüklemek için pip kullanmanız gerekir. Daha sonra, ortamların eşleştiğini tekrar kontrol etmek için modeli Vertex AI'a dağıtmadan önce yerel olarak test edersiniz.
Not defterindeki bağımlılıkları pip ile yükleyin.
!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 şöyle görünecektir:
+ 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ğ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 kısmını proje kimliğinizle, BUCKET_NAME kısmını da ö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}"
Verileri seaborn kitaplığından yükleyin ve ardından biri özelliklere, diğeri etikete sahip iki veri kümesi 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 olduğunu görebilirsiniz.
x_train.head()
Ve etiketler, yani karşılık gelen fiyatlar.
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(), [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 beslenen verilerin önce kodlanacağı/ölçekleneceği ve ardından modele aktarılacağı 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)
Modelin beklendiği gibi çalıştığından emin olmak için deneyelim. Test örneğini göndererek modelde 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 kaydedebilir ve 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ısını kaydedin
Şimdi, bir ön işleme yapısı oluşturacaksınız. Bu yapı, model sunucusu açıldığında özel kapsayıcıya yüklenir. Ön işleme yapınızın biçimi neredeyse her şey olabilir (ör. pickle dosyası), ancak bu durumda bir JSON dosyasına bir sözlük yazarsı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 clarity özelliği her zaman kısaltılmış biçimdeydi (ör. "kusursuz" yerine "kusursuz"). Yayınlama sırasında bu özelliğe ait verilerin de kısaltıldığını kontrol etmek isteriz. 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 kaydedip 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 şu şekilde görünecektir:
+ cpr-codelab/
+ model_artifacts/
+ model.joblib
+ preprocessor.json
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
6. CPR model sunucusunu kullanarak özel bir sunma kapsayıcısı oluşturma
Model eğitildiğine ve ön işleme yapıtı kaydedildiğine göre özel sunma kapsayıcısını oluşturma zamanı geldi. Genellikle bir yayınlama kapsayıcısı oluşturmak için model sunucu kodu 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, SDK tarafından otomatik olarak oluşturulur ve
scr_dir/içinde depolanır)- Modeli barındıran HTTP sunucusu
- Rota/bağlantı noktası/vb. kurulumundan sorumludur
- İstek işleyici
- İsteği işlemeyle ilgili web sunucusu yönlerinden (ör. istek gövdesini serileştirme, yanıtı serileştirme, yanıt başlıklarını ayarlama vb.) sorumludur.
- Bu örnekte, SDK'da sağlanan varsayılan işleyiciyi (
google.cloud.aiplatform.prediction.handler.PredictionHandler) kullanacaksınız.
- Tahmin aracı
- Tahmin isteğini işleme konusundaki ML mantığından sorumludur.
Bu bileşenlerin her biri, kullanım alanınızın gereksinimlerine göre özelleştirilebilir. Bu örnekte yalnızca tahmin edebilirsiniz.
Tahminci, özel ön işleme ve son işleme gibi bir tahmin isteğini işleme konusundaki ML mantığından sorumludur. Özel tahmin mantığı yazmak için Vertex AI Predictor arayüzünü alt sınıfa alırsınız.
Özel tahmin rutinlerinin bu sürümü, yeniden kullanılabilir XGBoost ve Sklearn tahmincileriyle birlikte gelir ancak farklı bir çerçeve kullanmanız gerekiyorsa temel tahmincinin alt sınıfını oluşturarak kendi tahmincinizi oluşturabilirsiniz.
Sklearn öngörücüsünün bir örneğini aşağıda görebilirsiniz. Bu özel model sunucusunu oluşturmak için yazmanız gereken tüm kod budur.
SklearnPredictor sınıfını alt sınıfa ayırmak için aşağıdaki kodu not defterinize yapıştırın ve src_dir/ içindeki bir Python dosyasına yazın. Bu örnekte predict yöntemini değil, yalnızca load, preprocess ve postprocess 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 birini daha ayrıntılı olarak inceleyelim.
loadyöntemi, ön işleme yapısını yükler. Bu yapı, bu durumda elmas netliği değerlerini kısaltmalarıyla eşleyen bir sözlüktür.preprocessyöntemi, netlik özelliğinin yayınlanma zamanında kısaltılmış biçimde olmasını sağlamak için bu yapıyı kullanır. Aksi takdirde, dizenin tamamını kısaltmasına dönüştürür.postprocessyöntemi, tahmini değeri $ işareti içeren bir dize olarak döndürür ve değeri yuvarlar.
Ardından, resmi oluşturmak için Vertex AI Python SDK'sını kullanın. Özel tahmin rutinleri kullanılarak Dockerfile oluşturulur ve görüntü sizin için derlenir.
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. Biri kısaltılmış netlik adına sahip 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
7. Modeli Vertex AI'a dağıtma
Container'ı yerel olarak test ettiğinize göre, görüntüyü Artifact Registry'ye aktarma ve modeli Vertex AI Model Registry'ye yükleme zamanı geldi.
Ö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 gösterilir:
Ardından, online tahminler için kullanabileceğiniz şekilde modeli 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.
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! 🎉
Aşağıdakiler için Vertex AI'ı nasıl kullanacağınızı öğrendiniz:
- Özel tahmin rutinleriyle özel ön işleme ve son işleme mantığı yazma
Vertex AI'ın farklı bölümleri hakkında daha fazla bilgi edinmek için belgelere göz atın.
8. Temizleme
Bu laboratuvarda oluşturduğunuz not defterini kullanmaya devam etmek istiyorsanız, kullanmadığınız not defterini kapatmanız önerilir. Google Cloud Console'daki Workbench kullanıcı arayüzünde not defterini ve ardından Durdur'u seçin.
Not defterini tamamen silmek istiyorsanız sağ üstteki Sil düğmesini tıklayın.
Dağıttığınız uç noktayı silmek için konsolun Uç Noktalar bölümüne gidin, oluşturduğunuz uç noktayı tıklayın ve ardından Modeli uç noktadan kaldır'ı seçin:
Kapsayıcı görüntüsünü silmek için Artifact Registry'ye gidin, oluşturduğunuz deposu seçin ve Sil'i seçin.
Depolama paketini silmek için Cloud Console'unuzdaki Gezinme menüsünü kullanarak Depolama'ya gidin, paketinizi seçin ve Sil'i tıklayın:
