1. Genel Bakış
Bu laboratuvarda, Vertex Pipelines ile ML ardışık düzenlerini nasıl oluşturacağınızı ve çalıştıracağınızı öğreneceksiniz.
Öğrenecekleriniz
Öğrenecekleriniz:
- Ölçeklenebilir ML ardışık düzenleri oluşturmak için Kubeflow Pipelines SDK'sını kullanma
- Metin girişi alan 3 adımlı bir giriş ardışık düzeni oluşturup çalıştırma
- AutoML sınıflandırma modelini eğiten, değerlendiren ve dağıtan bir ardışık düzen oluşturup çalıştırma
- Vertex AI hizmetleriyle etkileşime geçmek için
google_cloud_pipeline_componentskitaplığı üzerinden sağlanan önceden oluşturulmuş bileşenleri kullanın - 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'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. Dilerseniz mevcut projeleri 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, Feature Store ve daha fazlası gibi çeşitli MLOps ürünlerini de içerir. Vertex AI'ın sunduğu tüm ürün tekliflerini aşağıdaki şemada görebilirsiniz.
Geri bildirimde bulunmak isterseniz lütfen destek sayfasını inceleyin.
ML ardışık düzenleri neden yararlıdır?
Konuyu incelemeye başlamadan önce, ardışık düzeni neden kullanmak isteyebileceğinizi anlayalım. Veri işleme, model eğitimi, hiper parametre ayarı, değerlendirme ve model dağıtımı içeren bir makine öğrenimi iş akışı oluşturduğunuzu hayal edin. Bu adımların her birinin farklı bağımlılıkları olabilir. İş akışının tamamını monolit olarak ele alırsanız bunlar zorlaşabilir. Makine öğrenimi sürecinizi ölçeklendirmeye başladığınızda, ekibinizdeki diğer kullanıcıların çalıştırabilmesi ve kod katkısında bulunabilmesi için makine öğrenimi iş akışınızı onlarla paylaşabilirsiniz. Güvenilir ve tekrarlanabilir bir süreç olmadan bu işlem zor olabilir. Veri akışlarında, makine öğrenimi işleminizdeki her adım kendi kapsayıcısına sahiptir. Bu sayede adımları bağımsız olarak geliştirebilir ve her adımdaki giriş ile çıkışı tekrarlanabilir bir şekilde izleyebilirsiniz. Ayrıca, Cloud ortamınızdaki diğer etkinliklere göre ardışık düzeninizin çalıştırılmasını planlayabilir veya tetikleyebilirsiniz (ör. yeni eğitim verileri mevcut olduğunda ardışık düzen çalıştırma).
Özet: Ardışık düzenler, ML 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 projeniz olması gerekir. 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ısı olan Cloud Shell oturumunda çalışacaksınız. Bu bölümü kendi bilgisayarınızda yerel olarak da çalıştırabilirsiniz ancak Cloud Shell'i kullanmak, herkese tutarlı bir ortamda yeniden üretilebilir bir deneyime erişim sağlar. Laboratuvardan sonra bu bölümü bilgisayarınızda yeniden deneyebilirsiniz.
Cloud Shell'i etkinleştirme
Cloud Shell'i etkinleştirmek için Cloud Console'un sağ üst kısmındaki aşağıdaki düğmeyi tıklayın:
Cloud Shell'i daha önce hiç başlatmadıysanız Cloud Shell'in ne olduğunu açıklayan bir ara ekran (ekranın altında) gösterilir. Bu durumda Devam'ı tıklayın (bu ekranı bir daha görmezsiniz). Tek seferlik ekran aşağıdaki gibi görünür:
Cloud Shell'e bağlanmak ve ortam oluşturmak yalnızca birkaç dakikanızı alır.
Bu sanal makinede ihtiyacınız olan tüm geliştirme araçları yüklüdür. 5 GB boyutunda kalıcı bir ana dizin sunar ve Google Cloud'da çalışır. Bu sayede ağ performansını ve kimlik doğrulamayı büyük ölçüde iyileştirir. Bu kod laboratuvarındaki çalışmanızın tamamı olmasa da büyük bir kısmı yalnızca bir tarayıcı veya Chromebook'unuzla yapılabilir.
Cloud Shell'e bağlandıktan sonra kimliğinizin doğrulandığını ve projenin proje kimliğinize göre ayarlandığını görürsünüz.
Kimliğinizi doğrulamak için Cloud Shell'de aşağıdaki komutu çalıştırın:
gcloud auth list
Komut çıkışında aşağıdakine benzer bir şey görürsünüz:
gcloud komutunun projenizi bildiğini onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:
gcloud config list project
Komut çıkışı
[core] project = <PROJECT_ID>
Aksi takdirde aşağıdaki 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 gibi birkaç ortam değişkeni vardır. Bu laboratuvar boyunca çeşitli yerlerde bu değişkeni kullanacağız. Aşağıdaki komutu çalıştırarak bu bilgileri görebilirsiniz:
echo $GOOGLE_CLOUD_PROJECT
2. Adım: API'leri etkinleştirme
Sonraki adımlarda bu hizmetlerin nerede, neden gerekli olduğunu göreceksiniz. Şimdilik projenizin Compute Engine, Container Registry ve Vertex AI hizmetlerine erişmesine izin vermek için şimdilik şu 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 başarılı bir mesaj üretir:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
3. Adım: Cloud Storage paketi oluşturun
Vertex AI'da eğitim işi çalıştırmak için kayıtlı model öğelerimizi depolayacak bir depolama paketine ihtiyacımız vardır. Paketin bölgesel olması gerekir. Burada us-central bölgesini kullanıyoruz ancak başka bir bölge de kullanabilirsiniz (bu laboratuvar boyunca bölgeyi değiştirin). Halihazırda bir paketiniz varsa bu adımı atlayabilirsiniz.
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, bilgi işlem hizmet hesabımıza bu pakete erişim izni vereceğiz. Bu işlem, Vertex Pipelines'in 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şturun
Cloud Console'un Vertex AI bölümünde Workbench'i tıklayın:
İlgili sayfada, Kullanıcı tarafından yönetilen Not defterleri'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ın ve Oluştur'u tıklayın.
5. Adım: Not defterinizi açın
Örnek oluşturulduktan sonra JupyterLab'i aç'ı seçin:
4. Vertex Pipelines kurulumu
Vertex Pipelines'i kullanmak için yüklememiz gereken birkaç ek kitaplık vardır:
- Kubeflow Pipelines: Bu, 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 ardışık düzenlerin çalıştırılmasını destekler.
- Google Cloud Ardışık Düzen Bileşenleri: Bu kitaplık, ardışık düzen adımlarınızdan Vertex AI hizmetleriyle etkileşimi kolaylaştıran önceden derlenmiş bileşenler sağlar.
1. adım: Python not defteri oluşturun ve kitaplıkları yükleyin
Öncelikle, not defteri örneğinizin 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 laboratuvarda Cloud projenize ve daha önce oluşturduğunuz pakete atıfta bulunacaksınız. Ardından bunların her biri için değişkenler oluşturacağız.
Proje kimliğinizi bilmiyorsanız aşağıdakileri çalıştırarak öğrenebilirsiniz:
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ğıdaki yöntem işe yarayacaktır. 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 şunları 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: Sabit değerleri tanımlayın
Ardışık düzenimizi oluşturmadan önce yapmamız gereken son şey bazı sabit değişkenler 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, ardışık düzeninizin 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çimindedir.
5. İlk ardışık düzeninizi oluşturma
Vertex Pipelines'in işleyiş şeklini öğrenmek için önce KFP SDK'sını kullanarak kısa bir ardışık düzen oluşturacağız. Bu ardışık düzen, makine öğrenimi ile ilgili herhangi bir işlem yapmaz (Endişelenmeyin, bu konuya da değineceğiz). Bu ardışık düzeni kullanarak size şu konuları öğreteceğiz:
- KFP SDK'sında özel bileşenler oluşturma
- Vertex Pipelines'de ardışık düzeni çalıştırma ve izleme
Bir ürün adı ve emoji açıklaması olmak üzere iki çıkış kullanarak bir cümle yazdıran bir ardışık düzen oluşturacağız. Bu ardışık düzen üç bileşenden oluşur:
product_name: Bu bileşen, giriş olarak bir ürün adını (veya istediğiniz herhangi bir ismi) 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, ✨ için metin kodu "sparkles" (parıltılar) olur. Bu bileşen, ardışık düzeninizdeki 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, emojinin kullanıldığı bir cümle oluşturmak için önceki ikisinin çıkışını kullanır. Örneğin, sonuç "Vertex Pipelines is ✨" (Vertex Pipelines is ✨) olabilir.
Kodlamaya başlayalım.
1. adım: Python işlevine dayalı bir bileşen oluşturun
KFP SDK'sını kullanarak Python işlevlerine dayalı bileşenler oluşturabiliriz. İlk ardışık düzenimizdeki 3 bileşen için bunu kullanacağız. İlk olarak product_name bileşenini oluşturacağız. Bu bileşen, giriş olarak bir dizeyi alıp o dizeyi döndürecektir. 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:
@componenttasarımcısı, ardışık düzen çalıştırıldığında bu işlevi bir bileşen olarak derler. Özel bileşen yazarken her zaman bu sınıfı 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 bu dosyanın not defteri örneğinize yazıldığını görürsünüz. Bu bileşeni bir kullanıcıyla paylaşmak isterseniz oluşturulan yaml dosyasını kendisine gönderebilir ve aşağıdaki şekilde 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
Ardışık düzenimizi tamamlamak için iki bileşen daha oluşturacağız. Tanımlayacağımız ilk öğe, bir dizeyi giriş olarak alır ve varsa bu dizeyi karşılık gelen emojisine dönüştürür. Gönderilen giriş metnini ve oluşturulan emojiyi içeren bir tuple 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. Yenilikleri ayrıntılı olarak inceleyelim:
packages_to_installparametresi, bileşene bu kapsayıcı için tüm 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 tuple'deki dizelerin her birininemoji_textveemojianahtarlarına sahip olduğunu unutmayın. Çıktıya erişmek için bunları bir sonraki bileşenimizde kullanacağız.
Bu ardışık düzendeki son bileşen, ilk iki bileşenin çıktısını tüketir ve bir dize döndürmek için bunları birleştirir:
@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şen, tanımladığınız önceki adımların çıktısını nasıl bilir? diye merak ediyor olabilirsiniz. Güzel soru! Bir sonraki adımda tüm bunları bir araya getireceğiz.
3. Adım: Bileşenleri bir ardışık düzene yerleştirme
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şlevlerini oluşturdu. Ardışık düzen kurmak için @pipeline tasarımcısını kullanın, ardışık düzene bir ad ve açıklama verin, ardışık düzeninizin yapılarının yazılması gereken kök yolunu sağlayın. Yapılar, ardışık düzeniniz tarafından oluşturulan tüm çıkış dosyalarını ifade eder. Bu giriş ardışık düzeni hiçbir video oluşturmaz ancak sonraki ardışık düzenimiz oluşturur.
Bir sonraki kod bloğunda bir intro_pipeline işlevi tanımladık. Burada, ilk ardışık düzen adımlarımızın girişlerini ve adımların birbirine nasıl bağlandığını belirtiriz:
product_task, giriş olarak bir ürün adı alır. Burada "Vertex Pipelines" değerini iletmekteyiz ancak bunu istediğiniz şekilde değiştirebilirsiniz.emoji_task, emojinin metin kodunu giriş olarak alır. Ayrıca bunu istediğiniz şekilde değiştirebilirsiniz. Örneğin, "party_face" 🥳 emoji'sini ifade eder. Hem bu hem deproduct_taskbileşenine girilen herhangi bir adım olmadığından, ardışık düzenimizi tanımlarken bu bileşenler için girişi manuel olarak belirttiğimizi unutmayın.- Ardışık düzenimizdeki son adım (
consumer_task) üç giriş parametresine sahiptir:product_taskişlevinin sonucu. Bu adım yalnızca bir çıkış oluşturduğundanproduct_task.outputaracılığıyla bu adıma referans verebiliriz.emoji_taskadımımızınemojiçıkışı. Çıkış parametrelerini adlandırdığımız yukarıda tanımlananemojibileşenine bakın.- Benzer şekilde,
emojibileşenindekiemoji_textadlı çıkış. Ardışık düzenimize emojiye karşılık gelmeyen bir metin iletilmesi durumunda, 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
Oluşturduğunuz ardışık düzeni derlemeye hazırsınız. Aşağıdaki komut, ardışık düzeni ç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 bir TIMESTAMP değişkeni oluşturun. Bu değeri 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ütme oluşturmak için işi çalıştırın:
job.submit()
Bu hücreyi çalıştırdıktan sonra, ardışık düzenin çalıştırılmasını konsolunuzda görüntüleme bağlantısını içeren günlükleri görürsünüz:
İlgili bağlantıya gidin. Ardışık düzeniniz tamamlandığında aşağıdaki gibi görünmelidir:
Bu ardışık düzenin çalıştırılması 5-6 dakika sürer. İşlem tamamlandığında nihai çıkışı görmek için build-sentence bileşenini tıklayabilirsiniz:
KFP SDK'sının ve Vertex Pipelines'in işleyiş şeklini öğrendiğinize göre, diğer Vertex AI hizmetlerini kullanarak bir makine öğrenimi modeli oluşturup 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
İlk makine öğrenimi ardışık düzeninizi oluşturmanın zamanı geldi. Bu ardışık düzende, KOKLU, M. ve OZKAN, I.A., (2020), "Bilgisayar Görüşü ve Makine Öğrenimi Teknikleri Kullanılarak Kuru Fasulyelerin Çok Sınıflı Sınıflandırılması."In Computers and Electronics in Agriculture, 174, 105507. DOI.
Bu bir tablo veri kümesidir. Veri kümesini, akışı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 kullanacağız.
Bu ardışık düzen:
- bölgesinde bir Veri Kümesi oluşturun
- AutoML ile tablo biçiminde sınıflandırma modeli eğitme
- Bu modelle ilgili değerlendirme metriklerini alma
- Değerlendirme metriklerini temel alarak modeli Vertex Pipelines'de koşullu mantık kullanarak dağıtıp dağıtmayacağınıza karar verin.
- Vertex Prediction'i kullanarak modeli bir uç noktaya dağıtma
Anahatları verilen adımların her biri bir bileşen olacaktır. Ardışık düzen adımlarının çoğunda, bu codelab'de daha önce içe aktardığımız google_cloud_pipeline_components kitaplığı aracılığıyla Vertex AI hizmetleri için önceden oluşturulmuş bileşenler kullanılır. Bu bölümde, önce bir özel bileşen tanımlayacağız. Ardından, önceden oluşturulmuş bileşenleri kullanarak ardışık düzen adımlarının geri kalanını tanımlayacağız. Önceden oluşturulmuş bileşenler, model eğitimi ve dağıtım gibi Vertex AI hizmetlerine erişmeyi 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 birkaç işlevi yerine getirir:
- Eğitilen 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ırma
Bileşeni tanımlamadan önce giriş ve çıkış parametrelerini anlayalım. Bu ardışık düzen, giriş olarak Cloud projemizdeki bazı meta verileri, 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ırırken tanımlayacağımız bir değerdir. Bu sınıflandırma modelinde, ROC eğrisi değerinin altındaki alan, modeli dağıtmamız gereken alandır. Örneğin, 0,95 değerini iletiriz.Bu, 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 bir 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: Önceden oluşturulmuş Google Cloud bileşenlerini ekleme
Bu adımda, ardışık düzen bileşenlerimizin geri kalanını tanımlayıp hepsinin nasıl uyumlu olduğunu inceleyeceğiz. Öncelikle zaman damgası kullanarak ardışık düzen çalıştırmanızın görünen adını tanımlayın:
import time
DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time())))
print(DISPLAY_NAME)
Ardından, aşağıdakini 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 kullandığı giriş parametrelerini tanımlıyoruz. Bunlar, ardışık düzendeki diğer adımların çıktısına bağlı olmadığından manuel olarak ayarlanmalıdır.
- Ardışık düzenin geri kalanında, Vertex AI hizmetleriyle etkileşim kurmak için birkaç önceden derlenmiş bileşen kullanılır:
TabularDatasetCreateOp, Cloud Storage veya BigQuery'de bir veri kümesi kaynağı verildiğinde Vertex AI'da tablo veri kümesi oluşturur. Bu ardışık düzende verileri bir BigQuery tablosu URL'si üzerinden iletiyoruz.AutoMLTabularTrainingJobRunOp, tablo veri kümesi için bir AutoML eğitim işi 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üre boyunca çalıştırmak istediğimiz ve veri kümesinin işaretçisi gibi birkaç yapılandırma parametresi iletiriz. Veri kümesini bu bileşene iletmek içindataset_create_op.outputs["dataset"]aracılığıyla önceki bileşenin çıktısı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'daki bir uç noktaya dağıtır. Bu örnekte, önceki adımda oluşturulan uç noktayı kullanıyoruz. Ek yapılandırma seçenekleri de mevcut ancak dağıtmak istediğimiz uç nokta makine türünü ve modelini burada paylaşıyoruz. Ardışık düzenimizdeki eğitim adımını çıktılarına erişerek modeli iletiyoruz.
- Bu ardışık düzende, Vertex Ardışık Düzenler'in bir özelliği olan koşullu mantık da kullanılır. Bu özellik, bir koşulu ve bu koşulun sonucuna göre farklı dallar tanımlamanıza olanak tanır. Ardışık düzenimizi 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. İlettiğimiz koşul, bu kod laboratuvarının daha önceki bölümünde tanımladığımız özel eval bileşeninin çıktısıdır. Bu koşul doğruysa ardışık düzen,deploy_opbileşenini yürütmeye devam eder. Doğruluk, önceden tanımlanmış eşik değerini karşılamıyorsa ardışık düzen burada durur ve model dağıtılmaz.
3. adım: Uçtan uca ML ardışık düzenini derleyip çalıştırın
Tam ardışık düzenimiz tanımlandığında, derleme zamanı gelmiştir:
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()
Konsolda ardışık düzeninizi 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ızın büyük bir kısmı AutoML eğitim adımında geçer. Tamamlanmış ardışık düzen aşağıdaki gibi görünür:
Üstteki "Öğeleri genişlet" düğmesini etkinleştirirseniz ardışık düzeninizden oluşturulan farklı öğelerin ayrıntılarını görebilirsiniz. Örneğin, dataset yapısını tıklarsanız oluşturulan Vertex AI veri kümesinin ayrıntılarını görürsünüz. Bu 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 karışıklık matrisini görebilirsiniz:
Bu ardışık düzen çalıştırmasından oluşturulan modeli ve uç noktayı görmek için modeller bölümüne gidip automl-beans adlı modeli tıklayın. Burada, bu modelin bir uç noktaya dağıtıldığını görürsünüz:
Bu sayfaya, ardışık düzen grafiğinizde bitiş noktası yapısını tıklayarak da erişebilirsiniz.
Konsolda ardışık düzen grafiğine bakmanın yanı sıra soy ağacı izleme için Vertex Ardışık Düzenleri'ni de kullanabilirsiniz. Soy ağacı izleme, ardışık düzeninizde oluşturulan yapıları izleme anlamına gelir. Bu sayede, yapıların nerede oluşturulduğunu ve bir makine öğrenimi iş akışında nasıl kullanıldığını anlayabiliriz. Örneğin, bu ardışık düzende oluşturulan veri kümesinin soy ağacı izlemesini görmek için veri kümesi yapısını ve ardından Soy Ağacını Görüntüle'yi tıklayın:
Bu, bu yapının kullanıldığı tüm yerleri gösterir:
4. Adım: Ardışık düzen çalıştırmalarında metrikleri karşılaştırma
Bu ardışık düzeni birden çok kez çalıştırırsanız çalıştırmalar arasındaki metrikleri karşılaştırmak isteyebilirsiniz. Kampanya meta verilerine erişmek için aiplatform.get_pipeline_df() yöntemini kullanabilirsiniz. Burada, bu ardışık düzenin tüm çalıştırmalarının meta verilerini alıp bir 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
Bu işlemle birlikte laboratuvarı tamamladınız.
🎉 Tebrikler. 🎉
Aşağıdakiler için Vertex AI'ı nasıl kullanacağınızı öğrendiniz:
- Özel bileşenlerle uçtan uca ardışık düzenler oluşturmak için Kubeflow Pipelines SDK'sını kullanın
- Ardışık düzenlerinizi Vertex Pipelines'de çalıştırma ve SDK ile ardışık düzen çalıştırma işlemlerini 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
Ücret ödememek 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ızda kapatmanız önerilir. Cloud Console'daki Not Defteri kullanıcı arayüzünde not defterini, 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 sil simgesini tıklayın:
Ardından, aşağıdaki istemde Yayından kaldır'ı tıklayın:
Son olarak, konsolunuzun Modeller bölümüne gidin, ilgili modeli bulun ve sağdaki üç noktalı menüden Modeli sil'i tıklayın:
3. adım: Cloud Storage paketinizi silin
Depolama paketini silmek için Cloud Console'daki Gezinme menüsünü kullanarak Depolama'ya gidin, paketinizi seçin ve Sil'i tıklayın:
