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 derlemek için Kubeflow Pipelines SDK'yı kullanma
- Metin girişi alan 3 adımlı bir giriş ardışık düzeni oluşturup çalıştırın
- AutoML sınıflandırma modelini eğiten, değerlendiren ve dağıtan bir ardışık düzen oluşturma ve ç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 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, 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. Vertex AI'ın sunduğu tüm ürün tekliflerini aşağıdaki şemada görebilirsiniz.
Geri bildiriminiz varsa lütfen destek sayfasını inceleyin.
Makine öğrenimi ardışık düzenleri neden faydalıdır?
Başlamadan önce, neden bir ardışık düzen kullanmak isteyeceğinizi öğrenelim. Veri işleme, model eğitme, hiperparametre ayarı, değerlendirme ve model dağıtımı özelliklerini içeren bir ML 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, makine öğrenimi iş akışınızı ekibinizdeki diğer kişilerle paylaşarak onların da çalıştırıp kod katkısında bulunmasına yardımcı olabilirsiniz. Güvenilir, tekrarlanabilir bir süreç olmadan bu zor olabilir. Ardışık düzenler sayesinde makine öğrenimi sürecinizdeki her adım kendi container'ıdır. Bu, adımları bağımsız olarak geliştirmenize ve her adımdaki giriş ve çıkışı tekrarlanabilir bir şekilde izlemenize olanak tanır. Ayrıca, yeni eğitim verileri kullanılabilir olduğunda bir 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ırılması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 var. 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 çevirmeni olan Cloud Shell oturumunda çalışacaksınız. Bu bölümü yerel olarak kendi bilgisayarınızda da yerel olarak çalıştırabilirsiniz. Ancak Cloud Shell kullanarak herkes tutarlı bir ortamda tekrarlanabilir bir deneyime erişebilir. Laboratuvardan sonra bu bölümü bilgisayarınızda yeniden deneyebilirsiniz.
Cloud Shell'i etkinleştirme
Cloud Console'un sağ üst köşesinden 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ında) gösterilir. Bu durumda Devam'ı tıklayın (bunu bir daha görmezsiniz). Tek seferlik ekran şöyle görünür:
Temel hazırlık ve Cloud Shell'e bağlanmak yalnızca birkaç dakika sürer.
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ışarak ağ performansını ve kimlik doğrulamasını büyük ölçüde iyileştirir. Bu codelab'deki çalışmalarınızın tamamı olmasa bile 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 ayarlandığını görürsünüz.
Kimlik doğrulamanızın tamamlandığını onaylamak için Cloud Shell'de aşağıdaki komutu çalıştırın:
gcloud auth list
Komut çıkışında şuna benzer bir çıkış 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>
Doğru değilse aşağıdaki komutla ayarlayabilirsiniz:
gcloud config set project <PROJECT_ID>
Komut çıkışı
Updated property [core/project].
Cloud Shell'de birkaç ortam değişkeni bulunur. Bunların arasında mevcut Cloud projemizin adını içeren GOOGLE_CLOUD_PROJECT yer alır. Bu adı, bu laboratuvar boyunca çeşitli yerlerde kullanacağız. Bu klasörü şu komutu çalıştırarak 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 kullanıyoruz, ancak başka bir bölge de kullanabilirsiniz (bu laboratuvar boyunca başka bir bölgeyi değiştirmeniz yeterlidir). Zaten 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, işlem hizmeti hesabımızın bu pakete erişmesine izin vereceğiz. Bu sayede Vertex Pipelines bu pakete dosya yazmak için gerekli izinlere sahip olur. 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 Defteri'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 ardından 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'ı kullanmak için yüklememiz gereken birkaç kitaplık daha 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 derlenen ardışık düzenlerin çalıştırılmasını destekler.
- Google Cloud Ardışık Düzeni Bileşenleri: Bu kitaplık, ardışık düzen adımlarınızdan Vertex AI hizmetleriyle etkileşime geçmeyi kolaylaştıran önceden oluşturulmuş bileşenler sağlar.
1. adım: Python not defteri oluşturun ve kitaplıkları yükleyin
Öncelikle 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öşesindeki + 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ğıdaki komutu ç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. Şimdi, bunların her biri için değişkenler oluşturacağız.
Proje kimliğinizi bilmiyorsanız aşağıdaki kodu ç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 halde buradan ayarlayın:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Ardından paket adınızı kaydedecek bir değişken oluşturun. Projeyi bu laboratuvarda oluşturduysanız aşağıdaki adımlar işinize 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çiminde olacaktır
5. İlk ardışık düzeninizi oluşturma
Vertex Pipelines'ın işleyiş şekline aşina olmak için önce KFP SDK'sını kullanarak kısa bir ardışık düzen oluşturacağız. Bu ardışık düzen, makine öğrenimiyle ilgili hiçbir şey yapmaz (endişelenmeyin, size ulaşacağız!), bunu size öğretmek için kullanıyoruz:
- KFP SDK'sında özel bileşenler oluşturma
- Vertex Pipelines'da ardışık düzen çalıştırma ve izleme
Ürün adı ve emoji açıklaması olmak üzere iki çıkış kullanarak cümleyi yazdıran bir ardışık düzen oluşturacağız. Bu ardışık düzen üç bileşenden oluşur:
product_name: Bu bileşen, girdi olarak ürün adını (veya gerçekten istediğiniz herhangi bir ismi) alır ve bu dizeyi çıktı olarak döndürür.emoji: Bu bileşen, emojinin metin açıklamasını alıp emojiye dönüştürür. Örneğin, ✨ için metin kodu "parıltılar"dır. 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ırbuild_sentence: Bu son bileşen, emojinin kullanıldığı bir cümle oluşturmak için önceki iki öğenin çıkışını kullanır. Örneğin, "Vertex Ardışık Düzenleri ✨" şeklinde bir çıkış elde edersiniz.
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. Bunu ilk ardışık düzenimizdeki 3 bileşen için 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. Aşağıdakileri not defterinize 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 yazdığınızda 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 söz konusu 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. Aktarılan giriş metnini ve ortaya çıkan emojiyi içeren bir devir 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 öncekinden biraz daha karmaşıktır. Yeniliklere göz atalım:
packages_to_installparametresi, bileşene bu container'ın 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 unsurdaki dizelerin her birinin şu anahtarlara sahip olduğuna dikkat edin:emoji_textveemoji. Bunları çıkışa erişmek için bir sonraki bileşenimizde kullanacağız.
Bu ardışık düzendeki son bileşen, ilk ikisinin çıkışını kullanır ve bir dize döndürmek için bunları bir araya getirir:
@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)
Merak ediyor olabilirsiniz: Bu bileşen, tanımladığınız önceki adımlarda sağlanan çıktıyı kullanacağını nasıl biliyor? Güzel soru! Bir sonraki adımda bunları birbirine bağlayacağız.
3. adım: Bileşenleri bir ardışık düzende 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ş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 girin, ardından 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ı belirtir. Bu giriş ardışık düzeni hiç oluşturmaz ama bir sonraki ardışık düzenimiz oluşturur.
Bir sonraki kod bloğunda intro_pipeline fonksiyonunu tanımlıyoruz. Burada, başlangıçtaki ardışık düzen adımlarımıza girişleri ve adımların birbirine nasıl bağlanacağını belirleriz:
product_task, ürün adını giriş olarak alır. Burada, "Vertex Pipelines"ı ama bunu istediğiniz gibi değiştirebilirsiniz.emoji_task, emojinin metin kodunu giriş olarak alır. Ayrıca bu ayarı dilediğiniz gibi değiştirebilirsiniz. Örneğin, "party_face" 🥳 emojidir. 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 olan
consumer_tasküç giriş parametresine sahiptir:product_taskçıktısı. Bu adım yalnızca bir çıkış ürettiğindenproduct_task.outputaracılığıyla bunu referans alabiliriz.emoji_taskadımımızınemojiçıkışı. Yukarıda tanımlanan, çıkış parametrelerini adlandırdığımızemojibileşenine bakın.- Benzer şekilde,
emojibileşenindekiemoji_textadlandırılmış çıkışı. Ardışık düzenimiz, emojiye karşılık gelmeyen bir metin iletildiğinde, cümleyi 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ıktan sonra derlemeye hazırsınız demektir. Aşağıdaki işlem, 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"
)
Sonra, bir TIMESTAMP değişkeni oluşturun. İş kimliğimizde bunu 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ükleri göreceksiniz:
Bu bağlantıya gidin. Ardışık düzeniniz tamamlandığında aşağıdaki gibi görünmelidir:
Bu ardışık düzenin 5-6 dakikada çalışması gerekir. İşlem tamamlandığında, nihai çıkışı görmek için build-sentence bileşenini tıklayabilirsiniz:
Artık KFP SDK'nın ve Vertex Pipelines'ın işleyiş şekli hakkında bilgi sahibi olduğunuza göre diğer Vertex AI hizmetlerini kullanarak ML modeli oluşturan ve dağıtan bir ardışık düzen derlemeye 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 derleme zamanı geldi. Bu ardışık düzende KOKLU, M. ve OZKAN, I.A., (2020), "Bilgisayar Görüşü ve Makine Öğrenimi Tekniklerini Kullanarak Kuru Fasulyelerin Çok Sınıflı Sınıflandırılması.""Tarımda Bilgisayar ve Elektronikte, 174, 105507. DOI.
Bu tablo biçiminde bir veri kümesidir. Ardışık düzenimizde, çekirdekleri özelliklerine göre 7 türden birinde sınıflandıran bir AutoML modelini eğitmek, değerlendirmek ve dağıtmak için bu veri kümesini kullanacağız.
Bu ardışık düzende:
- ürününde bir Veri Kümesi oluşturun
- AutoML ile tablo biçiminde sınıflandırma modeli eğitme
- Bu modelle ilgili değerlendirme metrikleri al
- Değerlendirme metriklerine göre, Vertex Pipelines'da koşullu mantığı kullanarak modeli dağıtıp dağıtmayacağınıza karar verin
- Vertex Prediction'ı kullanarak modeli bir uç noktaya dağıtma
Ana hatlarıyla açıklanan 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 ilk olarak bir özel bileşen tanımlayacağız. Ardından, önceden oluşturulmuş bileşenleri kullanarak geri kalan ardışık düzen 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ımladığımız özel bileşen, model eğitimi tamamlandıktan sonra ardışık düzenimizin sonuna doğru kullanılacaktır. Bu bileşen birkaç işlem yapar:
- Eğitilmiş AutoML sınıflandırma modelinden değerlendirme metriklerini alın
- Metrikleri ayrıştırıp 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; Cloud projemizde bazı meta verileri, sonuçta ortaya çıkan eğitilmiş model (bu bileşeni daha sonra tanımlayacağız), modelin değerlendirme metrikleri 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 bu, modeli dağıtmamız gereken ROC eğrisi değerinin altındaki alandır. Örneğin, 0,95'i geçersek bu, yalnızca söz konusu metriğin %95'in üzerinde olması durumunda ardışık düzenimizin modeli dağıtmasını isteyeceğ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 birlikte bakalım:
- İlk olarak, önceki ardışık düzenimizde olduğu gibi, bu ardışık düzenin kullandığı giriş parametrelerini tanımlıyoruz. Ardışık düzendeki diğer adımların sonuçlarına bağlı olmadıklarından bu ayarları manuel olarak yapmamız gerekir.
- Ardışık düzenin geri kalanında, Vertex AI hizmetleriyle etkileşim için önceden oluşturulmuş birkaç bileşen kullanılır:
TabularDatasetCreateOp, Cloud Storage veya BigQuery'deki bir veri kümesi kaynağına bağlı olarak Vertex AI'da tablo biçiminde bir veri kümesi oluşturur. Bu ardışık düzende, verileri bir BigQuery tablo URL'si aracılığıyla iletiyoruzAutoMLTabularTrainingJobRunOp, tablo biçiminde bir veri kümesi için AutoML eğitim işi başlattı. Bu bileşene, model türü (bu örnekte sınıflandırma), sütunlardaki bazı veriler, eğitimi ne kadar süreyle çalıştırmak istediğimiz ve veri kümesine işaret eden bir işaret de dahil olmak üzere birkaç yapılandırma parametresi iletiriz. Veri kümesini bu bileşene iletmek için önceki bileşenin çıkışınıdataset_create_op.outputs["dataset"]aracılığıyla sağladığımızı unutmayınEndpointCreateOp, Vertex AI'da uç nokta oluşturur. Bu adımdan oluşturulan uç nokta, sonraki bileşene giriş olarak iletilirModelDeployOp, belirli bir modeli Vertex AI'daki 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ın çıkışlarına erişerek modeli iletiyoruz.
- Bu ardışık düzen, Vertex Pipelines'ın bir koşulu tanımlamanıza ve bu koşulun sonucuna göre farklı dalları tanımlamanıza olanak tanıyan koşullu mantık özelliğinden de yararlanı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 codelab'de daha önce tanımladığımız özel değerlendirme bileşeninin çıkışıdır. Bu koşul karşılanırsa ardışık düzen,deploy_opbileşenini yürütmeye devam eder. Doğruluk, önceden tanımlı eşiğimizi karşılamıyorsa ardışık düzen burada durur ve model dağıtmaz.
3. Adım: Uçtan uca makine öğrenimi ardışık düzenini derleyin ve çalıştırın
Ardışık düzenimizi tanımladıktan sonra sıra onu derlemeye gelir:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="tab_classif_pipeline.json"
)
Sonra, 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ışması bir saatten biraz uzun sürer. Zamanın büyük bir kısmı AutoML eğitim adımında harcanır. Tamamlanmış ardışık düzen aşağıdaki gibi görünür:
"Yapıları genişlet" ayarını açar/kapatırsanız düğmesini tıkladığınızda ardışık düzeninizden oluşturulan farklı yapıların 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 modele ilişkin 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öreceksiniz:
Bu sayfaya, ardışık düzen grafiğinizdeki uç nokta yapısını tıklayarak da erişebilirsiniz.
Konsolda ardışık düzen grafiğine bakmanın yanı sıra Sıra İzleme için Vertex Pipelines'ı da kullanabilirsiniz. Sıra takibi, ardışık düzeninizde oluşturulan yapıları takip etmek anlamına gelir. Bu, yapıların nerede oluşturulduğunu ve makine öğrenimi iş akışı boyunca nasıl kullanıldığını anlamamıza yardımcı olabilir. Örneğin, bu ardışık düzende oluşturulan veri kümesinin sıra takibini görmek için, veri kümesi yapısını ve ardından Seriyi Görüntüle'yi tıklayın:
Bu yapı bize, söz konusu 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 genelinde 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ı tamamlamış oldunuz.
🎉 Tebrikler! 🎉
Vertex AI'ı kullanarak şunları öğrendiniz:
- Özel bileşenlerle uçtan uca ardışık düzenler derlemek için Kubeflow Pipelines SDK'yı kullanın
- Ardışık düzenlerinizi Vertex Pipelines'da çalıştırın ve SDK ile ardışık düzen çalıştırmalarını başlatın
- Konsolda Vertex Pipelines grafiğinizi görüntüleme ve analiz etme
- Ardışık düzeninize Vertex AI hizmetlerini eklemek için önceden oluşturulmuş ardışık düzen bileşenlerini kullanın
- Yinelenen ardışık düzen işlerini planlama
Vertex'in farklı bölümleri hakkında daha fazla bilgi edinmek için dokümanlara göz atın.
7. Temizleme
Ücret ödememek için bu laboratuvar boyunca oluşturulan kaynakları silmeniz önerilir.
1. Adım: Notebooks örneğinizi durdurun veya silin
Bu laboratuvarda oluşturduğunuz not defterini kullanmaya devam etmek istiyorsanız, kullanmadığınız not defterini kapatmanız önerilir. Cloud Console'daki Notebooks kullanıcı arayüzünde not defterini, ardından Stop'ı (Durdur) 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 gidip sil simgesini tıklayın:
Ardından aşağıdaki istemde Undeploy'u 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
Storage Paketini silmek için Cloud Console'unuzdaki gezinme menüsünü kullanarak Storage'a gidin, paketinizi seçin ve Sil'i tıklayın:
