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 phòng thí nghiệm này, bạn sẽ sử dụng Vertex AI để chạy một công việc đào tạo phân tán trong Vertex AI Training bằng TensorFlow.

Phòng thí nghiệm này nằm trong loạt video Nguyên mẫu để phát hành công khai. Hãy nhớ hoàn thành phòng thí nghiệm trước trước khi dùng thử phòng thí nghiệm 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 chương trình đào tạo phân phối trên một máy bằng nhiều GPU
• Chạy chương trình đào tạo được phân phối trên nhiều máy

Tổng chi phí để chạy phòng thí nghiệm này trên Google Cloud là khoảng 2 USD.

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

Phòng thí nghiệm này sử dụng sản phẩm AI mới nhất có trên Google Cloud. Vertex AI tích hợp các giải pháp học máy trên Google Cloud vào một 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à mô hình tuỳ chỉnh có thể truy cập được thông qua các dịch vụ riêng biệt. Dịch vụ mới 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 có nhiều sản phẩm nhằm hỗ trợ quy trình học máy toàn diện. Phòng thí nghiệm này sẽ tập trung vào các sản phẩm được làm nổi bật dưới đây: Đào tạo và Bàn làm việc

3. Tổng quan về chương trình đào tạo được phân phối

Nếu bạn có một GPU, TensorFlow sẽ sử dụng trình 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 làm gì thêm. Tuy nhiên, nếu muốn sử dụng nhiều GPU hiệu quả hơn nữa, bạn cần phải 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 phòng thí nghiệm này sử dụng tf.distribute.MirroredStrategy mà bạn có thể thêm vào ứng dụng huấn luyện chỉ bằng một vài lần thay đổi mã. Chiến lược này sẽ tạo bản sao của mô hình trên từng GPU trên máy của bạn. Các lần cập nhật độ dốc tiếp theo sẽ diễn ra một cách đồng bộ. Tức là mỗi GPU tính toán lượt tiến và lùi thông qua mô hình trên một lát cắt khác của dữ liệu đầu vào. Sau đó, độ dốc được tính toán từ mỗi lát cắt này được tổng hợp trên tất cả các GPU và tính trung bình trong một quy trình gọi là all-reduce. Các tham số của mô hình được cập nhật bằng các độ dốc trung bình này.

Phần không bắt buộc ở cuối phòng thí nghiệm sẽ sử dụng tf.distribute.MultiWorkerMirroredStrategy, tương tự như MirroredStrategy, ngoại trừ việc công cụ này hoạt động trên nhiều máy theo quy trình AcoRSS. Mỗi máy trong số này cũng có thể có nhiều GPU. Giống như MirroredStrategy, MultiWorkerMirroredStrategy là một chiến lược song song dữ liệu đồng bộ mà bạn có thể sử dụng chỉ với một vài lần thay đổi mã. Điểm khác biệt chính khi chuyển từ tính song song dữ liệu đồng bộ trên một máy sang nhiều máy là độ dốc ở cuối mỗi bước giờ cần được đồng bộ hoá trên tất 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 phải biết thông tin chi tiết để hoàn thành phòng thí nghiệm này, nhưng nếu bạn muốn tìm hiểu thêm về cách hoạt động của chương trình đào tạo phân tán trong TensorFlow, hãy xem video dưới đây:

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

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

5. Đào tạo máy đơn, nhiều GPU

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

Để bắt đầu, từ trình đơn Trình chạy của sổ tay Workbench mà bạn đã tạo trong các phòng thí nghiệm 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 và cd vào thư mục đó:

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

Chạy lệnh sau để tạo 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ó những nội dung sau trong thư mục flowers-multi-gpu/:

+ trainer/
    + task.py

Tiếp theo, hãy mở tệp task.py bạn vừa tạo rồi sao chép đoạn 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 Phòng thí nghiệm 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 tạo 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 phương thức huấn luyện phân tán.

• Trong hàm main(), đối tượng MirroredStrategy được tạo. Tiếp theo, bạn kết hợp việc tạo các biến mô hình trong phạm vi của chiến lược. Bước này sẽ cho TensorFlow biết những biến nào nên được phản chiếu trên các GPU.
• Kích thước lô được num_replicas_in_sync tăng tỷ lệ. Việc điều chỉnh quy mô kích thước lô là một phương pháp hay nhất khi sử dụng chiến lược tính song song 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 một Dockerfile

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

Trên Terminal, 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ó những nội dung sau trong thư mục flowers-multi-gpu/:

+ Dockerfile
+ trainer/
    + task.py

Mở Dockerfile và sao chép nội dung sau đây 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: Tạo vùng chứa

Trên cửa sổ dòng lệnh, hãy chạy lệnh sau để xác định một biến env cho dự án của bạn, nhớ thay thế your-cloud-project bằng mã dự án của bạ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ữ đã tạo trong phòng thí nghiệm đầu tiên.

REPO_NAME='flower-app'

Xác định một biến bằng URI của hình ảnh vùng chứa của bạn 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 tạo vùng chứa bằng cách chạy lệnh sau từ gốc của thư mục flowers-multi-gpu:

docker build ./ -t $IMAGE_URI

Cuối cùng, đẩy tệp này vào Artifact Registry:

docker push $IMAGE_URI

Với vùng chứa được đẩy vào Artifact Registry, giờ đây bạn đã sẵn sàng bắt đầu công việc đào tạo.

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

Trong phần này, bạn sẽ tìm hiểu cách định cấu hình và triển khai công việc huấn luyện phân tán bằng cách sử dụ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 một 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ẽ thiết lập số lượng trình tăng tốc là 2. Nếu chúng ta chỉ sử dụng 1 GPU, thì quá trình này sẽ không được coi là quy trình huấn luyện phân tán. Chương trình đào tạo được phân tán trên một máy đơn lẻ là khi bạn sử dụng 2 trình 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ể xem tiến trình công việc của mình.

6. [Không bắt buộc] Đào tạo nhiều nhân viên

Giờ đây, khi đã thử phân tán nội dung đào tạo trên một máy có nhiều GPU, bạn có thể nâng tầm kỹ năng đào tạo phân tán của mình bằng cách đào tạo trên nhiều máy. Để giảm chi phí, chúng tôi sẽ không thêm bất kỳ GPU nào vào những 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 thực thể 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 và cd vào thư mục đó:

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

Chạy lệnh sau để tạo 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ó những nội dung sau trong thư mục flowers-multi-machine/:

+ trainer/
    + task.py

Tiếp theo, hãy mở tệp task.py bạn vừa tạo rồi sao chép đoạn 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 Phòng thí nghiệm 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 tạo 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 kết hợp việc 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 giúp TensorFlow biết những biến nào nên được phản chiếu trên các bản sao.
• Kích thước lô được num_replicas_in_sync tăng tỷ lệ. Việc điều chỉnh quy mô kích thước lô là một phương pháp hay nhất khi sử dụng chiến lược tính song song 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 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 hoạt động tập thể, nghĩa là mọi nhân viên phải tiết kiệm chứ không chỉ người trưởng nhóm. Các hàm _is_chief(), _get_temp_dir(), write_filepath() cũng như hàm main() đều chứa 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 đặt TF_CONFIG cho bạn nên 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 một Dockerfile

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

Trên Terminal, 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ó những nội dung sau trong thư mục flowers-multi-machine/:

+ Dockerfile
+ trainer/
    + task.py

Mở Dockerfile và sao chép nội dung sau đây 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: Tạo vùng chứa

Trên cửa sổ dòng lệnh, hãy chạy lệnh sau để xác định một biến env cho dự án của bạn, nhớ thay thế your-cloud-project bằng mã dự án của bạ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ữ đã tạo trong phòng thí nghiệm đầu tiên.

REPO_NAME='flower-app'

Xác định một biến bằng URI của hình ảnh vùng chứa của bạn 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 tạo vùng chứa bằng cách chạy lệnh sau từ gốc của thư mục flowers-multi-machine:

docker build ./ -t $IMAGE_URI

Cuối cùng, đẩy tệp này vào Artifact Registry:

docker push $IMAGE_URI

Với vùng chứa được đẩy vào Artifact Registry, giờ đây bạn đã sẵn sàng bắt đầu công việc đào tạo.

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

Trong phần này, bạn sẽ tìm hiểu cách định cấu hình và triển khai công việc huấn luyện phân tán bằng cách sử dụ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 để xử lý nhiều loại tác vụ trong máy.

Nhóm Worker 0 định cấu hình thư mục Chính, trưởng, bộ lập lịch biểu hoặc "chính". Trong MultiWorkerMirroredStrategy, tất cả máy đều được chỉ định là worker (máy thực thi). Đây là các máy thực tế thực thi việc tính toán được sao chép. Ngoài mỗi máy là một worker, thì cần có một worker đảm nhận thêm một số công việc 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à máy trưởng. Chỉ có một worker chính, vì vậy, số lượng worker của bạn 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 của mình.

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, 2 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 nhân viên khác 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 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 để chạy thử.

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ể xem tiến trình công việc của mình.

🎉 Xin chúc mừng! 🎉

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

• Chạy công việc đào tạo 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 này.

7. Dọn dẹp

Vì đã định cấu hình sổ tay hết thời gian chờ sau 60 phút ở trạng thái rảnh, nên chúng ta không cần phải lo lắng về việc tắt thực thể. Nếu bạn muốn tắt thực thể 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 bạn muốn xoá hoàn toàn sổ tay, hãy nhấp vào nút Xoá.

Để xoá Bộ chứa Storage, hãy sử dụng trình đơn Điều hướng trong Cloud Console, duyệt đến Bộ nhớ, chọn bộ chứa rồi nhấp vào Xoá: