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

1. Genel Bakış

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

Öğrenecekleriniz

Öğrenecekleriniz:

• Çok işçili eğitim için eğitim uygulaması kodunu değiştirme
• Vertex AI kullanıcı arayüzünden çok işçili bir eğitim işi yapılandırma ve başlatma
• Vertex SDK ile çok işçili bir eğitim işini 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'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. Kullanım Alanına Genel Bakış

Bu laboratuvarda, TensorFlow Datasets'teki cassava veri kümesinde görüntü sınıflandırma modeli eğitmek için transfer öğrenimini kullanacaksınız. Kullanacağınız mimari, Imagenet veri kümesi üzerinde önceden eğitilmiş tf.keras.applications kitaplığındaki bir ResNet50 modelidir.

Neden Dağıtılmış Eğitim?

Tek bir GPU'nuz varsa TensorFlow, model eğitimini hızlandırmak için bu hızlandırıcıyı kullanır ve sizin tarafınızdan ek bir işlem yapılması gerekmez. Ancak tek bir makinede veya birden fazla makinede (her biri birden fazla GPU'ya sahip olabilir) birden fazla GPU kullanarak ek bir artış elde etmek istiyorsanız TensorFlow'un birden fazla cihazda hesaplama çalıştırma kitaplığı olan tf.distribute kullanmanız gerekir. Cihaz, TensorFlow'un üzerinde işlemler çalıştırabileceği bir makinedeki CPU veya hızlandırıcıyı (ör. GPU'lar ya da TPU'lar) ifade eder.

Dağıtılmış eğitime başlamanın en basit yolu, birden fazla GPU cihazı olan tek bir makinedir. tf.distribute modülündeki bir TensorFlow dağıtım stratejisi, veri dağıtımı ve gradyan güncellemelerinin tüm GPU'lar arasında koordinasyonunu yönetir. Tek ana makine eğitimi konusunda uzmanlaştıysanız ve daha da ölçeklendirmek istiyorsanız kümenize birden fazla makine eklemek performansınızı daha da artırmanıza yardımcı olabilir. Yalnızca CPU'lu veya her biri bir ya da daha fazla GPU'lu bir makine kümesinden yararlanabilirsiniz. Bu laboratuvarda ikinci durum ele alınmakta ve bir TensorFlow modelinin eğitimini Vertex AI'daki birden fazla makineye dağıtmak için MultiWorkerMirroredStrategy nasıl kullanılacağı gösterilmektedir.

MultiWorkerMirroredStrategy, yalnızca birkaç kod değişikliğiyle kullanabileceğiniz eşzamanlı bir veri paralelliği stratejisidir. Modelin bir kopyası, kümenizdeki her cihazda oluşturulur. Sonraki gradyan güncellemeleri eşzamanlı olarak gerçekleşir. Bu, her çalışan cihazın, giriş verilerinin farklı bir bölümünde model üzerinden ileri ve geri geçişleri hesapladığı anlamına gelir. Bu dilimlerin her birinden hesaplanan gradyanlar, bir makinedeki tüm cihazlarda ve kümedeki tüm makinelerde toplanır ve "all-reduce" olarak bilinen bir işlemde azaltılır (genellikle ortalama). Ardından optimize edici, parametre güncellemelerini bu azaltılmış gradyanlarla gerçekleştirerek cihazların senkronize kalmasını sağlar. TensorFlow ile dağıtılmış eğitim hakkında daha fazla bilgi edinmek için aşağıdaki videoyu izleyin:

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 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.

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

Eğitim uygulama kodunuzu bir Docker container'a yerleştirip bu container'ı Google Container Registry'ye aktararak bu eğitim işini Vertex'e gönderirsiniz. 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 bu dizine gidin:

mkdir cassava
cd cassava

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. Bu işlem, gerekli tüm kitaplıkları yükler ve eğitim kodu için 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 /

# 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: Cloud Storage paketi oluşturma

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

Ardından, projenizde yeni bir paket oluşturmak için Terminal'inizde aşağıdakileri çalıştırın.

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

3. 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

cassava/ 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. {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ı oluşturmadan önce, tf.distribute.Strategy API'sinden MultiWorkerMirroredStrategy kullanan koda daha yakından bakalım.

MultiWorkerMirroredStrategy, bir kümedeki birden fazla makineye eğitim dağıtmak için tasarlanmıştır. Bu makinelerin her birinde birden fazla GPU olabilir. Eğitimi tek bir cihazdaki birden fazla GPU'ya dağıtmak istiyorsanız MirroredStrategy bölümüne bakın.

Kodunuzun MultiWorkerMirroredStrategy ile çalışması için koddaki birkaç bileşenin bulunması gerekir.

1. Verilerin parçalanması gerekir. Yani, tüm veri kümesinin bir alt kümesi her çalışana atanır. Bu nedenle, her adımda her çalışan tarafından çakışmayan veri kümesi öğelerinden oluşan global bir grup boyutu işlenir. Bu parçalama işlemi, tf.data.experimental.AutoShardPolicy ile otomatik olarak gerçekleşir. tf.data.experimental.AutoShardPolicy, FILE veya DATA olarak ayarlanabilir. 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 sonuç aynı olur. MultiWorkerMirroredStrategy ile veri kümesi parçalama hakkında daha fazla bilgiyi burada bulabilirsiniz.
2. main() işlevinde MultiWorkerMirroredStrategy nesnesi oluşturulur. Ardından, model değişkenlerinizi stratejinin kapsamına dahil edersiniz. Bu önemli adım, TensorFlow'a hangi değişkenlerin kopyalar arasında yansıtılması gerektiğini bildirir.
3. Grup boyutu num_replicas_in_sync ile ölçeklendirilir. Bu, her replikanın her adımda aynı sayıda örnek işlemesini sağlar. TensorFlow'da eşzamanlı veri paralelliği stratejileri kullanırken grup boyutunu ölçeklendirmek en iyi uygulamadır.
4. Modelinizi kaydetme işlemi, çoklu çalışan durumunda biraz daha karmaşıktır. Bunun nedeni, hedef konumun her çalışan için farklı olmasıdır. Ana çalışan, modeli istenen model dizinine kaydederken diğer çalışanlar modeli geçici dizinlere kaydeder. Birden fazla çalışanın aynı konuma yazmasını önlemek için bu geçici dizinlerin benzersiz olması önemlidir. Kaydetme işlemi, toplu işlemleri içerebilir. Bu durumda, yalnızca şefin değil tüm çalışanların kaydetmesi gerekir. _is_chief(), _get_temp_dir(), write_filepath() işlevlerinin yanı sıra main() işlevi de modeli kaydetmeye yardımcı olan standart kod içerir.

MultiWorkerMirroredStrategy'yı farklı bir ortamda kullandıysanız TF_CONFIG ortam değişkenini ayarlamış olabilirsiniz. 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ı 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/multiworker:cassava"

Docker'ı yapılandırma

gcloud auth configure-docker

Ardından, cassava 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 eğitim işini başlatmaya hazırsınız.

6. Vertex AI'da çok işçili 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 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çip 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 (Container image), önceki bölümdeki IMAGE_URI değişkeninizin değerini girin. Bu kimlik, kendi proje kimliğinizle birlikte gcr.io/your-cloud-project/multiworker:cassava olmalıdır. Diğer alanları boş bırakıp Devam'ı tıklayın.

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

2. adım: İşlem kümesini yapılandırın

Vertex AI, farklı makine görevlerini kapsayacak 4 çalışan havuzu sağlar.

Worker pool 0, birincil, baş, planlayıcı veya "ana"yı yapılandırır. MultiWorkerMirroredStrategy'da tüm makineler, tekrarlanan hesaplamanın yürütüldüğü fiziksel makineler olan çalışanlar olarak belirlenir. Her makinenin bir çalışan olmasının yanı sıra, kontrol noktalarını kaydetme ve TensorBoard'a özet dosyaları yazma gibi bazı ek işleri üstlenen bir çalışan da olmalıdır. Bu makine, şef olarak bilinir. Her zaman yalnızca bir baş çalışan olduğundan, çalışan havuzu 0 için çalışan sayınız her zaman 1 olur.

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:

GPU eklemeyi seçebilirsiniz ancak kümenizdeki her makinenin aynı sayıda GPU'ya sahip olması gerektiğini unutmayın.MultiWorkerMirroredStrategy GPU eklemek eğitim işinin maliyetini de artırır.

1. çalışan havuzu, kümenizin çalışanlarını 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'ya sahip iki makine içerecek şekilde yapılandırıldı. Eğitim uygulaması kodu çalıştırıldığında MultiWorkerMirroredStrategy, eğitimi her iki makineye de dağıtır.

MultiWorkerMirroredStrategy yalnızca yönetici ve çalışan görev türlerine sahiptir. Bu nedenle, ek çalışan havuzlarını yapılandırmanıza gerek yoktur. Ancak TensorFlow'un ParameterServerStrategy özelliğini kullanırsanız parametre sunucularınızı çalışan havuzu 2'de yapılandırırsınız. Kümenize bir değerlendirici eklemek isterseniz bu makineyi worker pool 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 İŞLEME HATTI sekmesinde yeni başlattığınız işi görürsünüz:

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

🎉 Tebrikler! 🎉

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

• Özel bir kapsayıcıda sağlanan eğitim kodunu eğitmek için çok çalışanlı bir eğitim işi başlatın. Bu örnekte bir TensorFlow modeli kullanıldı 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'yı kullanma

Önceki bölümde, eğitim işinin kullanıcı arayüzü üzerinden nasıl başlatılacağı gösterilmişti. 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 TensorFlow 2 not defteri oluşturun:

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

from google.cloud import aiplatform

Çoklu çalışan eğitim işini başlatmak için önce çalışan havuzu spesifikasyonunu tanımlamanız gerekir. Spesifikasyonda GPU kullanımı tamamen isteğe bağlıdır. Yalnızca CPU'lu bir küme istiyorsanız önceki bölümde gösterildiği gibi 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"}
      }
]

Ardından bir CustomJob oluşturup çalıştırın. {YOUR_BUCKET} yerine projenizde hazırlama için bir paket kullanmanız 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 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: