Vertex AI: Dağıtılmış hiperparametre ayarı

1. Genel Bakış

Bu laboratuvarda, hiperparametre ayarı ve dağıtılmış eğitim için Vertex AI'ı nasıl kullanacağınızı öğreneceksiniz. Bu laboratuvar, model kodu için TensorFlow'u kullansa da bu kavramlar diğer makine öğrenimi çerçeveleri için de geçerlidir.

Öğrenecekleriniz

Öğrenecekleriniz:

• Özel bir container'da dağıtılmış eğitimden yararlanarak bir model eğitme
• Otomatik hiperparametre ayarı için eğitim kodunuzun birden fazla denemesini başlatın

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

Vertex AI, uçtan uca makine öğrenimi iş akışlarını destekleyen birçok farklı ürün içerir. Bu laboratuvar Eğitim ve Workbench konularına odaklanmaktadır.

3. Kullanım Alanına Genel Bakış

Bu laboratuvarda, TensorFlow Veri Kümeleri'ndeki atlar veya insanlar veri kümesi üzerinde eğitilen bir görüntü sınıflandırma modeli için optimum parametreleri keşfetmek amacıyla hiperparametre ayarını kullanacaksınız.

Hiperparametre Ayarı

Vertex AI Training ile hiperparametre ayarı, seçtiğiniz hiperparametrelerin belirlediğiniz sınırlar dahilinde değerleriyle eğitim uygulamanızın birden fazla denemesini çalıştırarak çalışır. Vertex AI, her denemenin sonuçlarını takip eder ve sonraki denemeler için düzenlemeler yapar.

Vertex AI Training ile hiperparametre ayarını kullanmak için eğitim kodunuzda yapmanız gereken iki değişiklik vardır:

1. Ayarlamak istediğiniz her hiperparametre için ana eğitim modülünüzde bir komut satırı bağımsız değişkeni tanımlayın.
2. Uygulamanızın kodundaki ilgili hiperparametreyi ayarlamak için bu bağımsız değişkenlerde iletilen değeri kullanın.

Dağıtılmış Eğitim

Tek bir GPU'nuz varsa TensorFlow, herhangi bir ek işlem yapmanıza gerek kalmadan model eğitimini hızlandırmak için bu hızlandırıcıyı kullanır. Ancak, birden fazla GPU kullanarak ek artış elde etmek istiyorsanız TensorFlow'un birden fazla cihazda işlem yapmaya yönelik modülü olan tf.distribute kullanmanız gerekir.

Bu laboratuvarda, yalnızca birkaç kod değişikliğiyle eğitim uygulamalarınıza ekleyebileceğiniz tf.distribute.MirroredStrategy kullanılmaktadır. Bu strateji, makinenizdeki her GPU'da modelin bir kopyasını oluşturur. Sonraki gradyan güncellemeleri eşzamanlı bir şekilde gerçekleşir. Bu, her bir GPU'nun ileri ve geri verileri hesapladığı, giriş verilerinin farklı bir dilimdeki modelden geçtiği anlamına gelir. Bu dilimlerin her birinden hesaplanan renk geçişleri, daha sonra tüm GPU'lar genelinde toplanır ve tüm azaltma adı verilen bir işlemin ortalaması alınır. Model parametreleri bu ortalama değerdeki renk geçişleri kullanılarak güncellenir.

Bu laboratuvarı tamamlamak için ayrıntıları bilmeniz gerekmez ancak dağıtılmış eğitimin TensorFlow'da nasıl çalıştığı hakkında daha fazla bilgi edinmek isterseniz aşağıdaki videoya göz atın:

4. 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 var. Proje oluşturmak için buradaki talimatları uygulayın.

1. Adım: Compute Engine API'yi etkinleştirin

Compute Engine'e gidin ve zaten etkinleştirilmemişse Etkinleştir'i seçin.

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

Container Registry'ye gidin ve henüz yapmadıysanız Etkinleştir'i seçin. Özel eğitim işiniz için bir container oluşturmak üzere bunu kullanacaksınız.

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

Cloud Console'un Vertex AI bölümüne gidip Enable Vertex AI API'yi (Vertex AI API'yi etkinleştir) tıklayın.

4. Adım: Vertex AI Workbench örneği oluşturun

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

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

Etkinleştirdikten sonra YÖNETİLEN NOT KİTAPLARI'nı 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 altından boşta kalma özelliğini etkinleştirin ve dakika sayısını 60 olarak ayarlayın. Bu sayede not defteriniz kullanılmadığında otomatik olarak kapatılır, böylece gereksiz maliyetlere neden olmazsınız.

Güvenlik'in altında "Terminali etkinleştir"i seçin Etkin değilse.

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

Ardından Oluştur'u tıklayın. Örneğin temel hazırlığının yapılması birkaç dakika sürer.

Örnek oluşturulduktan sonra JupyterLab'i aç'ı seçin.

Yeni bir örneği ilk kez kullandığınızda kimliğinizi doğrulamanız istenir. Bu işlemi yapmak için kullanıcı arayüzündeki adımları uygulayın.

5. Eğitim kodunu yazma

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

vertex-codelab adında yeni bir dizin oluşturun ve cd'ye yapıştırın.

mkdir vertex-codelab
cd vertex-codelab

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

mkdir trainer
touch trainer/task.py

Artık vertex-codelab dizininizde aşağıdakilerin olması gerekir:

+ trainer/
    + task.py

Sonra, az önce oluşturduğunuz task.py dosyasını açın ve aşağıdaki kodun tamamını yapıştırın.

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

NUM_EPOCHS = 10
BATCH_SIZE = 64

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(batch_size):
  '''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(batch_size)

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

  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()

  # Create distribution strategy
  strategy = tf.distribute.MirroredStrategy()

  # Get data
  GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
  train_data, validation_data = create_dataset(GLOBAL_BATCH_SIZE)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model(args.num_units, args.learning_rate, args.momentum)

  # Train model
  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()

Şimdi koda daha yakından bakalım ve dağıtılmış eğitim ile hiperparametre ayarlamasına özgü bileşenleri inceleyelim.

Dağıtılmış Eğitim

1. main() işlevinde MirroredStrategy nesnesi oluşturulur. Daha sonra, model değişkenlerinizi oluşturma sürecini stratejinin kapsamında sarmalayın. Bu adım, TensorFlow'a hangi değişkenlerin GPU'lar genelinde yansıtılması gerektiğini bildirir.
2. Grup boyutu num_replicas_in_sync oranında artırılır. TensorFlow'da eşzamanlı veri paralelliği stratejilerini kullanırken grup boyutunu ölçeklendirmek en iyi uygulamadır. Buradan daha fazla bilgi edinebilirsiniz.

Hiperparametre Ayarı

1. Komut dosyası, hypertune kitaplığını içe aktarır. Daha sonra container görüntüsünü oluşturduğumuzda bu kitaplığı yüklememiz gerekecek.
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 birimlerin sayısıdır, ancak başkalarıyla da deneme yapmaktan çekinmeyin. Bu bağımsız değişkenlerde iletilen değer, daha sonra kodda karşılık gelen hiperparametreyi ayarlamak için kullanılır (ör. learning_rate = args.learning_rate değerini ayarlayın)
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 bir History nesnesi döndürür. History.history özelliği, ardışık dönemlerdeki eğitim kaybı değerlerinin ve metrik değerlerinin kaydıdır. Doğrulama verilerini model.fit hizmetine iletirseniz History.history özelliği, doğrulama kaybı ve metrik değerlerini de içerir. Örneğin, bir modeli doğrulama verileriyle üç dönem için eğittiyseniz ve metrik olarak accuracy sağladıysanız History.history özelliği aşağıdaki sözlüğe benzer olur.

{
 "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 ayarı hizmetinin, modelin doğrulama doğruluğunu en üst düzeye çıkaran değerleri keşfetmesini istiyorsanız metriği val_accuracy listesindeki son giriş (veya NUM_EPOCS - 1) olarak tanımlarsınız. Ardından, bu metriği bir HyperTune örneğine iletin. hyperparameter_metric_tag için istediğiniz dizeyi seçebilirsiniz ancak daha sonra hiperparametre ayarlama işini başlattığınızda bu dizeyi tekrar kullanmanız gerekir.

6. Kodu container mimarisine alma

Kodunuzu container mimarisine almanın ilk adımı bir Dockerfile oluşturmaktır. Dockerfile'a görüntüyü çalıştırmak için gereken tüm komutları eklersiniz. Gerekli tüm kitaplıkları yükler ve eğitim kodu için giriş noktasını ayarlar.

1. Adım: Dockerfile yazın

Terminal'inizden vertex-codelab dizininde olduğunuzdan emin olun ve boş bir Dockerfile oluşturun:

touch Dockerfile

Artık vertex-codelab dizininizde aşağıdakilerin olması gerekir:

+ Dockerfile
+ trainer/
    + task.py

Dockerfile'ı açın ve aşağıdakini bu dosyaya 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 Containers, yaygın olarak kullanılan birçok makine öğrenimi ve veri bilimi çerçevesi önceden yüklenmiş olarak sunulur. Bu görüntü indirildikten sonra bu Dockerfile, eğitim kodu için giriş noktasını ayarlar.

2. Adım: Container'ı oluşturun

Terminalinizde projeniz için bir env değişkeni tanımlamak üzere aşağıdaki komutu çalıştırın. your-cloud-project kısmına projenizin kimliğini girdiğinizden emin olun:

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

PROJECT_ID='your-cloud-project'

Google Container Registry'deki kapsayıcı görüntünüzün URI'sıyla bir değişken tanımlayın:

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

Docker'ı yapılandırma

gcloud auth configure-docker

Ardından, vertex-codelab dizininizin kök dizininden aşağıdaki komutu çalıştırarak container'ı oluşturun:

docker build ./ -t $IMAGE_URI

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

docker push $IMAGE_URI

3. Adım: Cloud Storage paketi oluşturun

Eğitim işimizde yolu bir hazırlık paketine aktaracağız.

Projenizde yeni bir paket oluşturmak için Terminal'inizde aşağıdaki komutu çalıştırın.

BUCKET_NAME="gs://${PROJECT_ID}-hptune-bucket"
gsutil mb -l us-central1 $BUCKET_NAME

7. Hiperparametre ayarlama işini başlat

1. Adım: Hiperparametre ayarı ile özel eğitim işi oluşturun

Başlatıcıdan yeni bir TensorFlow 2 Notebook açın.

Vertex AI Python 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 makine türünü ve Docker görüntüsünü belirten worker_pool_specs öğesini tanımlamanız gerekir. Aşağıdaki spesifikasyonda iki NVIDIA Tesla V100 GPU'ya sahip bir makine tanımlanmaktadır.

image_uri içindeki {PROJECT_ID} öğesini projenizle değiştirmeniz 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": 2
    },
    "replica_count": 1,
    "container_spec": {
        "image_uri": "gcr.io/{PROJECT_ID}/horse-human-codelab:latest"
    }
}]

Ardından, optimize etmek istediğiniz parametreleri belirten bir sözlük olan parameter_spec öğesini tanımlayın. Sözlük anahtarı, her bir hiperparametre için komut satırı bağımsız değişkenine atadığınız dizedir. Sözlük değeri ise parametre spesifikasyonudur.

Her hiperparametre için, Tür ve ayar hizmetinin deneeceği değerlerin sınırlarını tanımlamanız gerekir. Hiperparametreler Çift, Tam Sayı, Kategorik veya Ayrık türünde olabilir. Çift veya Tamsayı türünü seçerseniz minimum ve maksimum değer sağlamanız gerekir. Kategorik veya Ayrık'ı seçerseniz değerleri sağlamanız gerekir. Çift ve Tamsayı türleri için Ölçekleme değerini de sağlamanız gerekir. En iyi ölçeği nasıl seçeceğiniz hakkında daha fazla bilgiyi bu videoda bulabilirsiniz.

# 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)
}

Tanımlanacak son özellik, optimize edilecek metriği temsil eden bir sözlük olan metric_spec'dir. Sözlük anahtarı, eğitim uygulama kodunuzda ayarladığınız hyperparameter_metric_tag değeridir ve değer, optimizasyon hedefidir.

# Dicionary 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'}

Teknik özellikler tanımlandıktan sonra CustomJob oluşturacaksınız. Bu, hiperparametre ayarlama denemelerinin her birinde işinizi çalıştırmak için kullanılacak ortak spesifikasyondur.

{YOUR_BUCKET} öğesini daha önce oluşturduğunuz paketle değiştirmeniz gerekir.

# Replace YOUR_BUCKET
my_custom_job = aiplatform.CustomJob(display_name='horses-humans',
                              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',
    custom_job=my_custom_job,
    metric_spec=metric_spec,
    parameter_spec=parameter_spec,
    max_trial_count=6,
    parallel_trial_count=2,
    search_algorithm=None)

hp_job.run()

Göz önünde bulundurulması gereken birkaç bağımsız değişken vardır:

• max_trial_count: Hizmetin çalıştıracağı deneme sayısı için bir üst sınır belirlemeniz gerekir. Daha fazla deneme yapıldığında genellikle daha iyi sonuçlar elde edilir. Ancak getirilerde bir azalma olacaktır. Sonrasında ek denemeler, optimize etmeye çalıştığınız metrik üzerinde çok az etkiye neden olur veya hiç etkisi olmaz. Daha az sayıda denemeyle başlayıp ölçeği artırmadan önce seçtiğiniz hiperparametrelerin ne kadar etkili olduğunu anlamanız önerilir.
• paralel_trial_count: Paralel denemeleri kullanırsanız hizmet, birden fazla eğitim işleme kümesi sağlar. Paralel deneme sayısını artırmak, hiperparametre ayarı işinin çalışması için gereken süreyi azaltır; işin genel olarak verimliliğini azaltabilir. Bunun nedeni, varsayılan ayarlama stratejisinin sonraki denemelerde değer atanmasını sağlamak için önceki denemelerin sonuçlarını kullanmasıdır.
• arama_algorithm: Arama algoritmasını ızgara, rastgele veya varsayılan (Yok) değerine ayarlayabilirsiniz. Varsayılan seçenek, olası hiperparametre değerleri alanında arama yapmak için Bayes optimizasyonunu uygular ve önerilen algoritmadır. Bu algoritma hakkında daha fazla bilgiyi buradan edinebilirsiniz.

İş başladıktan sonra, kullanıcı arayüzünde HYPERPARAMETER AYAR İŞLERİ sekmesi altında işlerin durumunu izleyebilirsiniz.

İş tamamlandıktan sonra, hiperparametre değerlerinin en iyi kombinasyonunu keşfetmek için denemelerinizin sonuçlarını görüntüleyebilir ve sıralayabilirsiniz.

🎉 Tebrikler! 🎉

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

• Dağıtılmış eğitimle hiperparametre ayarı işi çalıştırma

Vertex AI'ın farklı bölümleri hakkında daha fazla bilgi edinmek için belgeleri inceleyin.

8. Temizleme

Not defterini 60 dakika boşta kalma dakikasının sonunda zaman aşımına uğrayacak şekilde yapılandırdığımızdan örneği kapatma konusunda endişelenmemize gerek yoktur. Örneği manuel olarak kapatmak isterseniz 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.

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: