Vertex AI: Hiperparametre Ayarı

1. Genel Bakış

Bu laboratuvarda, bir TensorFlow modeli için hiperparametre ayarlama işi çalıştırmak üzere Vertex AI'ı kullanacaksınız. Bu laboratuvarda model kodu için TensorFlow kullanılsa da kavramlar diğer makine öğrenimi çerçeveleri için de geçerlidir.

Öğrenecekleriniz

Öğrenecekleriniz:

• Otomatik hiperparametre ayarı için eğitim uygulaması kodunu değiştirme
• Vertex AI kullanıcı arayüzünden hiperparametre ayarı işi yapılandırma ve başlatma
• Vertex AI Python SDK ile hiperparametre ayarlama işini yapılandırma ve başlatma

Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 3 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. Geri bildiriminiz varsa lütfen destek sayfasına göz atın.

Vertex AI, uçtan uca makine öğrenimi iş akışlarını desteklemek için birçok farklı ürün içerir. Bu laboratuvarda, aşağıda vurgulanan ürünlere odaklanılacaktır: Training ve Workbench.

3. Ortamınızı ayarlama

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: Compute Engine API'yi etkinleştirin

Compute Engine'e gidin ve henüz etkinleştirilmemişse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için bu bilgiye ihtiyacınız vardır.

2. adım: Container Registry API'yi etkinleştirin

Container Registry'ye gidin ve henüz etkin değilse Etkinleştir'i seçin. Bu dosyayı, özel eğitim işiniz için bir kapsayıcı oluşturmak üzere kullanacaksınız.

3. adım: Vertex AI API'yi etkinleştirin

Cloud Console'unuzun Vertex AI bölümüne gidin ve Vertex AI API'yi etkinleştir'i tıklayın.

4. adım: Vertex AI Workbench örneği oluşturma

Cloud Console'unuzun Vertex AI bölümünde Workbench'i tıklayın:

Henüz etkinleştirilmemişse Notebooks API'yi etkinleştirin.

Etkinleştirildikten sonra YÖNETİLEN NOT DEFTERLERİ'ni tıklayın:

Ardından YENİ NOT DEFTERİ'ni seçin.

Not defterinize bir ad verin ve Gelişmiş Ayarlar'ı tıklayın.

Gelişmiş Ayarlar'da boşta kalma durumunda kapatma özelliğini etkinleştirin ve süreyi 60 dakika olarak ayarlayın. Bu sayede, gereksiz maliyetlere yol açmamak için not defteriniz kullanılmadığında otomatik olarak kapatılır.

Güvenlik bölümünde, henüz etkinleştirilmemişse "Terminali etkinleştir"i seçin.

Diğer tüm gelişmiş ayarları olduğu gibi bırakabilirsiniz.

Ardından Oluştur'u tıklayın. Örneğin sağlanması birkaç dakika sürer.

Örnek oluşturulduktan sonra Open JupyterLab'i (JupyterLab'i aç) seçin.

Yeni bir örneği ilk kez kullandığınızda kimlik doğrulamanız istenir. Bunun için kullanıcı arayüzündeki adımları uygulayın.

4. Eğitim uygulaması kodunu kapsayıcıya alma

Bu laboratuvarda eğiteceğiniz ve ayarlayacağınız model, TensorFlow Datasets'teki horses or humans veri kümesi üzerinde eğitilmiş bir görüntü sınıflandırma modelidir.

Eğitim uygulama kodunuzu bir Docker container'ına yerleştirip bu container'ı Google Container Registry'ye aktararak bu hiperparametre ayarlama işini Vertex AI'a gönderirsiniz. Bu yaklaşımı kullanarak herhangi bir çerçeveyle oluşturulmuş bir modelin hiperparametrelerini ayarlayabilirsiniz.

Başlamak için Başlatıcı menüsünden not defteri örneğinizde bir Terminal penceresi açın:

horses_or_humans adlı yeni bir dizin oluşturun ve bu dizine gidin:

mkdir horses_or_humans
cd horses_or_humans

1. adım: Dockerfile oluşturun

Kodunuzu kapsayıcılaştırmanın ilk adımı Dockerfile oluşturmaktır. Dockerfile'da, görüntüyü çalıştırmak için gereken tüm komutları eklersiniz. CloudML Hypertune kitaplığı dahil olmak üzere gerekli tüm kitaplıkları yükler ve eğitim kodunun giriş noktasını ayarlar.

Terminalinizden boş bir Dockerfile oluşturun:

touch Dockerfile

Dockerfile'ı açın ve aşağıdakileri kopyalayın:

FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-7

WORKDIR /

# Installs hypertune library
RUN pip install cloudml-hypertune

# Copies the trainer code to the docker image.
COPY trainer /trainer

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]

Bu Dockerfile, Deep Learning Container TensorFlow Enterprise 2.7 GPU Docker görüntüsünü kullanır. Google Cloud'daki Deep Learning Container'larında birçok yaygın makine öğrenimi ve veri bilimi çerçevesi önceden yüklenmiş olarak gelir. Bu görüntüyü indirdikten sonra bu Dockerfile, eğitim kodu için giriş noktasını ayarlar. Bu dosyaları henüz oluşturmadınız. Bir sonraki adımda, modeli eğitmek ve ayarlamak için kodu ekleyeceksiniz.

2. adım: Model eğitimi kodu ekleyin

Terminalinizde aşağıdaki komutu çalıştırarak eğitim kodu için bir dizin ve kodu ekleyeceğiniz bir Python dosyası oluşturun:

mkdir trainer
touch trainer/task.py

horses_or_humans/ dizininizde artık şunlar olmalıdır:

+ Dockerfile
+ trainer/
    + task.py

Ardından, yeni oluşturduğunuz task.py dosyasını açın ve aşağıdaki kodu kopyalayın.

import tensorflow as tf
import tensorflow_datasets as tfds
import argparse
import hypertune

NUM_EPOCHS = 10


def get_args():
  '''Parses args. Must include all hyperparameters you want to tune.'''

  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--learning_rate',
      required=True,
      type=float,
      help='learning rate')
  parser.add_argument(
      '--momentum',
      required=True,
      type=float,
      help='SGD momentum value')
  parser.add_argument(
      '--num_units',
      required=True,
      type=int,
      help='number of units in last hidden layer')
  args = parser.parse_args()
  return args


def preprocess_data(image, label):
  '''Resizes and scales images.'''

  image = tf.image.resize(image, (150,150))
  return tf.cast(image, tf.float32) / 255., label


def create_dataset():
  '''Loads Horses Or Humans dataset and preprocesses data.'''

  data, info = tfds.load(name='horses_or_humans', as_supervised=True, with_info=True)

  # Create train dataset
  train_data = data['train'].map(preprocess_data)
  train_data  = train_data.shuffle(1000)
  train_data  = train_data.batch(64)

  # Create validation dataset
  validation_data = data['test'].map(preprocess_data)
  validation_data  = validation_data.batch(64)

  return train_data, validation_data


def create_model(num_units, learning_rate, momentum):
  '''Defines and compiles model.'''

  inputs = tf.keras.Input(shape=(150, 150, 3))
  x = tf.keras.layers.Conv2D(16, (3, 3), activation='relu')(inputs)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu')(x)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu')(x)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Flatten()(x)
  x = tf.keras.layers.Dense(num_units, activation='relu')(x)
  outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
  model = tf.keras.Model(inputs, outputs)
  model.compile(
      loss='binary_crossentropy',
      optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=momentum),
      metrics=['accuracy'])
  return model


def main():
  args = get_args()
  train_data, validation_data = create_dataset()
  model = create_model(args.num_units, args.learning_rate, args.momentum)
  history = model.fit(train_data, epochs=NUM_EPOCHS, validation_data=validation_data)

  # DEFINE METRIC
  hp_metric = history.history['val_accuracy'][-1]

  hpt = hypertune.HyperTune()
  hpt.report_hyperparameter_tuning_metric(
      hyperparameter_metric_tag='accuracy',
      metric_value=hp_metric,
      global_step=NUM_EPOCHS)


if __name__ == "__main__":
    main()

Kapsayıcıyı oluşturmadan önce koda daha yakından bakalım. Hiperparametre ayarlama hizmetini kullanmaya özgü birkaç bileşen vardır.

1. Komut dosyası, hypertune kitaplığını içe aktarır. 1. adımda yer alan Dockerfile dosyasının, bu kitaplığı pip ile yükleme talimatlarını içerdiğini unutmayın.
2. get_args() işlevi, ayarlamak istediğiniz her hiperparametre için bir komut satırı bağımsız değişkeni tanımlar. Bu örnekte, ayarlanacak hiperparametreler öğrenme hızı, optimize edicideki momentum değeri ve modelin son gizli katmanındaki birim sayısıdır. Ancak diğerleriyle de deneme yapabilirsiniz. Bu bağımsız değişkenlerde iletilen değer, daha sonra kodda ilgili hiperparametreyi ayarlamak için kullanılır.
3. main() işlevinin sonunda, optimize etmek istediğiniz metriği tanımlamak için hypertune kitaplığı kullanılır. TensorFlow'da keras model.fit yöntemi, History nesnesi döndürür. History.history özelliği, eğitim kaybı değerlerinin ve metrik değerlerinin ardışık dönemlerdeki kaydıdır. Doğrulama verilerini model.fit öğesine iletirseniz History.history özelliği, doğrulama kaybını ve metrik değerlerini de içerir. Örneğin, doğrulama verileriyle üç dönem boyunca bir modeli eğittiyseniz ve metrik olarak accuracy sağladıysanız History.history özelliği aşağıdaki sözlüğe benzer görünür.

{
 "accuracy": [
   0.7795261740684509,
   0.9471358060836792,
   0.9870933294296265
 ],
 "loss": [
   0.6340447664260864,
   0.16712145507335663,
   0.04546636343002319
 ],
 "val_accuracy": [
   0.3795261740684509,
   0.4471358060836792,
   0.4870933294296265
 ],
 "val_loss": [
   2.044623374938965,
   4.100203514099121,
   3.0728273391723633
 ]

Hiperparametre ayarlama hizmetinin, modelin doğrulama doğruluğunu en üst düzeye çıkaran değerleri bulmasını istiyorsanız metriği val_accuracy listesinin son girişi (veya NUM_EPOCS - 1) olarak tanımlarsınız. Ardından, bu metriği HyperTune örneğine iletin. hyperparameter_metric_tag için istediğiniz dizeyi seçebilirsiniz ancak hiperparametre ayarlama işini başlattığınızda bu dizeyi tekrar kullanmanız gerekir.

3. adım: Kapsayıcıyı oluşturun

Terminalinizde, projeniz için bir ortam değişkeni tanımlamak üzere aşağıdakileri çalıştırın. your-cloud-project yerine projenizin kimliğini yazdığınızdan emin olun:

Proje kimliğinizi, terminalinizde gcloud config list --format 'value(core.project)' komutunu çalıştırarak alabilirsiniz.

PROJECT_ID='your-cloud-project'

Google Container Registry'deki container görüntünüzün URI'siyle bir değişken tanımlayın:

IMAGE_URI="gcr.io/$PROJECT_ID/horse-human:hypertune"

Docker'ı yapılandırma

gcloud auth configure-docker

Ardından, horses_or_humans dizininizin kökünden aşağıdaki komutu çalıştırarak kapsayıcıyı oluşturun:

docker build ./ -t $IMAGE_URI

Son olarak, Google Container Registry'ye aktarın:

docker push $IMAGE_URI

Kapsayıcı Container Registry'ye aktarıldığına göre artık özel model hiperparametre ayarlama işini başlatmaya hazırsınız.

5. Vertex AI'da hiperparametre ayarlama işi çalıştırma

Bu laboratuvarda, Google Container Registry'deki özel bir container aracılığıyla özel eğitim kullanılır. Ancak Vertex AI önceden oluşturulmuş container ile bir hiperparametre ayarlama işi de çalıştırabilirsiniz.

Başlamak için Cloud Console'unuzun Vertex bölümündeki Eğitim bölümüne gidin:

1. adım: Eğitim işini yapılandırın

Hiperparametre ayarlama işinizin parametrelerini girmek için Oluştur'u tıklayın.

• Veri kümesi bölümünde Yönetilen veri kümesi yok'u seçin.
• Ardından eğitim yönteminiz olarak Özel eğitim (gelişmiş)'i seçip Devam'ı tıklayın.
• Model adı için horses-humans-hyptertune (veya modelinize vermek istediğiniz adı) girin.
• Devam et'i tıklayın.

Kapsayıcı ayarları adımında Özel kapsayıcı'yı seçin:

İlk kutuya (Container image), önceki bölümdeki IMAGE_URI değişkeninizin değerini girin. Şu şekilde olmalıdır: gcr.io/your-cloud-project/horse-human:hypertune, kendi proje adınızla. Diğer alanları boş bırakıp Devam'ı tıklayın.

2. adım: Hiperparametre ayarlama işini yapılandırın

Hiperparametre ayarlamayı etkinleştir'i seçin.

Hiperparametreleri yapılandırma

Ardından, eğitim uygulama kodunda komut satırı bağımsız değişkenleri olarak ayarladığınız hiperparametreleri eklemeniz gerekir. Hiperparametre eklerken önce adı girmeniz gerekir. Bu, argparse işlevine ilettiğiniz bağımsız değişken adıyla eşleşmelidir.

Ardından, türü ve ayarlama hizmetinin deneyeceği değerlerin sınırlarını seçersiniz. Çift veya Tam Sayı türünü seçerseniz minimum ve maksimum değer sağlamanız gerekir. Kategorik veya Ayrı seçeneğini belirlerseniz değerleri sağlamanız gerekir.

Çift ve Tam Sayı türleri için ölçekleme değerini de sağlamanız gerekir.

learning_rate hiperparametresini ekledikten sonra momentum ve num_units için parametreler ekleyin.

Metriği Yapılandırma

Hiperparametreleri ekledikten sonra, optimize etmek istediğiniz metriği ve hedefi sağlarsınız. Bu, eğitim uygulamanızda ayarladığınız hyperparameter_metric_tag ile aynı olmalıdır.

Vertex AI hiperparametre ayarlama hizmeti, eğitim uygulamanızın önceki adımlarda yapılandırılan değerlerle birden fazla denemesini çalıştırır. Hizmetin çalıştıracağı deneme sayısına bir üst sınır koymanız gerekir. Daha fazla deneme genellikle daha iyi sonuçlar verir ancak ek denemelerin, optimize etmeye çalıştığınız metrik üzerinde çok az veya hiç etkisi olmayacağı bir nokta vardır. Daha fazla denemeye geçmeden önce daha az sayıda denemeyle başlayıp seçtiğiniz hiperparametrelerin ne kadar etkili olduğunu anlamak en iyi uygulamadır.

Ayrıca, paralel deneme sayısına bir üst sınır belirlemeniz gerekir. Paralel deneme sayısını artırmak, hiperparametre ayarlama işinin çalışması için gereken süreyi azaltır ancak işin genel etkinliğini düşürebilir. Bunun nedeni, varsayılan ayarlama stratejisinin sonraki denemelerde değerlerin atanması konusunda bilgi vermek için önceki denemelerin sonuçlarını kullanmasıdır. Çok fazla denemeyi paralel olarak çalıştırırsanız devam eden denemelerin sonuçlarından yararlanmadan başlatılan denemeler olur.

Gösterim amacıyla deneme sayısını 15, maksimum paralel deneme sayısını ise 3 olarak ayarlayabilirsiniz. Farklı sayılarla denemeler yapabilirsiniz ancak bu, daha uzun bir ayarlama süresine ve daha yüksek maliyete neden olabilir.

Son adım, arama algoritması olarak "Varsayılan"ı seçmektir. Bu algoritma, hiperparametre ince ayarı için Bayes optimizasyonu gerçekleştirmek üzere Google Vizier'i kullanır. Bu algoritma hakkında daha fazla bilgiyi buradan edinebilirsiniz.

Devam'ı tıklayın.

3. adım: İşlemi yapılandırın

Compute and pricing (İşlem ve fiyatlandırma) bölümünde, seçili bölgeyi olduğu gibi bırakın ve Worker pool 0'ı (Çalışma düğümü havuzu 0) aşağıdaki gibi yapılandırın.

Not: GPU kullanımı isteğe bağlıdır. GPU kullanmazsanız hiperparametre ayarlama işinin tamamlanması biraz daha uzun sürer.

Hiperparametre ayarlama işini başlatmak için Eğitimi başlat'ı tıklayın. Konsolunuzun Eğitim bölümündeki HYPERPARAMETER TUNING JOBS (Hiperparametre Ayarlama İşleri) sekmesinde şuna benzer bir şey görürsünüz:

Hiperparametre ayarlama işinin tamamlanması yaklaşık 30-40 dakika sürer.

İşlem tamamlandığında işin adını tıklayarak ayarlama denemelerinin sonuçlarını görebilirsiniz.

🎉 Tebrikler! 🎉

Vertex AI'ı kullanarak şunları yapmayı öğrendiniz:

• Özel bir container'da sağlanan eğitim kodu için hiperparametre ayarlama işi başlatın. Bu örnekte bir TensorFlow modeli kullandınız ancak özel kapsayıcıları kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebilirsiniz.

Vertex'in farklı bölümleri hakkında daha fazla bilgi edinmek için belgelere göz atın.

6. [İsteğe bağlı] Vertex SDK'yı kullanma

Önceki bölümde, hiperparametre ayarlama işinin kullanıcı arayüzü üzerinden nasıl başlatılacağı gösterilmişti. Bu bölümde, Vertex Python API'yi kullanarak hiperparametre ayarlama işini göndermenin alternatif bir yolunu göreceksiniz.

Başlatıcı'dan TensorFlow 2 not defteri oluşturun.

Vertex AI SDK'yı içe aktarın.

from google.cloud import aiplatform
from google.cloud.aiplatform import hyperparameter_tuning as hpt

Hiperparametre ayarlama işini başlatmak için önce aşağıdaki özellikleri tanımlamanız gerekir. image_uri içindeki {PROJECT_ID} yerine projenizi yazmanız gerekir.

# The spec of the worker pools including machine type and Docker image
# Be sure to replace PROJECT_ID in the `image_uri` with your project.

worker_pool_specs = [{
    "machine_spec": {
        "machine_type": "n1-standard-4",
        "accelerator_type": "NVIDIA_TESLA_V100",
        "accelerator_count": 1
    },
    "replica_count": 1,
    "container_spec": {
        "image_uri": "gcr.io/{PROJECT_ID}/horse-human:hypertune"
    }
}]


# Dictionary representing metrics to optimize.
# The dictionary key is the metric_id, which is reported by your training job,
# And the dictionary value is the optimization goal of the metric.
metric_spec={'accuracy':'maximize'}

# Dictionary representing parameters to optimize.
# The dictionary key is the parameter_id, which is passed into your training
# job as a command line argument,
# And the dictionary value is the parameter specification of the metric.
parameter_spec = {
    "learning_rate": hpt.DoubleParameterSpec(min=0.001, max=1, scale="log"),
    "momentum": hpt.DoubleParameterSpec(min=0, max=1, scale="linear"),
    "num_units": hpt.DiscreteParameterSpec(values=[64, 128, 512], scale=None)
}

Ardından CustomJob oluşturun. {YOUR_BUCKET} yerine projenizde hazırlama için bir paket kullanmanız gerekir.

# Replace YOUR_BUCKET
my_custom_job = aiplatform.CustomJob(display_name='horses-humans-sdk-job',
                              worker_pool_specs=worker_pool_specs,
                              staging_bucket='gs://{YOUR_BUCKET}')

Ardından, HyperparameterTuningJob oluşturup çalıştırın.

hp_job = aiplatform.HyperparameterTuningJob(
    display_name='horses-humans-sdk-job',
    custom_job=my_custom_job,
    metric_spec=metric_spec,
    parameter_spec=parameter_spec,
    max_trial_count=15,
    parallel_trial_count=3)

hp_job.run()

7. Temizleme

Not defterini 60 dakika boşta kaldıktan sonra zaman aşımına uğrayacak şekilde yapılandırdığımız için örneği kapatmamız gerekmez. Örneği manuel olarak kapatmak istiyorsanız konsolun Vertex AI Workbench bölümündeki Durdur düğmesini tıklayın. Not defterini tamamen silmek isterseniz Sil düğmesini tıklayın.

Cloud Console'unuzdaki gezinme menüsünü kullanarak Storage paketini silmek için Storage'a gidin, paketinizi seçin ve Sil'i tıklayın: