Vertex AI: TensorFlow ile Çok Çalışanlı Eğitim ve Öğrenimi Aktarma

1. Genel Bakış

Bu laboratuvarda, bir TensorFlow modeli için çok çalışanlı eğitim işi çalıştırmak üzere Vertex AI'yı kullanacaksınız.

Öğrenecekleriniz

Öğrenecekleriniz:

• Çok çalışanlı eğitim için eğitim uygulama kodunu değiştirme
• Vertex AI kullanıcı arayüzünden çok çalışanlı bir eğitim işi yapılandırma ve başlatma
• Vertex SDK'sı ile çok çalışanlı bir eğitim işi yapılandırma ve başlatma

Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 5 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. Mevcut projeleri Vertex AI'a da taşıyabilirsiniz. Geri bildirimde bulunmak isterseniz lütfen destek sayfasını inceleyin.

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. Kullanım Alanına Genel Bakış

Bu laboratuvarda, TensorFlow Veri Kümeleri'ndeki mantık veri kümesinde bir görüntü sınıflandırma modeli eğitmek için aktarımla öğrenme özelliğini kullanacaksınız. Kullanacağınız mimari, tf.keras.applications kitaplığındaki ve Imagenet veri kümesinde önceden eğitilmiş bir ResNet50 modelidir.

Dağıtılmış eğitim neden önemlidir?

Tek bir GPU'nuz varsa TensorFlow, model eğitimini hızlandırmak için bu hızlandırıcıyı kullanır ve sizden ek bir işlem yapmanızı gerektirmez. Ancak, tek bir makinede veya her biri potansiyel olarak birden fazla GPU'ya sahip olan birden fazla makinede birden fazla GPU kullanarak ek artış elde etmek istiyorsanız TensorFlow'un birden fazla cihazda işlem yapmaya yönelik kitaplığı olan tf.distribute kullanmanız gerekir. Cihaz, TensorFlow'un işlem yapabileceği bazı makinelerdeki GPU veya TPU gibi bir CPU'yu ya da hızlandırıcıyı ifade eder.

Dağıtılmış eğitime başlamanın en basit yolu, birden fazla GPU cihazına sahip tek bir makinedir. tf.distribute modülündeki bir TensorFlow dağıtım stratejisi, tüm GPU'larda veri dağıtımının ve gradyan güncellemelerinin koordinasyonunu yönetir. Tek ana makineli eğitimde ustalaştıysanız ve daha da ölçeklendirmek istiyorsanız kümenize birden fazla makine ekleyerek daha da fazla performans artışı elde edebilirsiniz. Yalnızca CPU'ya sahip veya her biri bir veya daha fazla GPU'ya sahip bir makine grubu kullanabilirsiniz. Bu laboratuvarda ikinci durum ele alınmakta ve bir TensorFlow modelinin eğitimini Vertex AI'da birden fazla makineye dağıtmak için MultiWorkerMirroredStrategy'ün nasıl kullanılacağı gösterilmektedir.

MultiWorkerMirroredStrategy, yalnızca birkaç kod değişikliğiyle kullanabileceğiniz eşzamanlı bir veri paralelliği stratejisidir. Kümenizdeki her cihazda modelin bir kopyası oluşturulur. Sonraki gradyan güncellemeleri senkronize bir şekilde gerçekleşir. Bu, her çalışan cihazın, giriş verilerinin farklı bir diliminde model üzerinden ileri ve geri geçişleri hesapladığı anlamına gelir. Bu dilimlerin her birinden hesaplanan gradyanlar daha sonra bir makinedeki tüm cihazlar ve kümedeki tüm makineler genelinde toplanır ve tüm azaltma olarak bilinen bir işlemde azaltılır (genellikle ortalama). Daha sonra optimizatör, bu azaltılmış gradyanlarla parametre güncellemelerini gerçekleştirerek cihazları senkronize tutar. TensorFlow ile dağıtılmış eğitim hakkında daha fazla bilgi edinmek için aşağıdaki videoya göz atın:

4. Ortamınızı ayarlama

Bu kod laboratuvarını çalıştırmak için faturalandırmanın etkin olduğu bir Google Cloud Platform projeniz olmalıdır. 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. Not defteri örneğinizi oluşturmak için bu anahtara ihtiyacınız vardır.

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

Kapsayıcı Kaydı'na gidin ve henüz etkinleştirilmediyse Etkinleştir'i seçin. Özel eğitim işiniz için bir kapsayıcı oluşturmak üzere bu dosyayı kullanırsı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şturun

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

Henüz etkinleştirilmediyse Notebooks API'yi etkinleştirin.

Etkinleştirdikten sonra YÖNETİLEN NOT DEFTERİ'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 bölümünde, boştayken kapatma özelliğini etkinleştirin ve dakika sayısını 60 olarak ayarlayın. Bu sayede, gereksiz maliyetlere maruz kalmamak için dizüstü bilgisayarınız kullanılmadığında otomatik olarak kapanır.

Güvenlik bölümünde, etkin değilse "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 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. Bunu yapmak için kullanıcı arayüzündeki adımları uygulayın.

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

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

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

cassava adlı yeni bir dizin oluşturun ve cd komutuyla bu dizine gidin:

mkdir cassava
cd cassava

1. Adım: Dockerfile oluşturun

Kodunuzu container mimarisine almanın ilk adımı bir Dockerfile oluşturmaktır. 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 boş bir Dockerfile oluşturun:

touch Dockerfile

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

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

WORKDIR /

# 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. Bu dosyaları henüz oluşturmadınız. Bir sonraki adımda, modeli eğitme ve ayarlama kodunu ekleyeceksiniz.

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

Bu eğitim işinde, eğitilen TensorFlow modelini bir Cloud Storage paketine aktaracaksınız. 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'

Ardından projenizde yeni bir paket oluşturmak için aşağıdaki komutu Terminal'de çalıştırın.

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

3. Adım: Model eğitim kodunu ekleyin

Terminal'inizden 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

cassava/ dizininde şu dosyalar bulunmalıdır:

+ Dockerfile
+ trainer/
    + task.py

Sonra, az önce oluşturduğunuz task.py dosyasını açın ve aşağıdaki kodu kopyalayın. {your-gcs-bucket} ifadesini, az önce oluşturduğunuz Cloud Storage paketinin adıyla değiştirmeniz gerekir.

import tensorflow as tf
import tensorflow_datasets as tfds
import os


PER_REPLICA_BATCH_SIZE = 64
EPOCHS = 2

# TODO: replace {your-gcs-bucket} with the name of the Storage bucket you created earlier
BUCKET = 'gs://{your-gcs-bucket}/mwms'

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

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


def create_dataset(batch_size):
  '''Loads Cassava dataset and preprocesses data.'''

  data, info = tfds.load(name='cassava', as_supervised=True, with_info=True)
  number_of_classes = info.features['label'].num_classes
  train_data = data['train'].map(preprocess_data,
                                 num_parallel_calls=tf.data.experimental.AUTOTUNE)
  train_data  = train_data.shuffle(1000)
  train_data  = train_data.batch(batch_size)
  train_data  = train_data.prefetch(tf.data.experimental.AUTOTUNE)

  # Set AutoShardPolicy
  options = tf.data.Options()
  options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.DATA
  train_data = train_data.with_options(options)

  return train_data, number_of_classes


def create_model(number_of_classes):
  '''Creates and compiles pretrained ResNet50 model.'''

  base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False)
  x = base_model.output
  x = tf.keras.layers.GlobalAveragePooling2D()(x)
  x = tf.keras.layers.Dense(1016, activation='relu')(x)
  predictions = tf.keras.layers.Dense(number_of_classes, activation='softmax')(x)
  model = tf.keras.Model(inputs=base_model.input, outputs=predictions)

  model.compile(
      loss='sparse_categorical_crossentropy',
      optimizer=tf.keras.optimizers.Adam(0.0001),
      metrics=['accuracy'])

  return model


def _is_chief(task_type, task_id):
  '''Helper function. Determines if machine is chief.'''

  return task_type == 'chief'


def _get_temp_dir(dirpath, task_id):
  '''Helper function. Gets temporary directory for saving model.'''

  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir


def write_filepath(filepath, task_type, task_id):
  '''Helper function. Gets filepath to save model.'''

  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)


def main():
  # Create strategy
  strategy = tf.distribute.MultiWorkerMirroredStrategy()

  # Get data
  global_batch_size = PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync
  train_data, number_of_classes = create_dataset(global_batch_size)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model(number_of_classes)

  model.fit(train_data, epochs=EPOCHS)

  # Determine type and task of the machine from
  # the strategy cluster resolver
  task_type, task_id = (strategy.cluster_resolver.task_type,
                        strategy.cluster_resolver.task_id)

  # Based on the type and task, write to the desired model path
  write_model_path = write_filepath(BUCKET, task_type, task_id)
  model.save(write_model_path)

if __name__ == "__main__":
    main()

Kapsayıcıyı derlemeden önce, tf.distribute.Strategy API'den MultiWorkerMirroredStrategy kullanan koda daha yakından bakalım.

MultiWorkerMirroredStrategy, her biri potansiyel olarak birden fazla GPU içeren bir kümedeki birden fazla makineye eğitim dağıtmak için tasarlanmıştır. Yalnızca tek bir cihazdaki birden fazla GPU'ya eğitim dağıtmak istiyorsanız MirroredStrategy bölümüne bakın.

Kodunuzun MultiWorkerMirroredStrategy ile çalışması için gerekli olan birkaç bileşen vardır.

1. Verilerin bölümlendirilmesi gerekir. Yani her çalışana veri kümesinin tamamının bir alt kümesi atanır. Bu nedenle, her adımda her çalışan tarafından, örtüşmeyen veri kümesi öğelerinin genel bir toplu boyutu işlenir. Bu parçalama işlemi, FILE veya DATA olarak ayarlanabilen tf.data.experimental.AutoShardPolicy ile otomatik olarak gerçekleşir. Bu örnekte, manyok veri kümesi birden fazla dosya olarak indirilmediği için create_dataset() işlevi AutoShardPolicy değerini DATA olarak ayarlar. Ancak politikayı DATA olarak ayarlamadıysanız varsayılan AUTO politikası devreye girer ve nihai sonuç aynı olur. MultiWorkerMirroredStrategy ile veri kümesi bölme hakkında daha fazla bilgiyi burada bulabilirsiniz.
2. main() işlevinde MultiWorkerMirroredStrategy nesnesi oluşturulur. Ardından, model değişkenlerinizin oluşturulmasını stratejinin kapsamına alırsınız. Bu önemli adım, TensorFlow'a hangi değişkenlerin replikalar genelinde yansıtılması gerektiğini bildirir.
3. Grup boyutu num_replicas_in_sync ile ölçeklendirilir. Bu sayede her kopya her adımda aynı sayıda örnek işler. TensorFlow'da senkron veri paralelliği stratejileri kullanırken grup boyutunu ölçeklendirmek en iyi uygulamadır.
4. Hedefin her çalışan için farklı olması gerektiğinden, modelinizi birden fazla çalışanla kullanmak biraz daha karmaşıktır. Baş işleyici, modeli istediğiniz model dizinine kaydeder. Diğer işleyiciler ise modeli geçici dizinlere kaydeder. Birden fazla işleyicinin aynı konuma yazmaması için bu geçici dizinlerin benzersiz olması önemlidir. Kayıt işlemi toplu işlemler içerebilir. Bu durumda, yalnızca şefin değil tüm çalışanların kaydetmesi gerekir. _is_chief(), _get_temp_dir(), write_filepath() ve main() işlevlerinin tümü, modeli kaydetmeye yardımcı olan standart kod içerir.

MultiWorkerMirroredStrategy ürününü farklı bir ortamda kullandıysanız TF_CONFIG ortam değişkenini oluşturmuş olabileceğinizi unutmayın. Vertex AI, TF_CONFIG değişkenini sizin için otomatik olarak ayarlar. Bu nedenle, bu değişkeni kümenizdeki her makinede tanımlamanız gerekmez.

4. Adım: Kapsayıcıyı derleyin

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'sini içeren bir değişken tanımlayın:

IMAGE_URI="gcr.io/$PROJECT_ID/multiworker:cassava"

Docker'ı yapılandırma

gcloud auth configure-docker

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

docker build ./ -t $IMAGE_URI

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

docker push $IMAGE_URI

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

6. Vertex AI'da çok çalışanlı eğitim işi çalıştırma

Bu laboratuvarda, Google Container Registry'deki özel bir container aracılığıyla özel eğitim kullanılır. Ancak önceden oluşturulmuş container'larla da bir eğitim işi ç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

Eğitim 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çin ve Devam'ı tıklayın.
• Model adı için multiworker-cassava (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 (Kapsayıcı resmi), önceki bölümde bulunan IMAGE_URI değişkeninizin değerini girin. Şöyle olmalıdır: gcr.io/your-cloud-project/multiworker:cassava, kendi proje kimliğinizle. Diğer alanları boş bırakıp Devam'ı tıklayın.

Devam'ı tekrar tıklayarak Hhyperparameters adımını atlayın.

2. Adım: Hesaplama kümesini yapılandırın

Vertex AI, farklı makine görevleri türlerini kapsayan 4 çalışan havuzu sunar.

Çalışan havuzu 0 birincil, şef, planlayıcı veya "ana" havuz ayarını yapılandırır. MultiWorkerMirroredStrategy ürününde tüm makineler, çalışan olarak tanımlanmıştır. Çalışanlar, bunlar üzerinde çoğaltılan hesaplamanın yürütüldüğü fiziksel makinelerdir. Her makinenin işleyici olmasının yanı sıra, kontrol noktalarını kaydetme ve özet dosyalarını TensorBoard'a yazma gibi bazı ek işleri üstlenen bir işleyicinin olması gerekir. Bu makine, şef olarak bilinir. Yalnızca bir baş çalışan vardır. Bu nedenle 0 olan çalışan havuzu için çalışan sayınız her zaman 1 olur.

İşlem ve fiyatlandırma bölümünde, seçili bölgeyi olduğu gibi bırakın ve Çalışan havuzu 0'u aşağıdaki gibi yapılandırın:

GPU eklemeyi seçebilirsiniz ancak MultiWorkerMirroredStrategy için kümenizdeki her makinede aynı sayıda GPU bulunması gerektiğini unutmayın. GPU eklemek, eğitim işinin maliyetini de artırır.

1. çalışan havuzu, kümeniz için çalışanları yapılandırdığınız yerdir.

Çalışan havuzu 1'i aşağıdaki gibi yapılandırın:

Küme artık yalnızca CPU kullanan iki makine içerecek şekilde yapılandırılmıştır. Eğitim uygulama kodu çalıştırıldığında MultiWorkerMirroredStrategy, eğitimi her iki makineye de dağıtır.

MultiWorkerMirroredStrategy yalnızca şef ve çalışan görev türlerine sahiptir. Bu nedenle, ek çalışan havuzlarını yapılandırmanız gerekmez. Ancak TensorFlow'un ParameterServerStrategy sürümünü kullanıyorsanız parametre sunucularınızı çalışan havuzu 2'de yapılandırırsınız. Ayrıca, kümenize bir değerlendirici eklemek isterseniz bu makineyi çalışan havuzu 3'te yapılandırırsınız.

Hiperparametre ayarlama işini başlatmak için Eğitimi başlat'ı tıklayın. Konsolunuzun Eğitim bölümündeki EĞİTİM İŞ AKIŞLARI sekmesinde yeni başlatılan işinizi görürsünüz:

Eğitim işinin tamamlanması yaklaşık 30-35 dakika sürer.

🎉 Tebrikler! 🎉

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

• Özel bir kapsayıcıda sağlanan eğitim kodu için çok çalışanlı bir eğitim işi başlatın. Bu örnekte bir TensorFlow modeli kullandık ancak özel veya yerleşik 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.

7. [İsteğe bağlı] Vertex SDK'sını kullanma

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

Not defteri örneğinize dönün ve Başlatıcı'dan bir TensorFlow 2 not defteri oluşturun:

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

from google.cloud import aiplatform

Çok çalışanlı eğitim işini başlatmak için öncelikle çalışan havuzu spesifikasyonunu tanımlamanız gerekir. Spesifikasyondaki GPU kullanımının tamamen isteğe bağlı olduğunu unutmayın. Önceki bölümde gösterildiği gibi yalnızca CPU kullanılmasını isterseniz accelerator_type ve accelerator_count öğelerini kaldırabilirsiniz.

# The spec of the worker pools including machine type and Docker image
# Be sure to replace {YOUR-PROJECT-ID} with your project ID.
worker_pool_specs=[
     {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
        },
        "container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
      },
      {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
        },
        "container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
      }
]

Sonra, bir CustomJob oluşturup çalıştırın. Hazırlık için {YOUR_BUCKET} öğesini projenizde bir paketle değiştirmeniz gerekir. Daha önce oluşturduğunuz paketi kullanabilirsiniz.

# Replace YOUR_BUCKET
my_multiworker_job = aiplatform.CustomJob(display_name='multiworker-cassava-sdk',
                              worker_pool_specs=worker_pool_specs,
                              staging_bucket='gs://{YOUR_BUCKET}')

my_multiworker_job.run()

Konsolunuzun Eğitim bölümündeki ÖZEL İŞLER sekmesinde eğitim işinizi görürsünüz:

8. 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ğini manuel olarak kapatmak istiyorsanız 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.

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: