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 lớp học 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.

Lớp học lập trình này nằm trong loạt video Từ nguyên mẫu đến sản phẩm hoàn thiện. 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 quy trình huấn luyện phân tán trên một máy có nhiều GPU
  • Chạy quy trình huấn luyện phân tán 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

Lớp học 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 dịch vụ 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, bạn có thể truy cập vào các mô hình được huấn luyện bằng AutoML và mô hình tuỳ chỉnh thông qua các dịch vụ riêng biệt. Sản phẩm 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 bao gồm nhiều sản phẩm để hỗ trợ quy trình làm việc toàn diện về máy học. Lớp học này sẽ tập trung vào các sản phẩm được nêu dưới đây: Bài đào tạo và Workbench

Tổng quan về sản phẩm Vertex

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

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 tăng hiệu suất bằng cách sử dụng nhiều GPU, bạn cần sử dụng tf.distribute. Đây là mô-đun của TensorFlow để chạy phép tính trên nhiều thiết bị.

Phần đầu tiên của lớp học lập trình này sử dụng tf.distribute.MirroredStrategy. Bạn có thể thêm tf.distribute.MirroredStrategy vào các ứng dụng đào tạo của mình 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 lần cập nhật độ dốc tiếp theo sẽ diễn ra theo cách đồng bộ. Điều này có nghĩa là mỗi GPU tính toán các lượt truyền tới và lui 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 đó, các độ 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ả GPU và được tính trung bình trong một quy trình được gọi là tất cả giảm. Các thông số 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 thay đổi về mã. Điểm khác biệt chính khi chuyển từ tính năng song song 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ả GPU trong một máy và trên tất cả máy trong cụm.

Bạn không cần biết chi tiết để hoàn thành lớp học lập trình này, nhưng nếu muốn tìm hiểu thêm về cách hoạt động của tính năng 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 tất các bước trong lớp học Huấn luyện mô hình tuỳ chỉnh bằng Vertex AI để thiết lập môi trường.

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

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ã ứng dụng huấn luyện vào một 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.

Mở cửa sổ dòng lệnh trong 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-gpu rồi chuyển vào thư mục đó:

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

Chạy mã sau để tạo một thư mục cho mã huấn luyện và một tệp Python mà 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 và 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 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 mã. Có một số thành phần dành riêng cho việc sử dụng tính nă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 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 cần được phản chiếu trên các GPU.
  • Kích thước lô được điều chỉnh theo tỷ lệ bằng num_replicas_in_sync. Điều chỉnh quy mô 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 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

Để đóng gói 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. Công cụ 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, hãy tạo một Dockerfile trống trong thư mục gốc của thư mục flowers:

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 vào tệp đó:

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 Terminal, hãy chạy đoạn mã sau để xác định biến env cho dự án, nhớ thay thế your-cloud-project bằng mã nhận dạng của dự án:

PROJECT_ID='your-cloud-project'

Tạo kho lưu trữ trong Artifact Registry. Chúng ta sẽ sử dụng kho lưu trữ đã tạo trong lớp học đầ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 trong Cấu phần phần mềm:

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

Khi vùng chứa được đẩy vào Cấu phần phần mềm, bạn đã sẵn sàng 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ẽ 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.

new_notebook

Nhập SDK Vertex AI.

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ẽ 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ì đây không được coi là quá trình 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 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 sẽ thấy tiến trình của công việc.

multigpu_job

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 tôi sẽ không thêm 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 thực thể sổ tay:

Mở cửa sổ dòng lệnh trong 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 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 vài 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 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ệ. Điều chỉnh quy mô 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 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 khác nhau cho từng 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 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í. Thao tác lưu có thể chứa các thao tác tập thể, nghĩa là tất 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.

Bước 2: Tạo Dockerfile

Để đóng gói 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. Công cụ 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, hãy tạo một Dockerfile trống trong thư mục gốc của thư mục flowers:

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 vào tệp đó:

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 Terminal, hãy chạy đoạn mã sau để xác định biến env cho dự án, nhớ thay thế your-cloud-project bằng mã nhận dạng của dự án:

PROJECT_ID='your-cloud-project'

Tạo 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 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, hãy đẩy tệp này vào Artifact Registry:

docker push $IMAGE_URI

Khi vùng chứa được đẩy vào Cấu phần phần mềm, bạn đã sẵn sàng 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ẽ tìm hiểu cách định cấu hình và chạy công việc huấn luyện phân tán bằng cách sử dụng SDK Vertex AI Python.

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

new_notebook

Nhập SDK Vertex AI.

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ụ máy.

Nhóm worker 0 định cấu hình Primary (Chính), chief (trình lập lịch biểu) hoặc "master" (chính). Trong MultiWorkerMirroredStrategy, tất cả máy đều được chỉ định là worker, tức là các máy thực tế 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 thực hiện một số công việc bổ sung như lưu các đ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 chính. Chỉ có một worker chính, vì vậy, số lượng worker cho Worker pool 0 sẽ luôn là 1.

Worker pool 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 của bạn để tạo phiên bả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()

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

multi_worker_job

🎉 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 này.

7. Dọn dẹp

Vì chúng ta đã định cấu hình máy tính xách 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 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 trong mục Vertex AI Workbench (Bảng điều khiển Vertex AI) của bảng điều khiển. Nếu bạn muốn xoá toàn bộ sổ tay, hãy nhấp vào nút Xoá.

Dừng thực thể

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

Xoá bộ nhớ