1. Genel Bakış
Bu laboratuvarda, Vertex Pipelines ile makine öğrenimi ardışık düzenleri oluşturmayı ve çalıştırmayı öğreneceksiniz.
Öğrenecekleriniz
Öğrenecekleriniz:
- Ölçeklenebilir makine öğrenimi ardışık düzenleri oluşturmak için Kubeflow Pipelines SDK'yı kullanma
- Metin girişi alan 3 adımlı bir tanıtım ardışık düzeni oluşturma ve çalıştırma
- Bir AutoML sınıflandırma modelini eğiten, değerlendiren ve dağıtan bir ardışık düzen oluşturma ve çalıştırma
google_cloud_pipeline_componentskitaplığı aracılığıyla sağlanan, Vertex AI hizmetleriyle etkileşim için önceden oluşturulmuş bileşenleri kullanma- Cloud Scheduler ile ardışık düzen işi planlama
Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 25 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, model eğitimi ve dağıtım hizmetlerinin yanı sıra Vertex Pipelines (bu laboratuvarın odak noktası), Model Monitoring ve Feature Store gibi çeşitli MLOps ürünlerini de içerir. Tüm Vertex AI ürün tekliflerini aşağıdaki şemada görebilirsiniz.
Geri bildiriminiz varsa lütfen destek sayfasına göz atın.
ML ardışık düzenleri neden yararlıdır?
Ayrıntılara geçmeden önce, neden bir işlem hattı kullanmak isteyebileceğinizi anlayalım. Veri işleme, model eğitimi, hiperparametre ayarlama, değerlendirme ve model dağıtımı gibi adımları içeren bir makine öğrenimi iş akışı oluşturduğunuzu düşünün. Bu adımların her birinin farklı bağımlılıkları olabilir. Bu da tüm iş akışını tek bir monolit olarak ele alırsanız yönetilmesi zor bir durum haline gelebilir. Makine öğrenimi sürecinizi ölçeklendirmeye başladığınızda, makine öğrenimi iş akışınızı ekibinizdeki diğer kullanıcılarla paylaşmak isteyebilirsiniz. Böylece bu kullanıcılar iş akışını çalıştırabilir ve kod katkısında bulunabilir. Güvenilir ve tekrarlanabilir bir süreç olmadan bu zor olabilir. İşlem hatlarında, makine öğrenimi sürecinizdeki her adım kendi kapsayıcısında yer alır. Bu sayede adımları bağımsız olarak geliştirebilir ve her adımdaki giriş ve çıkışı tekrarlanabilir şekilde izleyebilirsiniz. Ayrıca, yeni eğitim verileri kullanıma sunulduğunda ardışık düzen çalıştırması başlatmak gibi Cloud ortamınızdaki diğer etkinliklere göre ardışık düzeninizin çalıştırmalarını planlayabilir veya tetikleyebilirsiniz.
Özet: Ardışık düzenler, makine öğrenimi iş akışınızı otomatikleştirmenize ve yeniden oluşturmanıza yardımcı olur.
3. Bulut ortamı kurulumu
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: Cloud Shell'i başlatın
Bu laboratuvarda, Google'ın bulutunda çalışan bir sanal makine tarafından barındırılan bir komut yorumlayıcı olan Cloud Shell oturumunda çalışacaksınız. Bu bölümü kendi bilgisayarınızda yerel olarak da kolayca çalıştırabilirsiniz ancak Cloud Shell'i kullanmak, herkesin tutarlı bir ortamda tekrarlanabilir bir deneyime erişmesini sağlar. Laboratuvarın ardından bu bölümü kendi bilgisayarınızda tekrar deneyebilirsiniz.
Cloud Shell'i etkinleştirme
Cloud Console'un sağ üst kısmından aşağıdaki düğmeyi tıklayarak Cloud Shell'i etkinleştirin:
Cloud Shell'i daha önce hiç başlatmadıysanız ne olduğunu açıklayan bir ara ekran (ekranın alt kısmı) gösterilir. Bu durumda Devam'ı tıkladığınızda bu ekranı bir daha görmezsiniz. Bu tek seferlik ekran aşağıdaki gibi görünür:
Cloud Shell'in temel hazırlığı ve bağlanması yalnızca birkaç dakikanızı alır.
Bu sanal makine, ihtiyaç duyduğunuz tüm geliştirme araçlarını içerir. 5 GB boyutunda kalıcı bir ana dizin bulunur ve Google Cloud'da çalışır. Bu sayede ağ performansı ve kimlik doğrulama önemli ölçüde güçlenir. Bu codelab'deki çalışmalarınızın neredeyse tamamını yalnızca bir tarayıcı veya Chromebook'unuzla yapabilirsiniz.
Cloud Shell'e bağlandıktan sonra kimliğinizin doğrulandığını ve projenin, proje kimliğinize ayarlandığını görürsünüz.
Kimliğinizin doğrulandığını onaylamak için Cloud Shell'de şu komutu çalıştırın:
gcloud auth list
Komut çıkışında aşağıdakine benzer bir sonuç görürsünüz:
gcloud komutunun projeniz hakkında bilgi sahibi olduğunu onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:
gcloud config list project
Komut çıkışı
[core] project = <PROJECT_ID>
Değilse şu komutla ayarlayabilirsiniz:
gcloud config set project <PROJECT_ID>
Komut çıkışı
Updated property [core/project].
Cloud Shell'de, mevcut Cloud projemizin adını içeren GOOGLE_CLOUD_PROJECT dahil olmak üzere birkaç ortam değişkeni bulunur. Bu değeri laboratuvarın çeşitli yerlerinde kullanacağız. Bu durumu şu komutu çalıştırarak görebilirsiniz:
echo $GOOGLE_CLOUD_PROJECT
2. Adım: API'leri etkinleştirme
Bu hizmetlerin nerede (ve neden) gerekli olduğunu sonraki adımlarda göreceksiniz. Ancak şimdilik projenizin Compute Engine, Container Registry ve Vertex AI hizmetlerine erişmesini sağlamak için bu komutu çalıştırın:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com \
cloudbuild.googleapis.com \
cloudfunctions.googleapis.com
Bu işlem, aşağıdakine benzer bir başarı mesajı oluşturur:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
3. adım: Cloud Storage paketi oluşturma
Vertex AI'da eğitim işi çalıştırmak için kayıtlı model öğelerimizi depolayacak bir depolama paketine ihtiyacımız var. Paket bölgesel olmalıdır. Burada us-central kullanıyoruz ancak başka bir bölge de kullanabilirsiniz (bu laboratuvarda her yerde değiştirmeniz yeterlidir). Halihazırda bir paketiniz varsa bu adımı atlayabilirsiniz.
Bir paket oluşturmak için Cloud Shell terminalinizde aşağıdaki komutları çalıştırın:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Ardından, bu pakete işlem hizmeti hesabımızın erişmesini sağlayacağız. Bu işlem, Vertex Pipelines'ın bu pakete dosya yazmak için gerekli izinlere sahip olmasını sağlar. Bu izni eklemek için aşağıdaki komutu çalıştırın:
gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin
4. adım: Vertex AI Workbench örneği oluşturma
Cloud Console'unuzun Vertex AI bölümünde Workbench'i tıklayın:
Buradan Kullanıcı tarafından yönetilen not defterleri bölümünde Yeni not defteri'ni tıklayın:
Ardından, GPU'suz TensorFlow Enterprise 2.3 (LTS özellikli) örnek türünü seçin:
Varsayılan seçenekleri kullanıp Oluştur'u tıklayın.
5. adım: Not defterinizi açın
Örnek oluşturulduktan sonra Open JupyterLab'i (JupyterLab'i aç) seçin:
4. Vertex Pipelines kurulumu
Vertex Pipelines'ı kullanmak için yüklememiz gereken birkaç ek kitaplık vardır:
- Kubeflow Pipelines: Ardışık düzenimizi oluşturmak için kullanacağımız SDK'dır. Vertex Pipelines, hem Kubeflow Pipelines hem de TFX ile oluşturulan işlem hatlarının çalıştırılmasını destekler.
- Google Cloud Pipeline Components: Bu kitaplık, ardışık düzen adımlarınızdan Vertex AI hizmetleriyle etkileşimi kolaylaştıran önceden oluşturulmuş bileşenler sağlar.
1. adım: Python not defteri oluşturun ve kitaplıkları yükleyin
İlk olarak, not defteri örneğinizdeki Başlatıcı menüsünden Python 3'ü seçerek bir not defteri oluşturun:
Not defteri örneğinizin sol üst kısmındaki + işaretini tıklayarak Başlatıcı menüsüne erişebilirsiniz.
Bu laboratuvarda kullanacağımız her iki hizmeti de yüklemek için önce bir not defteri hücresinde kullanıcı işaretini ayarlayın:
USER_FLAG = "--user"
Ardından, not defterinizden aşağıdakileri çalıştırın:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0
Bu paketleri yükledikten sonra çekirdeği yeniden başlatmanız gerekir:
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Son olarak, paketleri doğru şekilde yüklediğinizden emin olun. KFP SDK sürümü 1.8 veya üzeri olmalıdır:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"
2. adım: Proje kimliğinizi ve paketinizi ayarlayın
Bu laboratuvar boyunca Cloud proje kimliğinize ve daha önce oluşturduğunuz pakete referans vereceksiniz. Ardından, bunların her biri için değişkenler oluşturacağız.
Proje kimliğinizi bilmiyorsanız aşağıdaki komutu çalıştırarak 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 takdirde, buradan ayarlayın:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Ardından, paketinizin adını depolayacak bir değişken oluşturun. Bu laboratuvarda oluşturduysanız aşağıdakiler işe yarar. Aksi takdirde, bunu manuel olarak ayarlamanız gerekir:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
3. adım: Kitaplıkları içe aktarın
Bu codelab'de kullanacağımız kitaplıkları içe aktarmak için aşağıdakileri ekleyin:
import kfp
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import component, pipeline, Artifact, ClassificationMetrics, Input, Output, Model, Metrics
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
from typing import NamedTuple
4. adım: Sabitleri tanımlayın
Ardışık düzenimizi oluşturmadan önce yapmamız gereken son şey, bazı sabit değişkenleri tanımlamaktır. PIPELINE_ROOT, ardışık düzenimiz tarafından oluşturulan yapıların yazılacağı Cloud Storage yoludur. Burada bölge olarak us-central1 kullanıyoruz ancak paketinizi oluştururken farklı bir bölge kullandıysanız aşağıdaki kodda REGION değişkenini güncelleyin:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
Yukarıdaki kodu çalıştırdıktan sonra, işlem hattınızın kök dizininin yazdırıldığını görmeniz gerekir. Bu, ardışık düzeninizdeki yapıların yazılacağı Cloud Storage konumudur. gs://YOUR-BUCKET-NAME/pipeline_root/ biçiminde olacaktır.
5. İlk ardışık düzeninizi oluşturma
Vertex Pipelines'ın nasıl çalıştığını öğrenmek için önce KFP SDK'yı kullanarak kısa bir ardışık düzen oluşturacağız. Bu ardışık düzen, makine öğrenimiyle ilgili herhangi bir işlem yapmaz (Endişelenmeyin, bu konuya da değineceğiz!). Bu ardışık düzeni kullanarak size şunları öğreteceğiz:
- KFP SDK'sında özel bileşenler oluşturma
- Vertex Pipelines'da ardışık düzen çalıştırma ve izleme
Bir ürün adı ve emoji açıklaması olmak üzere iki çıkışı kullanarak bir cümle yazdıran bir işlem hattı oluşturacağız. Bu ardışık düzen üç bileşenden oluşur:
product_name: Bu bileşen, giriş olarak bir ürün adı (veya istediğiniz herhangi bir isim) alır ve bu dizeyi çıkış olarak döndürür.emoji: Bu bileşen, bir emojinin metin açıklamasını alıp emojiye dönüştürür. Örneğin, ✨ emojisi için metin kodu "sparkles"dır. Bu bileşen, işlem hattınızdaki harici bağımlılıkları nasıl yöneteceğinizi göstermek için bir emoji kitaplığı kullanır.build_sentence: Bu son bileşen, emoji'nin kullanıldığı bir cümle oluşturmak için önceki iki bileşenin çıkışını kullanır. Örneğin, sonuçta "Vertex Pipelines is ✨" çıkışı elde edilebilir.
Kodlamaya başlayalım.
1. adım: Python işlevine dayalı bir bileşen oluşturun
KFP SDK'yı kullanarak Python işlevlerine dayalı bileşenler oluşturabiliriz. Bunu ilk işlem hattımızdaki 3 bileşen için kullanacağız. Öncelikle product_name bileşenini oluşturacağız. Bu bileşen, giriş olarak yalnızca bir dize alır ve bu dizeyi döndürür. Not defterinize aşağıdakileri ekleyin:
@component(base_image="python:3.9", output_component_file="first-component.yaml")
def product_name(text: str) -> str:
return text
Buradaki söz dizimine daha yakından bakalım:
@componentdekoratörü, ardışık düzen çalıştırıldığında bu işlevi bir bileşene derler. Özel bir bileşen yazdığınız her zaman bunu kullanırsınız.base_imageparametresi, bu bileşenin kullanacağı kapsayıcı görüntüsünü belirtir.output_component_fileparametresi isteğe bağlıdır ve derlenen bileşenin yazılacağı yaml dosyasını belirtir. Hücreyi çalıştırdıktan sonra, dosyanın not defteri örneğinize yazıldığını görürsünüz. Bu bileşeni biriyle paylaşmak istiyorsanız oluşturulan YAML dosyasını gönderebilir ve aşağıdaki komutla yüklemesini isteyebilirsiniz:
product_name_component = kfp.components.load_component_from_file('./first-component.yaml')
- İşlev tanımından sonraki
-> str, bu bileşenin çıkış türünü belirtir.
2. adım: İki ek bileşen oluşturun
İşlem hattımızı tamamlamak için iki bileşen daha oluşturacağız. Tanımlayacağımız ilk işlev, giriş olarak bir dize alır ve varsa bu dizeyi karşılık gelen emoji'ye dönüştürür. Bu işlev, iletilen giriş metnini ve sonuç emoji'sini içeren bir demet döndürür:
@component(packages_to_install=["emoji"])
def emoji(
text: str,
) -> NamedTuple(
"Outputs",
[
("emoji_text", str), # Return parameters
("emoji", str),
],
):
import emoji
emoji_text = text
emoji_str = emoji.emojize(':' + emoji_text + ':', language='alias')
print("output one: {}; output_two: {}".format(emoji_text, emoji_str))
return (emoji_text, emoji_str)
Bu bileşen, önceki bileşenimizden biraz daha karmaşıktır. Yeniliklere göz atalım:
packages_to_installparametresi, bileşene bu kapsayıcı için harici kitaplık bağımlılıklarını bildirir. Bu örnekte, emoji adlı bir kitaplık kullanıyoruz.- Bu bileşen,
Outputsadlı birNamedTupledöndürür. Bu demetteki dizelerin her birindeemoji_textveemojianahtarları olduğunu unutmayın. Çıkışa erişmek için bunları bir sonraki bileşenimizde kullanacağız.
Bu işlem hattındaki son bileşen, ilk ikisinin çıkışını kullanır ve bunları birleştirerek bir dize döndürür:
@component
def build_sentence(
product: str,
emoji: str,
emojitext: str
) -> str:
print("We completed the pipeline, hooray!")
end_str = product + " is "
if len(emoji) > 0:
end_str += emoji
else:
end_str += emojitext
return(end_str)
Bu bileşenin, tanımladığınız önceki adımların çıktısını nasıl kullanacağını merak ediyor olabilirsiniz. Güzel soru! Tüm bunları bir sonraki adımda bir araya getireceğiz.
3. adım: Bileşenleri bir işlem hattında bir araya getirme
Yukarıda tanımladığımız bileşen tanımları, adım oluşturmak için ardışık düzen tanımında kullanılabilecek fabrika işlevleri oluşturdu. Ardışık düzen oluşturmak için @pipeline dekoratörünü kullanın, ardışık düzene bir ad ve açıklama verin ve ardışık düzeninizin yapıtlarının yazılacağı kök yolu belirtin. Yapılar, işlem hattınız tarafından oluşturulan tüm çıkış dosyalarıdır. Bu giriş ardışık düzeni herhangi bir sonuç üretmez ancak bir sonraki ardışık düzenimiz üretir.
Bir sonraki kod bloğunda intro_pipeline işlevini tanımlıyoruz. Burada, ilk ardışık düzen adımlarımızdaki girişleri ve adımların birbirine nasıl bağlandığını belirtiriz:
product_task, giriş olarak bir ürün adı alır. Burada "Vertex Pipelines" iletiliyor ancak bunu istediğiniz gibi değiştirebilirsiniz.emoji_task, emoji'nin metin kodunu giriş olarak alır. Bu değeri istediğiniz gibi değiştirebilirsiniz. Örneğin, "party_face" ifadesi 🥳 emojisini ifade eder. Hem bu bileşenin hem deproduct_taskbileşeninin giriş sağlayan herhangi bir adımı olmadığından, işlem hattımızı tanımlarken bu bileşenlerin girişini manuel olarak belirttiğimizi unutmayın.- Kanalımızdaki son adım olan
consumer_task'da üç giriş parametresi vardır:product_taskçıkışı. Bu adım yalnızca bir çıkış ürettiğindenproduct_task.outputile buna başvurabiliriz.emoji_taskadımımızınemojiçıkışı. Çıkış parametrelerini adlandırdığımız yukarıda tanımlananemojibileşenine bakın.- Benzer şekilde,
emojibileşeninden gelenemoji_textadlı çıkış. İşlem hattımıza emoji'ye karşılık gelmeyen bir metin iletilirse cümle oluşturmak için bu metin kullanılır.
@pipeline(
name="hello-world",
description="An intro pipeline",
pipeline_root=PIPELINE_ROOT,
)
# You can change the `text` and `emoji_str` parameters here to update the pipeline output
def intro_pipeline(text: str = "Vertex Pipelines", emoji_str: str = "sparkles"):
product_task = product_name(text)
emoji_task = emoji(emoji_str)
consumer_task = build_sentence(
product_task.output,
emoji_task.outputs["emoji"],
emoji_task.outputs["emoji_text"],
)
4. adım: Ardışık düzeni derleyin ve çalıştırın
Ardışık düzeniniz tanımlandığına göre derlemeye hazırsınız. Aşağıdaki komut, işlem hattını çalıştırmak için kullanacağınız bir JSON dosyası oluşturur:
compiler.Compiler().compile(
pipeline_func=intro_pipeline, package_path="intro_pipeline_job.json"
)
Ardından, TIMESTAMP değişkeni oluşturun. Bu bilgiyi iş kimliğimizde kullanacağız:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Ardından ardışık düzen işinizi tanımlayın:
job = aiplatform.PipelineJob(
display_name="hello-world-pipeline",
template_path="intro_pipeline_job.json",
job_id="hello-world-pipeline-{0}".format(TIMESTAMP),
enable_caching=True
)
Son olarak, yeni bir ardışık düzen yürütmesi oluşturmak için işi çalıştırın:
job.submit()
Bu hücreyi çalıştırdıktan sonra, konsolunuzda ardışık düzen çalıştırmasını görüntüleme bağlantısı içeren günlükler görmeniz gerekir:
Bağlantıya gidin. Ardışık düzeniniz tamamlandığında aşağıdaki gibi görünmelidir:
Bu işlem hattının çalışması 5-6 dakika sürer. İşlem tamamlandığında son çıktıyı görmek için build-sentence bileşenini tıklayabilirsiniz:
KFP SDK'sının ve Vertex Pipelines'ın nasıl çalıştığını öğrendiğinize göre artık diğer Vertex AI hizmetlerini kullanarak bir makine öğrenimi modeli oluşturan ve dağıtan bir ardışık düzen oluşturmaya hazırsınız. Haydi başlayalım.
6. Uçtan uca ML ardışık düzeni oluşturma
Şimdi ilk makine öğrenimi ardışık düzeninizi oluşturma zamanı. Bu ardışık düzende, KOKLU, M. ve OZKAN, I.A. tarafından oluşturulan UCI Machine Learning Kuru fasulye veri kümesini kullanacağız. (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques."In Computers and Electronics in Agriculture, 174, 105507. DOI.
Bu, tablo biçiminde bir veri kümesidir. İşlem hattımızda, fasulyeleri özelliklerine göre 7 türden birine sınıflandıran bir AutoML modelini eğitmek, değerlendirmek ve dağıtmak için bu veri kümesini kullanacağız.
Bu işlem hattı:
- içinde veri kümesi oluşturma
- AutoML ile tablo biçiminde sınıflandırma modeli eğitme
- Bu modelle ilgili değerlendirme metriklerini alma
- Değerlendirme metriklerine göre, modeli Vertex Pipelines'da koşullu mantık kullanarak dağıtıp dağıtmamaya karar verin.
- Vertex Prediction'ı kullanarak modeli bir uç noktaya dağıtma
Belirtilen adımların her biri bir bileşen olacaktır. Ardışık düzen adımlarının çoğu, bu codelab'in başında içe aktardığımız google_cloud_pipeline_components kitaplığı aracılığıyla Vertex AI hizmetleri için önceden oluşturulmuş bileşenleri kullanır. Bu bölümde, önce bir özel bileşen tanımlayacağız. Ardından, önceden oluşturulmuş bileşenleri kullanarak işlem hattının geri kalan adımlarını tanımlayacağız. Önceden oluşturulmuş bileşenler, model eğitimi ve dağıtımı gibi Vertex AI hizmetlerine erişimi kolaylaştırır.
1. adım: Model değerlendirmesi için özel bir bileşen
Tanımlayacağımız özel bileşen, model eğitimi tamamlandıktan sonra ardışık düzenimizin sonuna doğru kullanılır. Bu bileşen şunları yapar:
- Eğitilmiş AutoML sınıflandırma modelinden değerlendirme metriklerini alma
- Metrikleri ayrıştırın ve Vertex Pipelines kullanıcı arayüzünde oluşturun.
- Modelin dağıtılıp dağıtılmayacağını belirlemek için metrikleri bir eşikle karşılaştırın.
Bileşeni tanımlamadan önce giriş ve çıkış parametrelerini anlayalım. Bu ardışık düzen, giriş olarak Cloud projemizle ilgili bazı meta verileri, ortaya çıkan eğitilmiş modeli (bu bileşeni daha sonra tanımlayacağız), modelin değerlendirme metriklerini ve bir thresholds_dict_str alır. thresholds_dict_str, ardışık düzenimizi çalıştırdığımızda tanımlayacağımız bir şeydir. Bu sınıflandırma modelinde, bu değer, modeli dağıtmamız gereken ROC eğrisinin altındaki alan değeri olacaktır. Örneğin, 0, 95 değerini iletirsek ardışık düzenimizin modeli yalnızca bu metrik %95'in üzerindeyse dağıtmasını istediğimiz anlamına gelir.
Değerlendirme bileşenimiz, modelin dağıtılıp dağıtılmayacağını belirten bir dize döndürür. Bu özel bileşeni oluşturmak için not defteri hücresine aşağıdakileri ekleyin:
@component(
base_image="gcr.io/deeplearning-platform-release/tf2-cpu.2-3:latest",
output_component_file="tabular_eval_component.yaml",
packages_to_install=["google-cloud-aiplatform"],
)
def classification_model_eval_metrics(
project: str,
location: str, # "us-central1",
api_endpoint: str, # "us-central1-aiplatform.googleapis.com",
thresholds_dict_str: str,
model: Input[Artifact],
metrics: Output[Metrics],
metricsc: Output[ClassificationMetrics],
) -> NamedTuple("Outputs", [("dep_decision", str)]): # Return parameter.
import json
import logging
from google.cloud import aiplatform as aip
# Fetch model eval info
def get_eval_info(client, model_name):
from google.protobuf.json_format import MessageToDict
response = client.list_model_evaluations(parent=model_name)
metrics_list = []
metrics_string_list = []
for evaluation in response:
print("model_evaluation")
print(" name:", evaluation.name)
print(" metrics_schema_uri:", evaluation.metrics_schema_uri)
metrics = MessageToDict(evaluation._pb.metrics)
for metric in metrics.keys():
logging.info("metric: %s, value: %s", metric, metrics[metric])
metrics_str = json.dumps(metrics)
metrics_list.append(metrics)
metrics_string_list.append(metrics_str)
return (
evaluation.name,
metrics_list,
metrics_string_list,
)
# Use the given metrics threshold(s) to determine whether the model is
# accurate enough to deploy.
def classification_thresholds_check(metrics_dict, thresholds_dict):
for k, v in thresholds_dict.items():
logging.info("k {}, v {}".format(k, v))
if k in ["auRoc", "auPrc"]: # higher is better
if metrics_dict[k] < v: # if under threshold, don't deploy
logging.info("{} < {}; returning False".format(metrics_dict[k], v))
return False
logging.info("threshold checks passed.")
return True
def log_metrics(metrics_list, metricsc):
test_confusion_matrix = metrics_list[0]["confusionMatrix"]
logging.info("rows: %s", test_confusion_matrix["rows"])
# log the ROC curve
fpr = []
tpr = []
thresholds = []
for item in metrics_list[0]["confidenceMetrics"]:
fpr.append(item.get("falsePositiveRate", 0.0))
tpr.append(item.get("recall", 0.0))
thresholds.append(item.get("confidenceThreshold", 0.0))
print(f"fpr: {fpr}")
print(f"tpr: {tpr}")
print(f"thresholds: {thresholds}")
metricsc.log_roc_curve(fpr, tpr, thresholds)
# log the confusion matrix
annotations = []
for item in test_confusion_matrix["annotationSpecs"]:
annotations.append(item["displayName"])
logging.info("confusion matrix annotations: %s", annotations)
metricsc.log_confusion_matrix(
annotations,
test_confusion_matrix["rows"],
)
# log textual metrics info as well
for metric in metrics_list[0].keys():
if metric != "confidenceMetrics":
val_string = json.dumps(metrics_list[0][metric])
metrics.log_metric(metric, val_string)
# metrics.metadata["model_type"] = "AutoML Tabular classification"
logging.getLogger().setLevel(logging.INFO)
aip.init(project=project)
# extract the model resource name from the input Model Artifact
model_resource_path = model.metadata["resourceName"]
logging.info("model path: %s", model_resource_path)
client_options = {"api_endpoint": api_endpoint}
# Initialize client that will be used to create and send requests.
client = aip.gapic.ModelServiceClient(client_options=client_options)
eval_name, metrics_list, metrics_str_list = get_eval_info(
client, model_resource_path
)
logging.info("got evaluation name: %s", eval_name)
logging.info("got metrics list: %s", metrics_list)
log_metrics(metrics_list, metricsc)
thresholds_dict = json.loads(thresholds_dict_str)
deploy = classification_thresholds_check(metrics_list[0], thresholds_dict)
if deploy:
dep_decision = "true"
else:
dep_decision = "false"
logging.info("deployment decision is %s", dep_decision)
return (dep_decision,)
2. adım: Google Cloud önceden oluşturulmuş bileşenlerini ekleme
Bu adımda, ardışık düzen bileşenlerimizin geri kalanını tanımlayacak ve hepsinin nasıl bir araya geldiğini göreceğiz. Öncelikle, ardışık düzen çalıştırmanızın görünen adını bir zaman damgası kullanarak tanımlayın:
import time
DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time())))
print(DISPLAY_NAME)
Ardından, aşağıdakileri yeni bir not defteri hücresine kopyalayın:
@pipeline(name="automl-tab-beans-training-v2",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://aju-dev-demos.beans.beans1",
display_name: str = DISPLAY_NAME,
project: str = PROJECT_ID,
gcp_region: str = "us-central1",
api_endpoint: str = "us-central1-aiplatform.googleapis.com",
thresholds_dict_str: str = '{"auRoc": 0.95}',
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
project=project, display_name=display_name, bq_source=bq_source
)
training_op = gcc_aip.AutoMLTabularTrainingJobRunOp(
project=project,
display_name=display_name,
optimization_prediction_type="classification",
budget_milli_node_hours=1000,
column_transformations=[
{"numeric": {"column_name": "Area"}},
{"numeric": {"column_name": "Perimeter"}},
{"numeric": {"column_name": "MajorAxisLength"}},
{"numeric": {"column_name": "MinorAxisLength"}},
{"numeric": {"column_name": "AspectRation"}},
{"numeric": {"column_name": "Eccentricity"}},
{"numeric": {"column_name": "ConvexArea"}},
{"numeric": {"column_name": "EquivDiameter"}},
{"numeric": {"column_name": "Extent"}},
{"numeric": {"column_name": "Solidity"}},
{"numeric": {"column_name": "roundness"}},
{"numeric": {"column_name": "Compactness"}},
{"numeric": {"column_name": "ShapeFactor1"}},
{"numeric": {"column_name": "ShapeFactor2"}},
{"numeric": {"column_name": "ShapeFactor3"}},
{"numeric": {"column_name": "ShapeFactor4"}},
{"categorical": {"column_name": "Class"}},
],
dataset=dataset_create_op.outputs["dataset"],
target_column="Class",
)
model_eval_task = classification_model_eval_metrics(
project,
gcp_region,
api_endpoint,
thresholds_dict_str,
training_op.outputs["model"],
)
with dsl.Condition(
model_eval_task.outputs["dep_decision"] == "true",
name="deploy_decision",
):
endpoint_op = gcc_aip.EndpointCreateOp(
project=project,
location=gcp_region,
display_name="train-automl-beans",
)
gcc_aip.ModelDeployOp(
model=training_op.outputs["model"],
endpoint=endpoint_op.outputs["endpoint"],
dedicated_resources_min_replica_count=1,
dedicated_resources_max_replica_count=1,
dedicated_resources_machine_type="n1-standard-4",
)
Bu kodda neler olduğuna bakalım:
- İlk olarak, önceki ardışık düzenimizde olduğu gibi bu ardışık düzenin aldığı giriş parametrelerini tanımlarız. Bunlar, işlem hattındaki diğer adımların çıkışına bağlı olmadığından manuel olarak ayarlanması gerekir.
- Ardışık düzenin geri kalanında, Vertex AI hizmetleriyle etkileşim kurmak için birkaç önceden oluşturulmuş bileşen kullanılır:
TabularDatasetCreateOp, Cloud Storage veya BigQuery'deki bir veri kümesi kaynağına göre Vertex AI'da tablo biçiminde bir veri kümesi oluşturur. Bu ardışık düzende, verileri bir BigQuery tablosu URL'si üzerinden iletiyoruz.AutoMLTabularTrainingJobRunOp, tablo biçimindeki bir veri kümesi için AutoML eğitim işini başlatır. Bu bileşene, model türü (bu durumda sınıflandırma), sütunlarla ilgili bazı veriler, eğitimi ne kadar süreyle çalıştırmak istediğimiz ve veri kümesine yönelik bir işaretçi dahil olmak üzere birkaç yapılandırma parametresi iletiyoruz. Veri kümesini bu bileşene iletmek içindataset_create_op.outputs["dataset"]üzerinden önceki bileşenin çıkışını sağladığımızı unutmayın.EndpointCreateOp, Vertex AI'da bir uç nokta oluşturur. Bu adımdan oluşturulan uç nokta, bir sonraki bileşene giriş olarak iletilir.ModelDeployOp, belirli bir modeli Vertex AI'deki bir uç noktaya dağıtır. Bu örnekte, önceki adımda oluşturulan uç noktayı kullanıyoruz. Başka yapılandırma seçenekleri de mevcuttur ancak burada dağıtmak istediğimiz uç nokta makine türünü ve modelini sağlıyoruz. Ardışık düzenimizdeki eğitim adımının çıkışlarına erişerek modeli iletiyoruz.
- Bu ardışık düzende, Vertex Pipelines'ın bir özelliği olan koşullu mantık da kullanılır. Bu özellik, bir koşulun sonucuna göre farklı dallarla birlikte bir koşul tanımlamanıza olanak tanır. İşlem hattımızı tanımlarken bir
thresholds_dict_strparametresi ilettiğimizi unutmayın. Bu, modelimizi bir uç noktaya dağıtıp dağıtmayacağımızı belirlemek için kullandığımız doğruluk eşiğidir. Bunu uygulamak için KFP SDK'sındakiConditionsınıfını kullanırız. İletilen koşul, bu codelab'de daha önce tanımladığımız özel değerlendirme bileşeninin çıkışıdır. Bu koşul doğruysa işlem hattı,deploy_opbileşenini yürütmeye devam eder. Doğruluk, önceden tanımlanmış eşiğimizi karşılamıyorsa ardışık düzen burada durur ve bir model dağıtmaz.
3. adım: Uçtan uca makine öğrenimi ardışık düzenini derleyin ve çalıştırın
Tam ardışık düzenimiz tanımlandığına göre artık derleme zamanı:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="tab_classif_pipeline.json"
)
Ardından, işi tanımlayın:
ml_pipeline_job = aiplatform.PipelineJob(
display_name="automl-tab-beans-training",
template_path="tab_classif_pipeline.json",
pipeline_root=PIPELINE_ROOT,
parameter_values={"project": PROJECT_ID, "display_name": DISPLAY_NAME},
enable_caching=True
)
Son olarak, işi çalıştırın:
ml_pipeline_job.submit()
Ardışık düzeninizi konsolda görmek için yukarıdaki hücreyi çalıştırdıktan sonra günlüklerde gösterilen bağlantıya gidin. Bu ardışık düzenin çalıştırılması bir saatten biraz fazla sürer. Zamanın çoğu AutoML eğitim adımında harcanır. Tamamlanan ardışık düzen aşağıdaki gibi görünür:
En üstteki "Yapıları genişlet" düğmesini açarsanız işlem hattınızdan oluşturulan farklı yapılarla ilgili ayrıntıları görebilirsiniz. Örneğin, dataset yapıtını tıkladığınızda oluşturulan Vertex AI veri kümesiyle ilgili ayrıntıları görürsünüz. İlgili veri kümesinin sayfasına gitmek için buradaki bağlantıyı tıklayabilirsiniz:
Benzer şekilde, özel değerlendirme bileşenimizden elde edilen metrik görselleştirmelerini görmek için metricsc adlı yapıyı tıklayın. Kontrol panelinizin sağ tarafında bu modelin karmaşıklık matrisini görebilirsiniz:
Bu işlem hattı çalıştırmasından oluşturulan modeli ve uç noktayı görmek için modeller bölümüne gidin ve automl-beans adlı modeli tıklayın. Burada, bir uç noktaya dağıtılmış bu modeli görmelisiniz:
Bu sayfaya, işlem hattı grafiğinizdeki uç nokta yapısını tıklayarak da erişebilirsiniz.
Konsoldaki işlem hattı grafiğine bakmanın yanı sıra Soy Takibi için Vertex Pipelines'ı da kullanabilirsiniz. Soy takibi, işlem hattınız boyunca oluşturulan yapıları takip etme anlamına gelir. Bu, yapay ürünlerin nerede oluşturulduğunu ve bir makine öğrenimi iş akışında nasıl kullanıldığını anlamamıza yardımcı olabilir. Örneğin, bu ardışık düzende oluşturulan veri kümesinin soy takibini görmek için veri kümesi yapısını ve ardından Soyu Görüntüle'yi tıklayın:
Bu, yapay öğenin kullanıldığı tüm yerleri gösterir:
4. adım: Metrikleri ardışık düzen çalıştırmaları arasında karşılaştırma
Bu işlem hattını birden çok kez çalıştırırsanız çalıştırmalar arasındaki metrikleri karşılaştırmak isteyebilirsiniz. Çalıştırma meta verilerine erişmek için aiplatform.get_pipeline_df() yöntemini kullanabilirsiniz. Burada, bu ardışık düzenin tüm çalıştırmaları için meta verileri alıp Pandas DataFrame'e yükleyeceğiz:
pipeline_df = aiplatform.get_pipeline_df(pipeline="automl-tab-beans-training-v2")
small_pipeline_df = pipeline_df.head(2)
small_pipeline_df
Böylece laboratuvarı tamamladınız.
🎉 Tebrikler! 🎉
Vertex AI'ı kullanarak şunları yapmayı öğrendiniz:
- Özel bileşenlerle uçtan uca ardışık düzenler oluşturmak için Kubeflow Pipelines SDK'yı kullanma
- Ardışık düzenlerinizi Vertex Pipelines'da çalıştırma ve SDK ile ardışık düzen çalıştırmalarını başlatma
- Konsolda Vertex Pipelines grafiğinizi görüntüleme ve analiz etme
- Ardışık düzeninize Vertex AI hizmetleri eklemek için önceden oluşturulmuş ardışık düzen bileşenlerini kullanma
- Yinelenen ardışık düzen işlerini planlama
Vertex'in farklı bölümleri hakkında daha fazla bilgi edinmek için belgelere göz atın.
7. 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: Uç noktanızı silin
Dağıttığınız uç noktayı silmek için Vertex AI konsolunuzun Uç Noktalar bölümüne gidin ve silme simgesini tıklayın:
Ardından, aşağıdaki istemde Undeploy'u (Dağıtımı Kaldır) tıklayın:
Son olarak, konsolunuzun Modeller bölümüne gidin, ilgili modeli bulun ve sağdaki üç nokta menüsünden Modeli sil'i tıklayın:
3. 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:
