Prototipten Üretime: Hiperparametre ayarı

1. Genel Bakış

Bu laboratuvarda, Vertex AI Eğitimi'nde hiper parametre ayarlama işi çalıştırmak için Vertex AI'yı kullanacaksınız.

Bu laboratuvar, Prototipten Üretime video serisinin bir parçasıdır. Bu laboratuvarı denemeden önce önceki laboratuvarı tamamladığınızdan emin olun. Daha fazla bilgi edinmek için aşağıdaki video serisini izleyebilirsiniz:

.

Öğrenecekleriniz

Öğrenecekleriniz:

• Otomatik hiperparametre ayarı için eğitim uygulaması kodunu değiştirme
• Vertex AI Python SDK ile hiperparametre ayarı işi yapılandırma ve başlatma

Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 1 ABD dolarıdır.

2. Vertex AI'a giriş

Bu laboratuvarda, Google Cloud'da sunulan en yeni yapay zeka ürünü kullanılı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, 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 odaklanacağız: Eğitim ve Workbench

3. Ortamınızı ayarlama

Ortamınızı ayarlamak için Vertex AI ile özel modelleri eğitme laboratuvarındaki adımları tamamlayın.

4. Eğitim uygulaması kodunu container mimarisine alın

Eğitim uygulama kodunuzu bir Docker container'ına yerleştirip bu container'ı Google Artifact Registry'ye aktararak bu eğitim işini Vertex AI'a göndereceksiniz. Bu yaklaşımı kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebilir ve ayarlayabilirsiniz.

Başlamak için önceki laboratuvarlarda oluşturduğunuz Workbench not defterinin Başlatıcı menüsünden bir terminal penceresi açın.

1. adım: Eğitim kodunu yazın

flowers-hptune adlı yeni bir dizin oluşturun ve cd komutuyla bu dizine gidin:

mkdir flowers-hptune
cd flowers-hptune

Eğitim kodu için bir dizin ve aşağıdaki kodu ekleyeceğiniz bir Python dosyası oluşturmak üzere aşağıdakileri çalıştırın.

mkdir trainer
touch trainer/task.py

flowers-hptune/ dizininde şu dosyalar bulunmalıdır:

+ trainer/
    + task.py

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

BUCKET_ROOT içindeki {your-gcs-bucket} değerini, Lab 1'de çiçek veri kümesini depoladığınız Cloud Storage paketiyle değiştirmeniz gerekir.

import tensorflow as tf
import numpy as np
import os
import hypertune
import argparse

## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'

# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32

IMG_HEIGHT = 180
IMG_WIDTH = 180

DATA_DIR = f'{BUCKET_ROOT}/flower_photos'

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 create_datasets(data_dir, batch_size):
  '''Creates train and validation datasets.'''

  train_dataset = tf.keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    seed=123,
    image_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=batch_size)

  validation_dataset = tf.keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="validation",
    seed=123,
    image_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=batch_size)

  train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
  validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)

  return train_dataset, validation_dataset


def create_model(num_units, learning_rate, momentum):
  '''Creates model.'''

  model = tf.keras.Sequential([
    tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
    tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
    tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(num_units, activation='relu'),
    tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
  ])

  model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=momentum),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(),
              metrics=['accuracy'])
  
  return model

def main():
  args = get_args()
  train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
  model = create_model(args.num_units, args.learning_rate, args.momentum)
  history = model.fit(train_dataset, validation_data=validation_dataset, epochs=EPOCHS)

  # 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=EPOCHS)


if __name__ == "__main__":
    main()

Container'ı derlemeden ö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.
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 hiper parametreler öğrenme hızı, optimizatördeki momentum değeri ve modelin son gizli katmanındaki birim sayısıdır ancak başkalarını denemekten çekinmeyin. 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 bir History nesnesi döndürür. History.history özelliği, art arda gelen dönemlerdeki eğitim kaybı değerlerinin ve metrik değerlerinin bir kaydıdır. Doğrulama verilerini model.fit özelliğine gönderirseniz History.history özelliği, doğrulama kaybını ve metrik değerlerini de içerir. Örneğin, bir modeli doğrulama verileriyle üç dönem boyunca eğittiyseniz ve metrik olarak accuracy sağladıysanız History.history özelliği aşağıdaki sözlüğe benzer şekilde 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 keşfetmesini istiyorsanız metriği val_accuracy listesinin son girişi (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 hiperparametre ayarlama işini başlattığınızda bu dizeyi tekrar kullanmanız gerekir.

2. adım: Dockerfile oluşturun

Kodunuzu kapsayıcıya yerleştirmek için bir Dockerfile oluşturmanız gerekir. Dockerfile'e, görüntüyü çalıştırmak için gereken tüm komutları eklersiniz. Gerekli tüm kitaplıklar yüklenir ve eğitim kodunun giriş noktası ayarlanır.

Terminal'inizden flowers-hptune dizininizin kökünde boş bir Dockerfile oluşturun:

touch Dockerfile

flowers-hptune/ dizininde şu dosyalar bulunmalıdır:

+ Dockerfile
+ trainer/
    + task.py

Dockerfile'ı açın ve aşağıdakini bu dosyaya kopyalayın. Bunun, ilk laboratuvarda kullandığımız Dockerfile ile neredeyse aynı olduğunu fark edeceksiniz. Tek fark, şimdi cloudml-hypertune kitaplığını yüklememizdir.

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

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"]

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

Projeniz için bir env değişkeni tanımlamak üzere Terminal'inizde aşağıdaki komutu çalıştırın. your-cloud-project yerine projenizin kimliğini yazın:

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

PROJECT_ID='your-cloud-project'

Artifact Registry'de bir depo tanımlayın. Oluşturduğumuz depoyu ilk laboratuvarda kullanacağız.

REPO_NAME='flower-app'

Google Artifact Registry'deki container görüntünüzün URI'sini içeren bir değişken tanımlayın:

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_hptune:latest

Docker'ı yapılandırma

gcloud auth configure-docker \
    us-central1-docker.pkg.dev

Ardından, flower-hptune dizininizin kökünden aşağıdakileri çalıştırarak kapsayıcıyı derleyin:

docker build ./ -t $IMAGE_URI

Son olarak, dosyayı Artifact Registry'ye gönderin:

docker push $IMAGE_URI

Kapsayıcı Artifact Registry'ye aktarıldığında eğitim işini başlatmaya hazırsınız demektir.

5. SDK ile hiperparametre ayarlama işini çalıştırma

Bu bölümde, Vertex Python API'yi kullanarak hiper parametre ayarlama işini nasıl yapılandıracağınızı ve göndereceğinizi öğreneceksiniz.

Launcher'dan bir TensorFlow 2 not defteri oluşturun.

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

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

Hiperparametre ayarı 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} değerini 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": 1
    },
    "replica_count": 1,
    "container_spec": {
        "image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_hptune: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 hiper parametre için komut satırı bağımsız değişkenine atadığınız dizedir ve sözlük değeri, 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 Tam Sayı türünü seçerseniz minimum ve maksimum bir değer sağlamanız gerekir. Kategorik veya Ayrık'ı seçerseniz değerleri sağlamanız gerekir. Çift ve tam sayı türleri için ölçeklendirme 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 spesifikasyon, optimize edilecek metriği temsil eden bir sözlük olan metric_spec'tür. Sözlük anahtarı, eğitim uygulama kodunuzda ayarladığınız hyperparameter_metric_tag değeridir ve değer, optimizasyon hedefidir.

# Dictionary representing metric 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'}

Spesifikasyonlar tanımlandıktan sonra, işinizi hiper parametre ayarlama denemelerinin her birinde çalıştırmak için kullanılacak ortak spesifikasyon olan bir CustomJob oluşturursunuz.

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

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

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

hp_job = aiplatform.HyperparameterTuningJob(
    display_name='flowers-hptune-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()

Dikkat edilmesi gereken birkaç argüman 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 sahip olur veya hiç etkisi olmaz. Ölçeği artırmadan önce daha az sayıda denemeyle başlamak ve seçtiğiniz hiperparametrelerin ne kadar etkili olduğunu anlamak en iyi uygulamadır.
• parallel_trial_count: Paralel denemeler kullanıyorsanız hizmet, birden fazla eğitim işleme kümesi sağlar. Paralel denemelerin sayısını artırmak, hiper parametre ayarlama işinin çalışması için gereken süreyi azaltır ancak işin genel etkinliğini azaltabilir. Bunun nedeni, varsayılan ayarlama stratejisinin sonraki denemelerde değer ataması yaparken önceki denemelerin sonuçlarını kullanmasıdır.
• search_algorithm: Arama algoritmasını ızgara, rastgele veya varsayılan (Yok) olarak 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 burada bulabilirsiniz.

Konsolda işinizin ilerleme durumunu görebilirsiniz.

Deneme tamamlandığında her denemenin sonuçlarını ve en iyi performansı gösteren değer grubunu görebilirsiniz.

🎉 Tebrikler. 🎉

Aşağıdakiler için Vertex AI'ı nasıl kullanacağınızı öğrendiniz:

• Otomatik hiperparametre ayarlama işi çalıştırma

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

6. Temizleme

Not defterini, 60 dakikalık işlem yapılmadığında zaman aşımı olacak şekilde yapılandırdığımız için örneği kapatma konusunda endişelenmenize 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 istiyorsanız 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: