1. Genel Bakış
Bu laboratuvarda, TensorFlow'u kullanarak Vertex AI Eğitimi'nde dağıtılmış bir eğitim 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 laboratuvardan önce önceki laboratuvarları tamamladığınızdan emin olun. Daha fazla bilgi edinmek için aşağıdaki video serisini izleyebilirsiniz:
.
Öğrenecekleriniz
Öğrenecekleriniz:
- Birden fazla GPU'ya sahip tek bir makinede dağıtılmış eğitim çalıştırma
- Birden çok makinede dağıtılmış eğitim çalıştırma
Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 2 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. Önceden, AutoML ve özel modellerle eğitilen 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.
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ılmaktadır: training ve Workbench
3. Dağıtılmış eğitime genel bakış
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 birden fazla GPU kullanarak ek bir artış elde etmek istiyorsanız TensorFlow'un birden fazla cihazda hesaplama çalıştırma modülü olan tf.distribute'ü kullanmanız gerekir.
Bu laboratuvarın ilk bölümünde, yalnızca birkaç kod değişikliğiyle eğitim uygulamalarınıza ekleyebileceğiniz tf.distribute.MirroredStrategy kullanılır. Bu strateji, makinenizdeki her GPU'da modelin bir kopyasını oluşturur. Sonraki gradyan güncellemeleri senkronize 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 gradyanlar daha sonra tüm GPU'larda toplanır ve all-reduce olarak bilinen bir işlemde ortalaması alınır. Model parametreleri, bu ortalama gradyanlar kullanılarak güncellenir.
Laboratuvarın sonundaki isteğe bağlı bölümde tf.distribute.MultiWorkerMirroredStrategy kullanılır. tf.distribute.MultiWorkerMirroredStrategy, birden fazla makinede çalışabilmesi dışında MirroredStrategy'e benzer. Bu makinelerin her birinde de birden fazla GPU olabilir. MirroredStrategy gibi MultiWorkerMirroredStrategy da yalnızca birkaç kod değişikliğiyle kullanabileceğiniz senkron veri paralelliği stratejisidir. Bir makinedeki senkronize veri paralelliğinden birden fazla makineye geçişte en önemli fark, her adımın sonundaki gradyanların artık bir makinedeki tüm GPU'lar ve kümedeki tüm makineler arasında senkronize edilmesi gerektiğidir.
Bu laboratuvarı tamamlamak için ayrıntıları bilmeniz gerekmez ancak dağıtık eğitimin TensorFlow'da işleyiş şekli hakkında daha fazla bilgi edinmek istiyorsanız aşağıdaki videoya göz atın:
4. Ortamınızı ayarlama
Ortamınızı ayarlamak için Vertex AI ile özel modelleri eğitme laboratuvarındaki adımları tamamlayın.
5. Tek makine, çoklu GPU eğitimi
Eğitim uygulamanızın kodunu bir Docker container'ına yerleştirip bu container'ı Google Artifact Registry'ye göndererek dağıtılmış eğitim işinizi Vertex AI'a gönderirsiniz. Bu yaklaşımı kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebilirsiniz.
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-multi-gpu adlı yeni bir dizin oluşturun ve cd komutuyla bu dizine gidin:
mkdir flowers-multi-gpu
cd flowers-multi-gpu
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-multi-gpu/ dizininde şu dosyalar bulunmalıdır:
+ trainer/
+ task.py
Sonra, az önce 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, 1. Laboratuvar'da çiçekler veri kümesini depoladığınız Cloud Storage paketiyle değiştirmeniz gerekir.
import tensorflow as tf
import numpy as np
import os
## 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 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():
'''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(128, activation='relu'),
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
])
return model
def main():
# Create distribution strategy
strategy = tf.distribute.MirroredStrategy()
# Get data
GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
# Wrap model creation and compilation within scope of strategy
with strategy.scope():
model = create_model()
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
history = model.fit(
train_dataset,
validation_data=validation_dataset,
epochs=EPOCHS
)
model.save(f'{BUCKET_ROOT}/model_output')
if __name__ == "__main__":
main()
Kapsayıcıyı oluşturmadan önce kodu daha ayrıntılı bir şekilde inceleyelim. Dağıtılmış eğitimi kullanmaya özgü birkaç bileşen vardır.
main()işlevindeMirroredStrategynesnesi 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.- Grup boyutu
num_replicas_in_syncile ölçeklendirilir. TensorFlow'da senkron veri paralelliği stratejileri kullanırken grup boyutunu ölçeklendirmek en iyi uygulamadır. Buradan daha fazla bilgi edinebilirsiniz.
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.
Terminalinizde, flowers dizininizin kökünde boş bir Dockerfile oluşturun:
touch Dockerfile
Artık flowers-multi-gpu/ dizininizde aşağıdakilerin olması gerekir:
+ Dockerfile
+ trainer/
+ task.py
Dockerfile dosyasını açın ve aşağıdakileri kopyalayın:
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8
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"]
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:
PROJECT_ID='your-cloud-project'
Artifact Registry'de bir depo oluşturun. İlk laboratuvarda oluşturduğumuz deposu kullanacağız.
REPO_NAME='flower-app'
Artifact Registry'deki kapsayıcı 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_distributed:single_machine
Docker'ı yapılandırma
gcloud auth configure-docker \
us-central1-docker.pkg.dev
Ardından, flowers-multi-gpu 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.
4. Adım: İşi SDK ile çalıştırın
Bu bölümde, Vertex AI Python SDK'sını kullanarak dağıtık eğitim işinin nasıl yapılandırılacağını ve başlatılacağını göreceksiniz.
Launcher'dan bir TensorFlow 2 not defteri oluşturun.
Vertex AI SDK'sını içe aktarın.
from google.cloud import aiplatform
Ardından bir CustomContainerTrainingJob tanımlayın.
container_uri için {PROJECT_ID}, staging_bucket içinse {YOUR_BUCKET} değerini değiştirmeniz gerekir.
job = aiplatform.CustomContainerTrainingJob(display_name='flowers-multi-gpu',
container_uri='us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:single_machine',
staging_bucket='gs://{YOUR_BUCKET}')
İş tanımlandıktan sonra çalıştırabilirsiniz. Hızlandırıcı sayısını 2 olarak ayarlarsınız. Yalnızca 1 GPU kullanılıyorsa bu dağıtık eğitim olarak değerlendirilmez. Tek bir makinede dağıtılmış eğitimde 2 veya daha fazla hızlandırıcı kullanılır.
my_custom_job.run(replica_count=1,
machine_type='n1-standard-4',
accelerator_type='NVIDIA_TESLA_V100',
accelerator_count=2)
Konsolda işinizin ilerleme durumunu görebilirsiniz.
6. [İsteğe bağlı] Çok çalışanlı eğitim
Artık birden fazla GPU'ya sahip tek bir makinede dağıtılmış eğitimler denediniz. Artık birden fazla makinede eğitim yaparak dağıtılmış eğitim becerilerinizi bir üst seviyeye taşıyabilirsiniz. Maliyetleri düşük tutmak için bu makinelere GPU eklemeyiz ancak isterseniz GPU ekleyerek denemeler yapabilirsiniz.
Not defteri örneğinizde yeni bir terminal penceresi açın:
1. adım: Eğitim kodunu yazın
flowers-multi-machine adında yeni bir dizin oluşturun ve cd'ye ekleyin:
mkdir flowers-multi-machine
cd flowers-multi-machine
Eğitim kodu için bir dizin ve aşağıdaki kodu ekleyeceğiniz Python dosyası oluşturmak için aşağıdaki komutu çalıştırın.
mkdir trainer
touch trainer/task.py
Artık flowers-multi-machine/ dizininizde aşağıdakilerin olması gerekir:
+ 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, 1. Laboratuvar'da çiçekler veri kümesini depoladığınız Cloud Storage paketiyle değiştirmeniz gerekir.
import tensorflow as tf
import numpy as np
import os
## 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'
SAVE_MODEL_DIR = f'{BUCKET_ROOT}/multi-machine-output'
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():
'''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(128, activation='relu'),
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
])
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 distribution strategy
strategy = tf.distribute.MultiWorkerMirroredStrategy()
# Get data
GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
# Wrap variable creation within strategy scope
with strategy.scope():
model = create_model()
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
history = model.fit(
train_dataset,
validation_data=validation_dataset,
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(SAVE_MODEL_DIR, task_type, task_id)
model.save(write_model_path)
if __name__ == "__main__":
main()
Kapsayıcıyı oluşturmadan önce kodu daha ayrıntılı bir şekilde inceleyelim. Kodda, eğitim uygulamanızın MultiWorkerMirroredStrategy ile çalışması için gereken birkaç bileşen vardır.
main()işlevindeMultiWorkerMirroredStrategynesnesi 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 kopyalara yansıtılması gerektiğini söyler.- Grup boyutu
num_replicas_in_syncile ölçeklendirilir. TensorFlow'da senkron veri paralelliği stratejileri kullanırken grup boyutunu ölçeklendirmek en iyi uygulamadır. - Hedefin her çalışan için farklı olması gerektiğinden, çok çalışanlı bir durumda modelinizi kaydetmek 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()vemain()işlevlerinin tümü, modeli kaydetmeye yardımcı olan standart kod içerir.
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 çiçek dizininizin kök dizininde boş bir Dockerfile oluşturun:
touch Dockerfile
flowers-multi-machine/ dizininde şu dosyalar bulunmalıdır:
+ Dockerfile
+ trainer/
+ task.py
Dockerfile'ı açın ve aşağıdakini bu dosyaya kopyalayın:
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8
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"]
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:
PROJECT_ID='your-cloud-project'
Artifact Registry'de depo oluşturun. Oluşturduğumuz depoyu ilk laboratuvarda kullanacağız.
REPO_NAME='flower-app'
Google Artifact Registry'deki container görüntünüzün URI'sıyla bir değişken tanımlayın:
IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:multi_machine
Docker'ı yapılandırma
gcloud auth configure-docker \
us-central1-docker.pkg.dev
Ardından, flowers-multi-machine 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
Container, Artifact Registry'ye aktarıldığında bir eğitim işi başlatmaya hazırsınız.
4. Adım: İşi SDK ile çalıştırın
Bu bölümde, Vertex AI Python SDK'sını kullanarak dağıtık eğitim işinin nasıl yapılandırılacağını ve başlatılacağını göreceksiniz.
Launcher'dan bir TensorFlow 2 not defteri oluşturun.
Vertex AI SDK'sını içe aktarın.
from google.cloud import aiplatform
Daha sonra, worker_pool_specs tanımlayın.
Vertex AI, farklı makine görevleri türlerini kapsayan 4 çalışan havuzu sunar.
0 numaralı çalışan havuzu birincil, şef, planlayıcı veya "ana"yı 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 bir çalışan olmasına ek olarak, kontrol noktalarını kaydetme ve TensorBoard'a özet dosyaları yazma gibi ek işler gerektiren bir çalışana ihtiyaç vardır. Bu makine şef olarak bilinir. Yalnızca bir baş çalışan vardır. Bu nedenle 0 numaralı çalışan havuzu için çalışan sayınız her zaman 1 olur.
1. çalışan havuzu, kümeniz için ek çalışanları yapılandırdığınız yerdir.
worker_pool_specs listesindeki ilk sözlük, çalışan havuzu 0'ı, ikinci sözlük ise çalışan havuzu 1'i temsil eder. Bu örnekte, iki yapılandırma aynıdır. Ancak 3 makinede eğitim yapmak istiyorsanız replica_count değerini 2 olarak ayarlayarak Çalışan havuzu 1'e ek çalışanlar eklersiniz. GPU eklemek istiyorsanız her iki çalışan havuzu için de machine_spec alanına accelerator_type ve accelerator_count bağımsız değişkenlerini eklemeniz gerekir. MultiWorkerMirroredStrategy ile GPU kullanmak istiyorsanız kümedeki her makinenin aynı sayıda GPU'ya sahip olması gerektiğini unutmayın. Aksi takdirde iş başarısız olur.
image_uri dosyasında {PROJECT_ID} değerini 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=[
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-4",
},
"container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
},
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-4",
},
"container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
}
]
Ardından, staging_bucket içindeki {YOUR_BUCKET} yerine hazırlık için projenizdeki bir paketle değiştirerek CustomJob oluşturup çalıştırın.
my_custom_job = aiplatform.CustomJob(display_name='flowers-multi-worker',
worker_pool_specs=worker_pool_specs,
staging_bucket='gs://{YOUR_BUCKET}')
my_custom_job.run()
Konsolda işinizin ilerleme durumunu görebilirsiniz.
🎉 Tebrikler! 🎉
Vertex AI'ı kullanarak şunları öğrendiniz:
- TensorFlow ile dağıtılmış eğitim işleri çalıştırma
Vertex'in farklı bölümleri hakkında daha fazla bilgi edinmek için belgelere göz atın.
7. 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:
