Nguyên mẫu cho kênh phát hành công khai: Chương trình đào tạo phân tán về Vertex AI

1. Tổng quan

Trong bài tập thực hành này, bạn sẽ sử dụng Vertex AI để chạy một công việc huấn luyện phân tán trên Vertex AI Training bằng TensorFlow.

Bài tập thực hành này là một phần trong loạt video Từ nguyên mẫu đến vận hành thực tế. Hãy nhớ hoàn thành các bài tập thực hành trước đó trước khi thử bài tập thực hành này. Bạn có thể xem loạt video đi kèm để tìm hiểu thêm:

.

Kiến thức bạn sẽ học được

Bạn sẽ tìm hiểu cách:

• Chạy quá trình huấn luyện phân tán trên một máy có nhiều GPU
• Chạy quá trình huấn luyện phân tán trên nhiều máy

Tổng chi phí để chạy bài tập thực hành này trên Google Cloud là khoảng 2 USD.

2. Giới thiệu về Vertex AI

Bài tập thực hành này sử dụng sản phẩm AI mới nhất hiện có trên Google Cloud. Vertex AI tích hợp các sản phẩm học máy trên Google Cloud để mang lại trải nghiệm phát triển liền mạch. Trước đây, các mô hình được huấn luyện bằng AutoML và các mô hình tuỳ chỉnh có thể truy cập thông qua các dịch vụ riêng biệt. Sản phẩm mới này kết hợp cả hai thành một API duy nhất, cùng với các sản phẩm mới khác. Bạn cũng có thể di chuyển các dự án hiện có sang Vertex AI.

Vertex AI bao gồm nhiều sản phẩm khác nhau để hỗ trợ quy trình học máy đầu cuối. Bài tập thực hành này sẽ tập trung vào các sản phẩm được nêu bật bên dưới: Huấn luyện và Workbench

3. Tổng quan về huấn luyện phân tán

Nếu bạn có một GPU, TensorFlow sẽ sử dụng bộ tăng tốc này để tăng tốc quá trình huấn luyện mô hình mà bạn không cần phải làm gì thêm. Tuy nhiên, nếu muốn tăng thêm hiệu suất bằng cách sử dụng nhiều GPU, thì bạn cần sử dụng tf.distribute. Đây là mô-đun của TensorFlow để chạy một phép tính trên nhiều thiết bị.

Phần đầu tiên của bài tập thực hành này sử dụng tf.distribute.MirroredStrategy. Bạn có thể thêm chiến lược này vào các ứng dụng huấn luyện chỉ bằng một vài thay đổi về mã. Chiến lược này tạo một bản sao của mô hình trên mỗi GPU trên máy của bạn. Các bản cập nhật độ dốc tiếp theo sẽ diễn ra một cách đồng bộ. Điều này có nghĩa là mỗi GPU tính toán các lượt chuyển tiếp và chuyển ngược thông qua mô hình trên một phần dữ liệu đầu vào khác nhau. Sau đó, các độ dốc được tính toán từ mỗi phần này sẽ được tổng hợp trên tất cả các GPU và được tính trung bình trong một quy trình được gọi là all-reduce. Các tham số mô hình được cập nhật bằng các độ dốc được tính trung bình này.

Phần không bắt buộc ở cuối bài tập thực hành sử dụng tf.distribute.MultiWorkerMirroredStrategy. Chiến lược này tương tự như MirroredStrategy, ngoại trừ việc chiến lược này hoạt động trên nhiều máy. Mỗi máy này cũng có thể có nhiều GPU. Giống như MirroredStrategy, MultiWorkerMirroredStrategy là một chiến lược song song hoá dữ liệu đồng bộ mà bạn có thể sử dụng chỉ với một vài thay đổi về mã. Sự khác biệt chính khi chuyển từ song song hoá dữ liệu đồng bộ trên một máy sang nhiều máy là các độ dốc ở cuối mỗi bước hiện cần được đồng bộ hoá trên tất cả các GPU trong một máy và trên tất cả các máy trong cụm.

Bạn không cần biết chi tiết để hoàn thành bài tập thực hành này, nhưng nếu muốn tìm hiểu thêm về cách hoạt động của quá trình huấn luyện phân tán trong TensorFlow, hãy xem video bên dưới:

4. Thiết lập môi trường

Hoàn thành các bước trong bài tập thực hành Huấn luyện các mô hình tuỳ chỉnh bằng Vertex AI để thiết lập môi trường.

5. Huấn luyện nhiều GPU trên một máy

Bạn sẽ gửi công việc huấn luyện phân tán đến Vertex AI bằng cách đặt mã xử lý ứng dụng huấn luyện vào một vùng chứa Docker và đẩy vùng chứa này lên Google Artifact Registry. Bằng cách sử dụng phương pháp này, bạn có thể huấn luyện một mô hình được xây dựng bằng bất kỳ khung nào.

Để bắt đầu, trong trình đơn Trình chạy của sổ tay Workbench mà bạn đã tạo trong các bài tập thực hành trước, hãy mở một cửa sổ dòng lệnh.

Bước 1: Viết mã huấn luyện

Tạo một thư mục mới có tên là flowers-multi-gpu rồi chuyển đến thư mục đó:

mkdir flowers-multi-gpu
cd flowers-multi-gpu

Chạy lệnh sau để tạo một thư mục cho mã huấn luyện và một tệp Python nơi bạn sẽ thêm mã bên dưới.

mkdir trainer
touch trainer/task.py

Bây giờ, bạn sẽ có nội dung sau trong thư mục flowers-multi-gpu/:

+ trainer/
    + task.py

Tiếp theo, hãy mở tệp task.py mà bạn vừa tạo rồi sao chép mã bên dưới.

Bạn cần thay thế {your-gcs-bucket} trong BUCKET_ROOT bằng bộ chứa Cloud Storage nơi bạn đã lưu trữ tập dữ liệu hoa trong Bài tập thực hành 1.

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

Trước khi bạn xây dựng vùng chứa, hãy xem xét kỹ hơn về mã. Có một số thành phần dành riêng cho việc sử dụng huấn luyện phân tán.

• Trong hàm main(), đối tượng MirroredStrategy được tạo. Tiếp theo, bạn gói quá trình tạo các biến mô hình trong phạm vi của chiến lược. Bước này cho TensorFlow biết những biến nào sẽ được nhân bản trên các GPU.
• Kích thước lô được tăng lên theo num_replicas_in_sync. Tăng kích thước lô là phương pháp hay nhất khi sử dụng các chiến lược song song hoá dữ liệu đồng bộ trong TensorFlow. Bạn có thể tìm hiểu thêm tại đây.

Bước 2: Tạo Dockerfile

Để tạo vùng chứa cho mã, bạn cần tạo một Dockerfile. Trong Dockerfile, bạn sẽ đưa vào tất cả các lệnh cần thiết để chạy hình ảnh. Lệnh này sẽ cài đặt tất cả các thư viện cần thiết và thiết lập điểm vào cho mã huấn luyện.

Trong Dòng lệnh, hãy tạo một Dockerfile trống trong thư mục gốc của thư mục hoa:

touch Dockerfile

Bây giờ, bạn sẽ có nội dung sau trong thư mục flowers-multi-gpu/:

+ Dockerfile
+ trainer/
    + task.py

Mở Dockerfile rồi sao chép nội dung sau vào đó:

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

Bước 3: Xây dựng vùng chứa

Trong Dòng lệnh, hãy chạy lệnh sau để xác định một biến môi trường cho dự án của bạn, nhớ thay thế your-cloud-project bằng mã dự án:

Bạn có thể lấy mã dự án bằng cách chạy gcloud config list --format 'value(core.project)' trong dòng lệnh

PROJECT_ID='your-cloud-project'

Tạo một kho lưu trữ trong Artifact Registry. Chúng ta sẽ sử dụng kho lưu trữ mà chúng ta đã tạo trong bài tập thực hành đầu tiên.

REPO_NAME='flower-app'

Xác định một biến có URI của hình ảnh vùng chứa trong Artifact Registry:

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:single_machine

Định cấu hình Docker

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

Sau đó, hãy xây dựng vùng chứa bằng cách chạy lệnh sau từ thư mục gốc của thư mục flowers-multi-gpu:

docker build ./ -t $IMAGE_URI

Cuối cùng, hãy đẩy vùng chứa đó lên Artifact Registry:

docker push $IMAGE_URI

Sau khi vùng chứa được đẩy lên Artifact Registry, bạn có thể bắt đầu công việc huấn luyện.

Bước 4: Chạy công việc bằng SDK

Trong phần này, bạn sẽ thấy cách định cấu hình và chạy công việc huấn luyện phân tán bằng Vertex AI Python SDK.

Trong Trình chạy, hãy tạo một sổ tay TensorFlow 2.

Nhập Vertex AI SDK.

from google.cloud import aiplatform

Sau đó, hãy xác định CustomContainerTrainingJob.

Bạn cần thay thế {PROJECT_ID} trong container_uri và {YOUR_BUCKET} trong staging_bucket.

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

Sau khi xác định công việc, bạn có thể chạy công việc đó. Bạn sẽ đặt số lượng bộ tăng tốc là 2. Nếu chỉ sử dụng 1 GPU, thì đây sẽ không được coi là huấn luyện phân tán. Huấn luyện phân tán trên một máy là khi bạn sử dụng 2 bộ tăng tốc trở lên.

my_custom_job.run(replica_count=1,
                  machine_type='n1-standard-4',
                  accelerator_type='NVIDIA_TESLA_V100',
                  accelerator_count=2)

Trong bảng điều khiển, bạn có thể thấy tiến trình của công việc.

6. [Không bắt buộc] Huấn luyện nhiều worker

Giờ đây, khi đã thử huấn luyện phân tán trên một máy có nhiều GPU, bạn có thể nâng cao kỹ năng huấn luyện phân tán bằng cách huấn luyện trên nhiều máy. Để giảm chi phí, chúng ta sẽ không thêm bất kỳ GPU nào vào các máy đó, nhưng bạn có thể thử nghiệm bằng cách thêm GPU nếu muốn.

Mở một cửa sổ dòng lệnh mới trong phiên bản sổ tay:

Bước 1: Viết mã huấn luyện

Tạo một thư mục mới có tên là flowers-multi-machine rồi chuyển đến thư mục đó:

mkdir flowers-multi-machine
cd flowers-multi-machine

Chạy lệnh sau để tạo một thư mục cho mã huấn luyện và một tệp Python nơi bạn sẽ thêm mã bên dưới.

mkdir trainer
touch trainer/task.py

Bây giờ, bạn sẽ có nội dung sau trong thư mục flowers-multi-machine/:

+ trainer/
    + task.py

Tiếp theo, hãy mở tệp task.py mà bạn vừa tạo rồi sao chép mã bên dưới.

Bạn cần thay thế {your-gcs-bucket} trong BUCKET_ROOT bằng bộ chứa Cloud Storage nơi bạn đã lưu trữ tập dữ liệu hoa trong Bài tập thực hành 1.

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

Trước khi bạn xây dựng vùng chứa, hãy xem xét kỹ hơn về mã. Có một số thành phần trong mã cần thiết để ứng dụng huấn luyện của bạn hoạt động với MultiWorkerMirroredStrategy.

• Trong hàm main(), đối tượng MultiWorkerMirroredStrategy được tạo. Tiếp theo, bạn gói quá trình tạo các biến mô hình trong phạm vi của chiến lược. Bước quan trọng này cho TensorFlow biết những biến nào sẽ được nhân bản trên các bản sao.
• Kích thước lô được tăng lên theo num_replicas_in_sync. Tăng kích thước lô là phương pháp hay nhất khi sử dụng các chiến lược song song hoá dữ liệu đồng bộ trong TensorFlow.
• Việc lưu mô hình sẽ phức tạp hơn một chút trong trường hợp nhiều worker vì đích đến cần phải khác nhau đối với mỗi worker. Worker chính sẽ lưu vào thư mục mô hình mong muốn, trong khi các worker khác sẽ lưu mô hình vào các thư mục tạm thời. Điều quan trọng là các thư mục tạm thời này phải là duy nhất để ngăn nhiều worker ghi vào cùng một vị trí. Việc lưu có thể chứa các thao tác tập thể, nghĩa là tất cả các worker phải lưu chứ không chỉ worker chính. Các hàm _is_chief(), _get_temp_dir(), write_filepath() cũng như hàm main() đều bao gồm mã nguyên mẫu giúp lưu mô hình.

Xin lưu ý rằng nếu đã sử dụng MultiWorkerMirroredStrategy trong một môi trường khác, thì bạn có thể đã thiết lập biến môi trường TF_CONFIG. Vertex AI tự động thiết lập TF_CONFIG cho bạn, vì vậy, bạn không cần xác định biến này trên mỗi máy trong cụm.

Bước 2: Tạo Dockerfile

Để tạo vùng chứa cho mã, bạn cần tạo một Dockerfile. Trong Dockerfile, bạn sẽ đưa vào tất cả các lệnh cần thiết để chạy hình ảnh. Lệnh này sẽ cài đặt tất cả các thư viện cần thiết và thiết lập điểm vào cho mã huấn luyện.

Trong Dòng lệnh, hãy tạo một Dockerfile trống trong thư mục gốc của thư mục hoa:

touch Dockerfile

Bây giờ, bạn sẽ có nội dung sau trong thư mục flowers-multi-machine/:

+ Dockerfile
+ trainer/
    + task.py

Mở Dockerfile rồi sao chép nội dung sau vào đó:

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

Bước 3: Xây dựng vùng chứa

Trong Dòng lệnh, hãy chạy lệnh sau để xác định một biến môi trường cho dự án của bạn, nhớ thay thế your-cloud-project bằng mã dự án:

Bạn có thể lấy mã dự án bằng cách chạy gcloud config list --format 'value(core.project)' trong dòng lệnh

PROJECT_ID='your-cloud-project'

Tạo một kho lưu trữ trong Artifact Registry. Chúng ta sẽ sử dụng kho lưu trữ mà chúng ta đã tạo trong bài tập thực hành đầu tiên.

REPO_NAME='flower-app'

Xác định một biến có URI của hình ảnh vùng chứa trong Google Artifact Registry:

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:multi_machine

Định cấu hình Docker

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

Sau đó, hãy xây dựng vùng chứa bằng cách chạy lệnh sau từ thư mục gốc của thư mục flowers-multi-machine:

docker build ./ -t $IMAGE_URI

Cuối cùng, hãy đẩy vùng chứa đó lên Artifact Registry:

docker push $IMAGE_URI

Sau khi vùng chứa được đẩy lên Artifact Registry, bạn có thể bắt đầu công việc huấn luyện.

Bước 4: Chạy công việc bằng SDK

Trong phần này, bạn sẽ thấy cách định cấu hình và chạy công việc huấn luyện phân tán bằng Vertex AI Python SDK.

Trong Trình chạy, hãy tạo một sổ tay TensorFlow 2.

Nhập Vertex AI SDK.

from google.cloud import aiplatform

Sau đó, hãy xác định worker_pool_specs.

Vertex AI cung cấp 4 nhóm worker để bao gồm các loại tác vụ máy khác nhau.

Nhóm worker 0 định cấu hình Primary, chief, scheduler hoặc "master". Trong MultiWorkerMirroredStrategy, tất cả các máy đều được chỉ định là worker. Đây là các máy vật lý nơi thực thi phép tính được sao chép. Ngoài việc mỗi máy là một worker, cần có một worker đảm nhận một số công việc bổ sung, chẳng hạn như lưu điểm kiểm tra và ghi tệp tóm tắt vào TensorBoard. Máy này được gọi là chief. Chỉ có một worker chief, vì vậy, số lượng worker cho Nhóm worker 0 sẽ luôn là 1.

Nhóm worker 1 là nơi bạn định cấu hình các worker bổ sung cho cụm.

Từ điển đầu tiên trong danh sách worker_pool_specs đại diện cho Nhóm worker 0 và từ điển thứ hai đại diện cho Nhóm worker 1. Trong mẫu này, hai cấu hình giống hệt nhau. Tuy nhiên, nếu muốn huấn luyện trên 3 máy, bạn sẽ thêm các worker bổ sung vào Nhóm worker 1 bằng cách đặt replica_count thành 2. Nếu muốn thêm GPU, bạn cần thêm các đối số accelerator_type và accelerator_count vào machine_spec cho cả hai nhóm worker. Xin lưu ý rằng nếu bạn muốn sử dụng GPU với MultiWorkerMirroredStrategy, thì mỗi máy trong cụm phải có số lượng GPU giống hệt nhau. Nếu không, công việc sẽ không thành công.

Bạn cần thay thế {PROJECT_ID} trong image_uri.

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

Tiếp theo, hãy tạo và chạy CustomJob, thay thế {YOUR_BUCKET} trong staging_bucket bằng một bộ chứa trong dự án của bạn để dàn dựng.

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

Trong bảng điều khiển, bạn có thể thấy tiến trình của công việc.

🎉 Xin chúc mừng! 🎉

Bạn đã tìm hiểu cách sử dụng Vertex AI để:

• Chạy các công việc huấn luyện phân tán bằng TensorFlow

Để tìm hiểu thêm về các phần khác nhau của Vertex, hãy xem tài liệu.

7. Dọn dẹp

Vì chúng ta đã định cấu hình sổ tay để hết thời gian chờ sau 60 phút không hoạt động, nên chúng ta không cần lo lắng về việc tắt phiên bản. Nếu muốn tắt phiên bản theo cách thủ công, hãy nhấp vào nút Dừng trên phần Vertex AI Workbench của bảng điều khiển. Nếu muốn xoá hoàn toàn sổ tay, hãy nhấp vào nút Xoá.

Để xoá vùng chứa lưu trữ, hãy sử dụng trình đơn Điều hướng trong Cloud Console, duyệt đến phần Lưu trữ, chọn vùng chứa của bạn rồi nhấp vào Xoá: