为自定义训练配置计算资源

执行自定义训练时，您的训练代码会在一个或多个虚拟机 (VM) 实例上运行。您可以配置用于训练的虚拟机类型：使用计算资源较多的虚拟机可加快训练速度，并允许您使用更大的数据集，不过，它们也可能会产生更多训练费用。

在某些情况下，您还可以使用 GPU 加速训练。GPU 会产生额外费用。

您也可以选择自定义训练作业的启动磁盘的类型和大小。

本文档介绍了可用于自定义训练的不同计算资源及其配置方法。

指定计算资源的位置

在 WorkerPoolSpec 中指定配置详细信息。根据您执行自定义训练的方式，请将此 WorkerPoolSpec 放入以下某个 API 字段中：

如果您执行分布式训练，则可以对每个工作器池使用不同的设置。

机器类型

在 WorkerPoolSpec 中，您必须在 machineSpec.machineType 字段中指定以下机器类型之一。工作器池中的每个副本都在具有指定机器类型的不同虚拟机上运行。

  • a2-ultragpu-1g*
  • a2-ultragpu-2g*
  • a2-ultragpu-4g*
  • a2-ultragpu-8g*
  • a2-highgpu-1g*
  • a2-highgpu-2g*
  • a2-highgpu-4g*
  • a2-highgpu-8g*
  • a2-megagpu-16g*
  • a3-highgpu-8g*
  • e2-standard-4
  • e2-standard-8
  • e2-standard-16
  • e2-standard-32
  • e2-highmem-2
  • e2-highmem-4
  • e2-highmem-8
  • e2-highmem-16
  • e2-highcpu-16
  • e2-highcpu-32
  • n2-standard-4
  • n2-standard-8
  • n2-standard-16
  • n2-standard-32
  • n2-standard-48
  • n2-standard-64
  • n2-standard-80
  • n2-highmem-2
  • n2-highmem-4
  • n2-highmem-8
  • n2-highmem-16
  • n2-highmem-32
  • n2-highmem-48
  • n2-highmem-64
  • n2-highmem-80
  • n2-highcpu-16
  • n2-highcpu-32
  • n2-highcpu-48
  • n2-highcpu-64
  • n2-highcpu-80
  • n1-standard-4
  • n1-standard-8
  • n1-standard-16
  • n1-standard-32
  • n1-standard-64
  • n1-standard-96
  • n1-highmem-2
  • n1-highmem-4
  • n1-highmem-8
  • n1-highmem-16
  • n1-highmem-32
  • n1-highmem-64
  • n1-highmem-96
  • n1-highcpu-16
  • n1-highcpu-32
  • n1-highcpu-64
  • n1-highcpu-96
  • c2-standard-4
  • c2-standard-8
  • c2-standard-16
  • c2-standard-30
  • c2-standard-60
  • m1-ultramem-40
  • m1-ultramem-80
  • m1-ultramem-160
  • m1-megamem-96
  • g2-standard-4*
  • g2-standard-8*
  • g2-standard-12*
  • g2-standard-16*
  • g2-standard-24*
  • g2-standard-32*
  • g2-standard-48*
  • g2-standard-96*
  • cloud-tpu*

* 上述列表中标有星号的机器类型必须与特定 GPU 或 TPU 搭配使用。请参阅本指南的以下部分。

如需了解每种机器类型的技术规范，请参阅有关机器类型的 Compute Engine 文档。如需了解每种机器类型进行自定义训练的费用，请参阅价格。

以下示例演示了创建 CustomJob 时指定机器类型的位置：

控制台

在 Google Cloud 控制台中，您无法直接创建 CustomJob。 但是，您可以创建一个创建 CustomJob 的 TrainingPipeline。在 Google Cloud 控制台中创建 TrainingPipeline 时，请在计算和价格步骤的机器类型字段中为每个工作器池指定机器类型。

gcloud

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,container-image-uri=CUSTOM_CONTAINER_IMAGE_URI

Java

在尝试此示例之前，请按照《Vertex AI 快速入门：使用客户端库》中的 Java 设置说明执行操作。如需了解详情，请参阅 Vertex AI Java API 参考文档。

如需向 Vertex AI 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。 


import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.ContainerSpec;
import com.google.cloud.aiplatform.v1.CustomJob;
import com.google.cloud.aiplatform.v1.CustomJobSpec;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.WorkerPoolSpec;
import java.io.IOException;

// Create a custom job to run machine learning training code in Vertex AI
public class CreateCustomJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";

    // Vertex AI runs your training application in a Docker container image. A Docker container
    // image is a self-contained software package that includes code and all dependencies. Learn
    // more about preparing your training application at
    // https://cloud.google.com/vertex-ai/docs/training/overview#prepare_your_training_application
    String containerImageUri = "CONTAINER_IMAGE_URI";
    createCustomJobSample(project, displayName, containerImageUri);
  }

  static void createCustomJobSample(String project, String displayName, String containerImageUri)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (JobServiceClient client = JobServiceClient.create(settings)) {
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-4")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_K80)
              .setAcceleratorCount(1)
              .build();

      ContainerSpec containerSpec =
          ContainerSpec.newBuilder().setImageUri(containerImageUri).build();

      WorkerPoolSpec workerPoolSpec =
          WorkerPoolSpec.newBuilder()
              .setMachineSpec(machineSpec)
              .setReplicaCount(1)
              .setContainerSpec(containerSpec)
              .build();

      CustomJobSpec customJobSpecJobSpec =
          CustomJobSpec.newBuilder().addWorkerPoolSpecs(workerPoolSpec).build();

      CustomJob customJob =
          CustomJob.newBuilder()
              .setDisplayName(displayName)
              .setJobSpec(customJobSpecJobSpec)
              .build();
      LocationName parent = LocationName.of(project, location);
      CustomJob response = client.createCustomJob(parent, customJob);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }
}

Node.js

在尝试此示例之前，请按照《Vertex AI 快速入门：使用客户端库》中的 Node.js 设置说明执行操作。如需了解详情，请参阅 Vertex AI Node.js API 参考文档。

如需向 Vertex AI 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const customJobDisplayName = 'YOUR_CUSTOM_JOB_DISPLAY_NAME';
// const containerImageUri = 'YOUR_CONTAINER_IMAGE_URI';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Job Service Client library
const {JobServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const jobServiceClient = new JobServiceClient(clientOptions);

async function createCustomJob() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const customJob = {
    displayName: customJobDisplayName,
    jobSpec: {
      workerPoolSpecs: [
        {
          machineSpec: {
            machineType: 'n1-standard-4',
            acceleratorType: 'NVIDIA_TESLA_K80',
            acceleratorCount: 1,
          },
          replicaCount: 1,
          containerSpec: {
            imageUri: containerImageUri,
            command: [],
            args: [],
          },
        },
      ],
    },
  };
  const request = {parent, customJob};

  // Create custom job request
  const [response] = await jobServiceClient.createCustomJob(request);

  console.log('Create custom job response:\n', JSON.stringify(response));
}
createCustomJob();

Python

如需了解如何安装或更新 Python，请参阅安装 Python 版 Vertex AI SDK。 如需了解详情，请参阅 Python API 参考文档。 

from google.cloud import aiplatform

def create_custom_job_sample(
    project: str,
    display_name: str,
    container_image_uri: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)
    custom_job = {
        "display_name": display_name,
        "job_spec": {
            "worker_pool_specs": [
                {
                    "machine_spec": {
                        "machine_type": "n1-standard-4",
                        "accelerator_type": aiplatform.gapic.AcceleratorType.NVIDIA_TESLA_K80,
                        "accelerator_count": 1,
                    },
                    "replica_count": 1,
                    "container_spec": {
                        "image_uri": container_image_uri,
                        "command": [],
                        "args": [],
                    },
                }
            ]
        },
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_custom_job(parent=parent, custom_job=custom_job)
    print("response:", response)

如需了解详情，请参阅 创建 CustomJob 指南。

GPU

如果您已编写训练代码以使用 GPU，则可以将工作器池配置为在每个虚拟机上使用一个或多个 GPU。为了使用 GPU，您必须使用 A2、N1 或 G2 机器类型。此外，将 n1-highmem-2 等较小的机器类型与 GPU 搭配使用可能会导致某些工作负载的日志记录失败，这是因为 CPU 存在限制。如果训练作业停止返回日志，请考虑选择更大的机器类型。

Vertex AI 支持以下类型的可用于自定义训练的 GPU：

  • NVIDIA_H100_80GB
  • NVIDIA_A100_80GB
  • NVIDIA_TESLA_A100 (NVIDIA A100 40 GB)
  • NVIDIA_TESLA_K80
  • NVIDIA_TESLA_P4
  • NVIDIA_TESLA_P100
  • NVIDIA_TESLA_T4
  • NVIDIA_TESLA_V100
  • NVIDIA_L4

如需详细了解各种 GPU 的技术规范，请参阅有关计算工作负载 GPU 的 Compute Engine 简短文档。如需了解每种机器类型进行自定义训练的费用，请参阅价格。

在 WorkerPoolSpec 中，在machineSpec.acceleratorType 字段中指定要使用的 GPU 类型，以及工作器池中每个虚拟机的 GPU 数量以在 machineSpec.acceleratorCount 字段中使用。但是，您对这些字段的选择必须符合以下要求：

  • 您选择的 GPU 类型必须在执行自定义训练的位置可用。并非所有区域都提供所有类型的 GPU。 了解区域可用性。

  • 您的配置只能使用特定数量的 GPU。例如，您可以在虚拟机上使用 2 或 4 个 NVIDIA_TESLA_T4 GPU，但不能使用 3 个 GPU。如需了解每种 GPU 有效的 acceleratorCount 值，请参阅以下兼容性表。

  • 您必须确保 GPU 配置能够为要使用的 GPU 机器类型提供足够的虚拟 CPU 和内存。例如，如果您在工作器池中使用 n1-standard-32 机器类型，则每个虚拟机都有 32 个虚拟 CPU 和 120 GB 内存。由于每个 NVIDIA_TESLA_V100 GPU 最多可提供 12 个虚拟 CPU 和 76 GB 内存，因此每个 n1-standard-32 虚拟机必须至少使用 4 个 GPU 才能满足其需求。（2 个 GPU 提供的资源就已足够，您不能指定 3 个 GPU。）

    以下兼容性表考虑到了此要求。

    请注意，对使用 GPU 进行自定义训练与在 Compute Engine 中使用 GPU 的区别，还具有以下额外限制：

    • 包含 8 的配置NVIDIA_TESLA_K80GPU 在所有区域和地区最多仅能提供 208 GB 的内存。
    • 配备了 4 个 NVIDIA_TESLA_P100 GPU 的配置在所有区域和地区最多只提供 64 个虚拟 CPU 和 208 GB 的内存。

以下兼容性表列出了 machineSpec.acceleratorCount 的有效值，具体取决于您对 machineSpec.machineType 和 machineSpec.acceleratorType 的选择：

每种机器类型的有效 GPU 数量
机器类型 NVIDIA_A100_80GB NVIDIA_TESLA_A100 NVIDIA_TESLA_K80 NVIDIA_TESLA_P4 NVIDIA_TESLA_P100 NVIDIA_TESLA_T4 NVIDIA_TESLA_V100 NVIDIA_L4
a2-ultragpu-1g 1
a2-ultragpu-2g 2
a2-ultragpu-4g 4
a2-ultragpu-8g 8
a2-highgpu-1g 1
a2-highgpu-2g 2
a2-highgpu-4g 4
a2-highgpu-8g 8
a2-megagpu-16g 16
n1-standard-4 1、2、4、8 1、2、4 1、2、4 1、2、4 1、2、4、8
n1-standard-8 1、2、4、8 1、2、4 1、2、4 1、2、4 1、2、4、8
n1-standard-16 2、4、8 1、2、4 1、2、4 1、2、4 2、4、8
n1-standard-32 4、8 2、4 2、4 2、4 4、8
n1-standard-64 4 4 8
n1-standard-96 4 4 8
n1-highmem-2 1、2、4、8 1、2、4 1、2、4 1、2、4 1、2、4、8
n1-highmem-4 1、2、4、8 1、2、4 1、2、4 1、2、4 1、2、4、8
n1-highmem-8 1、2、4、8 1、2、4 1、2、4 1、2、4 1、2、4、8
n1-highmem-16 2、4、8 1、2、4 1、2、4 1、2、4 2、4、8
n1-highmem-32 4、8 2、4 2、4 2、4 4、8
n1-highmem-64 4 4 8
n1-highmem-96 4 4 8
n1-highcpu-16 2、4、8 1、2、4 1、2、4 1、2、4 2、4、8
n1-highcpu-32 4、8 2、4 2、4 2、4 4、8
n1-highcpu-64 8 4 4 4 8
n1-highcpu-96 4 4 8
g2-standard-4 1
g2-standard-8 1
g2-standard-12 1
g2-standard-16 1
g2-standard-24 2
g2-standard-32 1
g2-standard-48 4
g2-standard-96 8

以下示例演示了创建 CustomJob 时在何处指定 GPU：

控制台

在 Google Cloud 控制台中，您无法直接创建 CustomJob。但是，您可以创建一个创建 CustomJob 的 TrainingPipeline。在 Google Cloud 控制台中创建 TrainingPipeline 时，您可以在计算和价格步骤中为每个工作器池指定 GPU。首先指定机器类型。然后，您可以在加速器类型和加速器数量字段中指定 GPU 详细信息。

gcloud

如需使用 Google Cloud CLI 工具指定 GPU，您必须使用 config.yaml 文件。例如：

config.yaml

workerPoolSpecs:
  machineSpec:
    machineType: MACHINE_TYPE
    acceleratorType: ACCELERATOR_TYPE
    acceleratorCount: ACCELERATOR_COUNT
  replicaCount: REPLICA_COUNT
  containerSpec:
    imageUri: CUSTOM_CONTAINER_IMAGE_URI

然后，运行如下命令：

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --config=config.yaml

Node.js

在尝试此示例之前，请按照《Vertex AI 快速入门：使用客户端库》中的 Node.js 设置说明执行操作。如需了解详情，请参阅 Vertex AI Node.js API 参考文档。

如需向 Vertex AI 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅为本地开发环境设置身份验证。 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const customJobDisplayName = 'YOUR_CUSTOM_JOB_DISPLAY_NAME';
// const containerImageUri = 'YOUR_CONTAINER_IMAGE_URI';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Job Service Client library
const {JobServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const jobServiceClient = new JobServiceClient(clientOptions);

async function createCustomJob() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const customJob = {
    displayName: customJobDisplayName,
    jobSpec: {
      workerPoolSpecs: [
        {
          machineSpec: {
            machineType: 'n1-standard-4',
            acceleratorType: 'NVIDIA_TESLA_K80',
            acceleratorCount: 1,
          },
          replicaCount: 1,
          containerSpec: {
            imageUri: containerImageUri,
            command: [],
            args: [],
          },
        },
      ],
    },
  };
  const request = {parent, customJob};

  // Create custom job request
  const [response] = await jobServiceClient.createCustomJob(request);

  console.log('Create custom job response:\n', JSON.stringify(response));
}
createCustomJob();

Python

如需了解如何安装或更新 Python，请参阅安装 Python 版 Vertex AI SDK。 如需了解详情，请参阅 Python API 参考文档。 

from google.cloud import aiplatform

def create_custom_job_sample(
    project: str,
    display_name: str,
    container_image_uri: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)
    custom_job = {
        "display_name": display_name,
        "job_spec": {
            "worker_pool_specs": [
                {
                    "machine_spec": {
                        "machine_type": "n1-standard-4",
                        "accelerator_type": aiplatform.gapic.AcceleratorType.NVIDIA_TESLA_K80,
                        "accelerator_count": 1,
                    },
                    "replica_count": 1,
                    "container_spec": {
                        "image_uri": container_image_uri,
                        "command": [],
                        "args": [],
                    },
                }
            ]
        },
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_custom_job(parent=parent, custom_job=custom_job)
    print("response:", response)

如需了解详情，请参阅 创建 CustomJob 指南。

TPU

如需使用张量处理单元 (TPU) 在 Vertex AI 上进行自定义训练，您可以将工作器池配置为使用 TPU 虚拟机。

在 Vertex AI 中使用 TPU 虚拟机时，您只能使用一个工作器池进行自定义训练，并且必须将此工作器池配置为仅使用一个副本。

如需在工作器池中使用 TPU 虚拟机，您必须使用以下配置之一：

  • 如需使用 TPU V2 配置 TPU 虚拟机，请在 WorkerPoolSpec 中指定以下字段：

    • 将 machineSpec.machineType 设置为 cloud-tpu。
    • 将 machineSpec.acceleratorType 设置为 TPU_V2。
    • 对于单个 TPU，将 machineSpec.acceleratorCount 设置为 8；对于 TPU Pod，则设置为 32 or multiple of 32。
    • 将 replicaCount 设置为 1。

  • 如需使用 TPU V3 配置 TPU 虚拟机，请在 WorkerPoolSpec 中指定以下字段：

    • 将 machineSpec.machineType 设置为 cloud-tpu。
    • 将 machineSpec.acceleratorType 设置为 TPU_V3。
    • 对于单个 TPU，将 machineSpec.acceleratorCount 设置为 8；对于 TPU Pod，则设置为 32+。
    • 将 replicaCount 设置为 1。

以下示例突出展示了如何在创建 CustomJob 时指定 TPU 虚拟机：

gcloud

如需使用 gcloud CLI 工具指定 TPU 虚拟机，您必须使用 config.yaml 文件。例如：

config.yaml

workerPoolSpecs:
  machineSpec:
    machineType: cloud-tpu
    acceleratorType: TPU_V2
    acceleratorCount: 8
  replicaCount: 1
  containerSpec:
    imageUri: CUSTOM_CONTAINER_IMAGE_URI

然后，运行如下命令：

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --config=config.yaml

如需了解详情，请参阅 CustomJob 创建指南。

启动磁盘选项

您可以选择为训练虚拟机自定义启动磁盘。工作器池中的所有虚拟机均使用相同类型和大小的启动磁盘。

  • 如需自定义每个训练虚拟机使用的启动磁盘类型，请在 WorkerPoolSpec 中指定 diskSpec.bootDiskType 字段。

    您可以将此字段设置为 pd-standard 以使用标准硬盘支持的标准永久性磁盘，也可以将其设置为 pd-ssd 以使用由固态硬盘支持的 SSD 永久性磁盘。默认值为 pd-ssd。

    如果训练代码对磁盘执行读写操作，则使用 pd-ssd 可能会增加性能。了解磁盘类型。

  • 如需自定义每个训练虚拟机使用的启动磁盘的大小（以 GB 为单位），在 WorkerPoolSpec 中指定 diskSpec.bootDiskSizeGb 字段。

    您可将此字段设为一个介于 100 到 64000（含）之间的整数。默认值为 100。

    如果您的训练代码将大量临时数据写入磁盘，则可能需要增加启动磁盘大小。请注意，您写入启动磁盘的任何数据都是临时的，在训练完成后，您便无法检索这些数据。

更改启动磁盘的类型和大小会影响自定义训练价格。

以下示例突出显示您在创建 CustomJob 时指定启动磁盘选项的位置：

控制台

在 Google Cloud 控制台中，您无法直接创建 CustomJob。但是，您可以创建一个创建 CustomJob 的 TrainingPipeline。在 Google Cloud 控制台中创建 TrainingPipeline 时，您可以在计算和价格步骤的磁盘类型下拉列表和磁盘大小 (GB)字段中为每个工作器池指定启动磁盘选项。

gcloud

如需使用 Google Cloud CLI 工具指定启动磁盘选项，您必须使用 config.yaml 文件。例如：

config.yaml

workerPoolSpecs:
  machineSpec:
    machineType: MACHINE_TYPE
  diskSpec:
    bootDiskType: DISK_TYPE
    bootDiskSizeGb: DISK_SIZE
  replicaCount: REPLICA_COUNT
  containerSpec:
    imageUri: CUSTOM_CONTAINER_IMAGE_URI

然后，运行如下命令：

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --config=config.yaml

如需了解详情，请参阅 创建 CustomJob 指南。

后续步骤