Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

הגדרת משאבי מחשוב לאימון ללא שרת (serverless) ב-Gemini Enterprise Agent Platform

כשמבצעים אימון ללא שרתים, קוד האימון מורץ במכונה וירטואלית (VM) אחת או יותר. אתם יכולים להגדיר את סוגי המכונות הווירטואליות שבהן תרצו להשתמש לאימון: שימוש במכונות וירטואליות עם יותר משאבי מחשוב יכול לזרז את האימון ולאפשר לכם לעבוד עם מערכי נתונים גדולים יותר, אבל הוא גם עלול להוביל לעלויות אימון גבוהות יותר.

במקרים מסוימים, אפשר גם להשתמש במעבדים גרפיים כדי להאיץ את האימון. שימוש ביחידות GPU כרוך בעלויות נוספות.

אפשר גם להתאים אישית את הסוג והגודל של דיסקי האתחול של מכונות ה-VM לאימון.

במאמר הזה מתוארים משאבי מחשוב שונים שאפשר להשתמש בהם לאימון בלי שרת (serverless), ומוסבר איך להגדיר אותם.

ניהול עלויות וזמינות

כדי לעזור לכם לנהל את העלויות או לוודא שהמשאבים של המכונות הווירטואליות זמינים, Agent Platform מספק את האפשרויות הבאות:

כדי לוודא שמשאבי המכונות הווירטואליות יהיו זמינים כשעבודות האימון יזדקקו להם, אפשר להשתמש בהזמנות של Compute Engine. הזמנות מספקות רמת ודאות גבוהה לגבי קבלת קיבולת למשאבי Compute Engine. מידע נוסף זמין במאמר בנושא שימוש בהזמנות עם אימון.
כדי להפחית את העלות של הרצת משימות האימון, אפשר להשתמש במכונות וירטואליות זמניות (Spot VMs). מכונות וירטואליות זמניות הן מופעים של מכונות וירטואליות (VM) שהן עודף קיבולת של Compute Engine. יש הנחות משמעותיות על מכונות וירטואליות זמניות, אבל Compute Engine עשוי להפסיק או למחוק אותן באופן יזום כדי לפנות קיבולת בכל שלב. מידע נוסף זמין במאמר שימוש במכונות וירטואליות זמניות לאימון.
במשימות אימון ללא שרת שמבקשות משאבי GPU, הכלי Dynamic Workload Scheduler מאפשר לתזמן את המשימות לפי הזמן שבו משאבי ה-GPU המבוקשים יהיו זמינים. מידע נוסף זמין במאמר בנושא תזמון של משימות אימון על סמך זמינות המשאבים.

איפה מציינים משאבי מחשוב

מציינים את פרטי ההגדרה בתוך תג WorkerPoolSpec. בהתאם לאופן שבו מבצעים אימון ללא שרת, צריך להזין את הערך WorkerPoolSpec באחד משדות ה-API הבאים:

אם יוצרים CustomJobמשאב, מציינים את WorkerPoolSpec ב-CustomJob.jobSpec.workerPoolSpecs.

אם אתם משתמשים ב-Google Cloud CLI, אתם יכולים להשתמש בדגל --worker-pool-spec או בדגל --config בפקודה gcloud ai custom-jobs create כדי לציין אפשרויות של מאגר עובדים.

מידע נוסף על יצירת CustomJob
אם יוצרים HyperparameterTuningJobמשאב, מציינים את WorkerPoolSpec ב-HyperparameterTuningJob.trialJobSpec.workerPoolSpecs.

אם אתם משתמשים ב-CLI של gcloud, אתם יכולים להשתמש בדגל --config בפקודה gcloud ai hpt-tuning-jobs create כדי לציין אפשרויות של מאגר עובדים.

מידע נוסף על יצירת HyperparameterTuningJob
אם יוצרים TrainingPipeline משאב בלי כוונון היפרפרמטרים, מציינים את WorkerPoolSpec ב-TrainingPipeline.trainingTaskInputs.workerPoolSpecs.

מידע נוסף על יצירת TrainingPipelineבהתאמה אישית
אם יוצרים TrainingPipeline עם כוונון של היפר-פרמטרים, צריך לציין את WorkerPoolSpec ב-TrainingPipeline.trainingTaskInputs.trialJobSpec.workerPoolSpecs.

אם אתם מבצעים אימון מבוזר, אתם יכולים להשתמש בהגדרות שונות לכל מאגר עובדים.

סוגי מכונות

ב-WorkerPoolSpec, צריך לציין אחד מסוגי המכונות הבאים בשדה machineSpec.machineType. כל רפליקה במאגר העובדים פועלת במכונה וירטואלית נפרדת עם סוג המכונה שצוין.

a4x-highgpu-4g^*
a4-highgpu-8g^*
a3-ultragpu-8g^*
a3-megagpu-8g^*
a3-highgpu-1g^*
a3-highgpu-2g^*
a3-highgpu-4g^*
a3-highgpu-8g^*
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^*
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
n4-standard-2
n4-standard-4
n4-standard-8
n4-standard-16
n4-standard-32
n4-standard-48
n4-standard-64
n4-standard-80
n4-highmem-2
n4-highmem-4
n4-highmem-8
n4-highmem-16
n4-highmem-32
n4-highmem-48
n4-highmem-64
n4-highmem-80
n4-highcpu-2
n4-highcpu-4
n4-highcpu-8
n4-highcpu-16
n4-highcpu-32
n4-highcpu-48
n4-highcpu-64
n4-highcpu-80
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
ct5lp-hightpu-1t^*
ct5lp-hightpu-4t^*
ct5lp-hightpu-8t^*
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^*
g4-standard-48^*
g4-standard-96^*
g4-standard-192^*
g4-standard-384^*
cloud-tpu^*

* צריך להשתמש בסוגי מכונות שמסומנים בכוכביות ברשימה הקודמת עם GPU או TPU מסוימים. אפשר לעיין בקטעים הבאים במדריך הזה.

כדי לקרוא על המפרטים הטכניים של כל סוג מכונה, אפשר לעיין במאמרי העזרה של Compute Engine בנושא סוגי מכונות. כדי לקבל מידע על העלות של שימוש בכל סוג של מכונה לאימון ללא שרתים, אפשר לקרוא את המאמר בנושא תמחור.

בדוגמאות הבאות אפשר לראות איפה מציינים את סוג המכונה כשיוצרים CustomJob:

המסוף

במסוף Google Cloud , אי אפשר ליצור CustomJob ישירות. עם זאת, אפשר ליצור TrainingPipeline שיוצר CustomJob. כשיוצרים TrainingPipeline במסוף Google Cloud , צריך לציין סוג מכונה לכל מאגר עובדים בשלב Compute and pricing (חישוב ומחירים), בשדה Machine type (סוג מכונה).

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

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaההוראות להגדרה במאמר מדריך למתחילים של Agent Platform באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של Agent Platform Java API.

כדי לבצע אימות ב-Agent Platform, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.


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_T4)
              .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

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsההוראות להגדרה במאמר מדריך למתחילים של Agent Platform באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של Agent Platform Node.js API.

/**
 * 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_T4',
            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

במאמר התקנת Vertex AI SDK ל-Python מוסבר איך להתקין או לעדכן את Vertex AI SDK ל-Python. מידע נוסף מופיע ב מאמרי העזרה של 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. אם משימת האימון מפסיקה להחזיר יומנים, כדאי לבחור סוג מכונה גדול יותר.

פלטפורמת Agent תומכת בסוגי ה-GPU הבאים לאימון ללא שרת:

‫NVIDIA_GB200⁺ (כולל GPUDirect-RDMA)
‫NVIDIA_B200^* (כולל GPUDirect-RDMA)
‫NVIDIA_H100_MEGA_80GB^* (כולל GPUDirect-TCPXO)
NVIDIA_H100_80GB
‫NVIDIA_H200_141GB^* (כולל GPUDirect-RDMA)
NVIDIA_A100_80GB
‫NVIDIA_TESLA_A100 (NVIDIA A100 40GB)
NVIDIA_TESLA_P4
NVIDIA_TESLA_P100
NVIDIA_TESLA_T4
NVIDIA_TESLA_V100
NVIDIA_L4
NVIDIA_RTX_PRO_6000

^* מומלץ להשיג קיבולת באמצעות מקום שמור משותף או מכונות וירטואליות מסוג Spot.

‫⁺ נדרש לקבל קיבולת באמצעות הזמנות משותפות.

מידע נוסף על המפרט הטכני של כל סוג של GPU זמין במאמר הקצר בנושא GPU לחישוב עומסי עבודה ב-Compute Engine. כדי לקבל מידע על העלות של כל סוג מכונה לאימון ללא שרתים, אפשר לקרוא את המאמר בנושא תמחור.

ב-WorkerPoolSpec, מציינים את סוג ה-GPU שרוצים להשתמש בו בשדה machineSpec.acceleratorType, ואת מספר יחידות ה-GPU שרוצים שכל מכונה וירטואלית במאגר העובדים תשתמש בהן בשדה machineSpec.acceleratorCount. עם זאת, הבחירות שלכם בשדות האלה צריכות לעמוד בהגבלות הבאות:

סוג ה-GPU שבוחרים צריך להיות זמין במיקום שבו מבצעים אימון ללא שרת. לא כל סוגי ה-GPU זמינים בכל האזורים. מידע נוסף על זמינות לפי אזור
אפשר להשתמש רק במספרים מסוימים של יחידות GPU בהגדרה. לדוגמה, אפשר להשתמש ב-2 או ב-4 יחידות GPU‏ NVIDIA_TESLA_T4 במכונה וירטואלית, אבל לא ב-3. כדי לראות אילו ערכים של acceleratorCount תקפים לכל סוג של GPU, אפשר לעיין בטבלת התאימות הבאה.
צריך לוודא שהגדרת ה-GPU מספקת מספיק מעבדים וירטואליים וזיכרון לסוג המכונה שבה משתמשים. לדוגמה, אם משתמשים בסוג המכונה n1-standard-32 במאגר העובדים, לכל מכונה וירטואלית יש 32 מעבדים וירטואליים וזיכרון בנפח 120GB. מכיוון שכל GPU מסוג NVIDIA_TESLA_V100 יכול לספק עד 12 מעבדים וירטואליים וזיכרון בנפח 76GB, צריך להשתמש ב-4 יחידות GPU לפחות לכל מכונה וירטואלית מסוג n1-standard-32 כדי לתמוך בדרישות שלה. (2 יחידות GPU לא מספקות מספיק משאבים, ואי אפשר לציין 3 יחידות GPU).

בטבלת התאימות הבאה מפורטות הדרישות האלה.

חשוב לשים לב למגבלה הנוספת הבאה על שימוש ב-GPU לאימון מותאם אישית, שמבדילה בין שימוש ב-GPU לבין שימוש ב-GPU עם Compute Engine:
- הגדרה עם 4 יחידות GPU‏ NVIDIA_TESLA_P100 מספקת עד 64 מעבדי CPU וירטואליים ועד 208GB של זיכרון בכל האזורים והאזורים.
לגבי משימות שמשתמשות ב-Dynamic Workload Scheduler או ב-Spot VMs, מעדכנים את השדה scheduling.strategy של CustomJob לאסטרטגיה שנבחרה.

בטבלת התאימות הבאה מפורטים הערכים התקינים של machineSpec.acceleratorCount בהתאם לבחירות שלכם לגבי machineSpec.machineType ו-machineSpec.acceleratorType:

מספרים תקינים של יחידות GPU לכל סוג מכונה
סוג המכונה	`NVIDIA_H100_MEGA_80GB`	`NVIDIA_H100_80GB`	`NVIDIA_A100_80GB`	`NVIDIA_TESLA_A100`	`NVIDIA_TESLA_P4`	`NVIDIA_TESLA_P100`	`NVIDIA_TESLA_T4`	`NVIDIA_TESLA_V100`	`NVIDIA_L4`	`NVIDIA_H200_141GB`	`NVIDIA_B200`	`NVIDIA_GB200`	`NVIDIA_RTX_PRO_6000`
`a3-megagpu-8g`	8
`a3-highgpu-1g`		1
`a3-highgpu-2g`		2
`a3-highgpu-4g`		4
`a3-highgpu-8g`		8
`a3-ultragpu-8g`										8
`a4-highgpu-8g`											8
`a4x-highgpu-4g`												4
`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	1, 2, 4	1, 2, 4	‫1, 2, 4, 8
`n1-standard-8`					1, 2, 4	1, 2, 4	1, 2, 4	‫1, 2, 4, 8
`n1-standard-16`					1, 2, 4	1, 2, 4	1, 2, 4	‫2, 4, 8
`n1-standard-32`					‫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	1, 2, 4	1, 2, 4	‫1, 2, 4, 8
`n1-highmem-4`					1, 2, 4	1, 2, 4	1, 2, 4	‫1, 2, 4, 8
`n1-highmem-8`					1, 2, 4	1, 2, 4	1, 2, 4	‫1, 2, 4, 8
`n1-highmem-16`					1, 2, 4	1, 2, 4	1, 2, 4	‫2, 4, 8
`n1-highmem-32`					‫2, 4	‫2, 4	‫2, 4	‫4, 8
`n1-highmem-64`					4		4	8
`n1-highmem-96`					4		4	8
`n1-highcpu-16`					1, 2, 4	1, 2, 4	1, 2, 4	‫2, 4, 8
`n1-highcpu-32`					‫2, 4	‫2, 4	‫2, 4	‫4, 8
`n1-highcpu-64`					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
`g4-standard-48`													1
`g4-standard-96`													2
`g4-standard-192`													4
`g4-standard-384`													8

בדוגמאות הבאות אפשר לראות איפה אפשר לציין יחידות GPU כשיוצרים CustomJob:

המסוף

במסוף Google Cloud , אי אפשר ליצור CustomJob ישירות. עם זאת, אפשר ליצור TrainingPipeline שיוצר CustomJob. כשיוצרים TrainingPipeline במסוף Google Cloud , אפשר לציין מעבדי GPU לכל מאגר עובדים בשלב Compute and pricing (חישוב וחיוב). קודם מציינים Machine type (סוג מכונה). אחר כך אפשר לציין פרטים של GPU בשדות Accelerator type (סוג מאיץ) ו-Accelerator count (מספר מאיצים).

gcloud

כדי לציין יחידות GPU באמצעות הכלי Google Cloud CLI, צריך להשתמש בקובץ 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

/**
 * 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_T4',
            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

במאמר התקנת Vertex AI SDK ל-Python מוסבר איך להתקין או לעדכן את Vertex AI SDK ל-Python. מידע נוסף מופיע ב מאמרי העזרה של 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.

GPUDirect Networking

ב-Vertex Training, חלק מהמכונות מסדרות H100,‏ H200,‏ B200 ו-GB200 מוגדרות מראש עם חבילת GPUDirect networking. ‏ GPUDirect יכול להגדיל את מהירות הרשת בין מעבדים גרפיים עד פי 2 בהשוואה למעבדים גרפיים ללא GPUDirect.

הטכנולוגיה הזו עושה את זה על ידי צמצום התקורה שנדרשת להעברת מטענים של מנות בין מעבדי GPU, וכך משפרת באופן משמעותי את קצב העברת הנתונים בהיקף גדול.

GPUDirect-TCPXO

סוג המכונה a3-megagpu-8g כולל:

‫8 GPUs מסוג NVIDIA H100 לכל מכונה
רוחב פס של עד ‎200 Gbps בכרטיס ה-NIC הראשי
‫8 כרטיסי NIC משניים, כל אחד עם תמיכה של עד ‎200 Gbps להעברת נתונים של GPU
‫GPUDirect-TCPXO, שמשפר עוד יותר את התקשורת בין ה-GPU לבין המכונה הווירטואלית

מעבדי GPU עם GPUDirect מצוידים במיוחד לאימון מבוזר של מודלים גדולים.

GPUDirect-RDMA

לסוגי המכונות a4x-highgpu-4g יש:

מעבדי GPU‏ 4 GB200 לכל מכונה
שני כרטיסי רשת של המארח שמספקים רוחב פס של ‎400 Gbps
‫6 כרטיסי רשת שמציעים עד 2,400Gbps להעברת נתונים של GPU
‫GPUDirect-RDMA, שמאפשר ביצועים גבוהים יותר ברשת לתקשורת בין יחידות GPU עבור עומסי עבודה של אימון למידת מכונה בקנה מידה גדול באמצעות RoCE ‏(RDMA over Converged Ethernet)

לסוגי המכונות a3-ultragpu-8g ו-a4-highgpu-8g יש:

‫8 GPUs מסוג NVIDIA H200/B200 לכל מכונה
שני כרטיסי רשת של המארח שמספקים רוחב פס של ‎400 Gbps
‫8 כרטיסי רשת שמציעים עד 3,200Gbps להעברת נתונים ב-GPU
‫GPUDirect-RDMA, שמאפשר ביצועים גבוהים יותר של רשת לתקשורת GPU עבור עומסי עבודה של אימון ML בקנה מידה גדול באמצעות RoCE ‏(RDMA over Converged Ethernet)

TPUs

כדי להשתמש ב-Tensor Processing Units (TPUs) לאימון בהתאמה אישית ב-Agent Platform, אפשר להגדיר מאגר עובדים לשימוש ב-TPU VM.

כשמשתמשים במכונה וירטואלית של TPU בפלטפורמת Agent, צריך להשתמש רק במאגר עובדים אחד לאימון בהתאמה אישית, ולהגדיר את מאגר העובדים הזה כך שישתמש רק בעותק אחד.

‫TPU v2 ו-v3

כדי להשתמש במכונות וירטואליות של TPU v2 או v3 במאגר העובדים, צריך להשתמש באחת מההגדרות הבאות:

כדי להגדיר TPU VM עם TPU v2, צריך לציין את השדות הבאים ב-WorkerPoolSpec:
- מגדירים את machineSpec.machineType להיות cloud-tpu.
- מגדירים את machineSpec.acceleratorType להיות TPU_V2.
- מגדירים את machineSpec.acceleratorCount ל-8 עבור TPU יחיד או ל-32 or multiple of 32 עבור TPU Pods.
- מגדירים את replicaCount להיות 1.
כדי להגדיר מכונת TPU VM עם TPU v3, צריך לציין את השדות הבאים ב-WorkerPoolSpec:
- מגדירים את machineSpec.machineType להיות cloud-tpu.
- מגדירים את machineSpec.acceleratorType להיות TPU_V3.
- מגדירים את machineSpec.acceleratorCount ל-8 עבור TPU יחיד או ל-32+ עבור TPU Pods.
- מגדירים את replicaCount להיות 1.

מידע על הזמינות האזורית של TPU זמין במאמר שימוש במאיצים.

TPU v5e

‫TPU v5e דורש JAX 0.4.6 ומעלה, TensorFlow 2.15 ומעלה או PyTorch 2.1 ומעלה. כדי להגדיר TPU VM עם TPU v5e, צריך לציין את השדות הבאים ב-WorkerPoolSpec:

מגדירים את machineSpec.machineType לערך ct5lp-hightpu-1t, ‏ct5lp-hightpu-4t או ct5lp-hightpu-8t.
מגדירים את machineSpec.tpuTopology לטופולוגיה נתמכת עבור סוג המכונה. פרטים נוספים מופיעים בטבלה הבאה.
מגדירים את replicaCount להיות 1.

בטבלה הבאה מוצגים סוגי המכונות והטופולוגיות של TPU v5e שנתמכים לאימון מותאם אישית:

סוג מכונה	טופולוגיה	מספר שבבי ה-TPU	מספר המכונות הווירטואליות	תרחיש שימוש מומלץ
`ct5lp-hightpu-1t`	‫1x1	1	1	אימון בקנה מידה קטן עד בינוני
`ct5lp-hightpu-4t`	‫2 על 2	4	1	אימון בקנה מידה קטן עד בינוני
`ct5lp-hightpu-8t`	‫2x4	8	1	אימון בקנה מידה קטן עד בינוני
`ct5lp-hightpu-4t`	‫2x4	8	2	אימון בקנה מידה קטן עד בינוני
`ct5lp-hightpu-4t`	4x4	16	4	אימון בקנה מידה גדול
`ct5lp-hightpu-4t`	4x8	32	8	אימון בקנה מידה גדול
`ct5lp-hightpu-4t`	8x8	64	16	אימון בקנה מידה גדול
`ct5lp-hightpu-4t`	‫8x16	128	32	אימון בקנה מידה גדול
`ct5lp-hightpu-4t`	‫16x16	256	64	אימון בקנה מידה גדול

משימות אימון מותאמות אישית שפועלות במכונות וירטואליות של TPU v5e מותאמות לתפוקה ולזמינות. מידע נוסף זמין במאמר בנושא סוגי מאיצי אימון v5e.

מידע על הזמינות האזורית של TPU זמין במאמר שימוש במאיצים. מידע נוסף על TPU v5e זמין במאמר בנושא אימון ב-Cloud TPU v5e.

השוואה בין סוגי מכונות:

סוג מכונה	ct5lp-hightpu-1t	ct5lp-hightpu-4t	ct5lp-hightpu-8t
מספר הצ'יפים מסוג v5e	1	4	8
מספר המעבדים הווירטואליים	24	112	224
‫RAM ‏ (GB)	48	192	384
מספר צמתי NUMA	1	1	2
הסבירות להקדמת השידור	גבוהה	בינוני	נמוכה

TPU v6e

‫TPU v6e דורש Python 3.10 ומעלה, JAX 0.4.37 ומעלה, PyTorch 2.1 ומעלה עם PJRT כזמן הריצה שמוגדר כברירת מחדל, או TensorFlow עם גרסת זמן הריצה tf-nightly 2.18 ומעלה בלבד. כדי להגדיר מכונת TPU וירטואלית עם TPU v6e, צריך לציין את השדות הבאים ב-WorkerPoolSpec:

מגדירים את machineSpec.machineType להיות ct6e.
מגדירים את machineSpec.tpuTopology לטופולוגיה נתמכת עבור סוג המכונה. פרטים נוספים מופיעים בטבלה הבאה.
מגדירים את replicaCount להיות 1.

בטבלה הבאה מוצגים סוגי המכונות והטופולוגיות של TPU v6e שנתמכים לאימון מותאם אישית:

סוג מכונה	טופולוגיה	מספר שבבי ה-TPU	מספר המכונות הווירטואליות	תרחיש שימוש מומלץ
`ct6e-standard-1t`	‫1x1	1	1	אימון בקנה מידה קטן עד בינוני
`ct6e-standard-8t`	‫2x4	8	1	אימון בקנה מידה קטן עד בינוני
`ct6e-standard-4t`	‫2 על 2	4	1	אימון בקנה מידה קטן עד בינוני
`ct6e-standard-4t`	‫2x4	8	2	אימון בקנה מידה קטן עד בינוני
`ct6e-standard-4t`	4x4	16	4	אימון בקנה מידה גדול
`ct6e-standard-4t`	4x8	32	8	אימון בקנה מידה גדול
`ct6e-standard-4t`	8x8	64	16	אימון בקנה מידה גדול
`ct6e-standard-4t`	‫8x16	128	32	אימון בקנה מידה גדול
`ct6e-standard-4t`	‫16x16	256	64	אימון בקנה מידה גדול

מידע על הזמינות האזורית של TPU זמין במאמר שימוש במאיצים. מידע נוסף על TPU v6e זמין במאמר בנושא אימון TPU v6e ב-Cloud.

השוואה בין סוגי מכונות:

סוג מכונה	ct6e-standard-1t	ct6e-standard-4t	ct6e-standard-8t
מספר הצ'יפים מסוג v6e	1	4	8
מספר המעבדים הווירטואליים	44	180	180
‫RAM ‏ (GB)	48	720	1440
מספר צמתי NUMA	2	1	2
הסבירות להקדמת השידור	גבוהה	בינוני	נמוכה

TPU 7x

‫TPU7x מחייב Python 3.12 ואילך.

לצורך בדיקות פונקציונליות והעברת עומסי עבודה, מומלץ להשתמש בשילוב היציב הבא:

‫JAX + JAX Lib: ‏ jax-0.8.1.dev20251104, ‏ jaxlib-0.8.1.dev2025104
‫libtpu יציב: libtpu-0.0.27

כדי להגדיר TPU VM עם TPU 7x, מציינים את השדות הבאים ב-WorkerPoolSpec:

מגדירים את machineSpec.machineType להיות tpu7x-standard-4t.
מגדירים את machineSpec.tpuTopology לטופולוגיה נתמכת עבור סוג המכונה. פרטים נוספים מופיעים בטבלה הבאה.
מגדירים את replicaCount להיות 1.

בטבלה הבאה מפורטות הטופולוגיות של TPU 7x שנתמכות לאימון בהתאמה אישית. כל הטופולוגיות משתמשות בסוג המכונה tpu7x-standard-4t.

טופולוגיה	מספר שבבי ה-TPU	מספר המכונות הווירטואליות	היקף
2x2x1	4	1	מארח יחיד
2x2x2	8	2	כמה מארחים
‫2x2x4	16	4	כמה מארחים
2x4x4	32	8	כמה מארחים
4x4x4	64	16	כמה מארחים
4x4x8	128	32	כמה מארחים
4x8x8	256	64	כמה מארחים
8x8x8	512	128	כמה מארחים
8x8x16	1024	256	כמה מארחים

מידע על הזמינות האזורית של TPU זמין במאמר שימוש במאיצים. מידע נוסף על TPU7x זמין במאמר אימון ב-Cloud TPU7x.

דוגמה ל-`CustomJob` שבה מצוינת מכונת TPU וירטואלית

בדוגמה הבאה מודגש איך מציינים TPU VM כשיוצרים CustomJob:

gcloud

כדי לציין מכונת TPU וירטואלית באמצעות כלי ה-CLI של gcloud, צריך להשתמש בקובץ config.yaml. כדי לראות דוגמה, בוחרים באחת מהכרטיסיות הבאות:

TPU v2/v3

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

TPU v5e

workerPoolSpecs:
  machineSpec:
    machineType: ct5lp-hightpu-4t
    tpuTopology: 4x4
  replicaCount: 1
  containerSpec:
    imageUri: CUSTOM_CONTAINER_IMAGE_URI

לאחר מכן מריצים פקודה כמו הבאה:

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

Python

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Pythonההוראות להגדרה במאמר מדריך למתחילים של Agent Platform באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של Agent Platform Python API.

כדי לציין מכונת TPU וירטואלית באמצעות Agent Platform SDK ל-Python, אפשר להיעזר בדוגמה הבאה:

from google.cloud.aiplatform import aiplatform

job = aiplatform.CustomContainerTrainingJob(
    display_name='DISPLAY_NAME',
    location='us-west1',
    project='PROJECT_ID',
    staging_bucket="gs://CLOUD_STORAGE_URI",
    container_uri='CONTAINER_URI')

job.run(machine_type='ct5lp-hightpu-4t', tpu_topology='2x2')

מידע נוסף על יצירת משימות אימון בהתאמה אישית זמין במאמר בנושא יצירת משימות אימון בהתאמה אישית.

אפשרויות של דיסק אתחול

אפשר גם להתאים אישית את דיסקי האתחול של מכונות ה-VM לאימון. כל המכונות הווירטואליות במאגר העובדים משתמשות באותו סוג ובאותו גודל של דיסק אתחול.

כדי להתאים אישית את סוג דיסק האתחול שבו משתמשת כל מכונת VM לאימון, מציינים את השדה diskSpec.bootDiskType ב-WorkerPoolSpec.

אפשר להגדיר בשדה הזה את אחת מהאפשרויות הבאות:
- ‫pd-standard כדי להשתמש בדיסק מתמיד סטנדרטי שמגובה על ידי כונן קשיח רגיל
- ‫pd-ssd כדי להשתמש בדיסק מתמיד שמבוסס על SSD שמגובה על ידי כונן SSD
- ‫hyperdisk-balanced כדי לקבל יותר פעולות קלט/פלט בשנייה (IOPS) וקצב העברת נתונים (throughput).
ערך ברירת המחדל הוא pd-ssd (hyperdisk-balanced הוא ערך ברירת המחדל של a3-ultragpu-8g ושל a4-highgpu-8g).

שימוש ב-pd-ssd או ב-hyperdisk-balanced עשוי לשפר את הביצועים אם קוד ההדרכה קורא וכותב לדיסק. מידע על סוגי דיסקים אפשר גם לעיין במכונות שנתמכות ב-Hyperdisk.
כדי לשנות את הגודל (ב-GB) של דיסק האתחול שכל מכונת VM לאימון משתמשת בו, מציינים את diskSpec.bootDiskSizeGbהשדה ב-WorkerPoolSpec.

אפשר להגדיר בשדה הזה מספר שלם בין 100 ל-64,000, כולל. ערך ברירת המחדל הוא 100.

כדאי להגדיל את הגודל של דיסק האתחול אם קוד האימון כותב הרבה נתונים זמניים לדיסק. חשוב לדעת שכל הנתונים שכותבים לדיסק האתחול הם זמניים, ואי אפשר לאחזר אותם אחרי שהאימון מסתיים.

שינוי הסוג והגודל של דיסקי האתחול משפיע על התמחור של אימון מותאם אישית.

בדוגמאות הבאות מודגש איפה אפשר לציין אפשרויות של דיסק אתחול כשיוצרים CustomJob:

המסוף

במסוף Google Cloud , אי אפשר ליצור CustomJob ישירות. עם זאת, אפשר ליצור TrainingPipeline שיוצר CustomJob. כשיוצרים TrainingPipeline במסוף Google Cloud , אפשר לציין אפשרויות של דיסק אתחול לכל מאגר עובדים בשלב Compute and pricing, ברשימה הנפתחת Disk type ובשדה Disk size (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.

המאמרים הבאים

כך יוצרים משאב מתמשך כדי להריץ משימות אימון בהתאמה אישית.
כך יוצריםCustomJob אימון בהתאמה אישית.

הגדרת משאבי מחשוב לאימון ללא שרת (serverless) ב-Gemini Enterprise Agent Platform קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

ניהול עלויות וזמינות

איפה מציינים משאבי מחשוב

סוגי מכונות

המסוף

gcloud

Java

Node.js

Python

יחידות GPU

המסוף

gcloud

config.yaml

Node.js

Python

GPUDirect Networking

GPUDirect-TCPXO

GPUDirect-RDMA

TPUs

‫TPU v2 ו-v3

TPU v5e

TPU v6e

TPU 7x

דוגמה ל-CustomJob שבה מצוינת מכונת TPU וירטואלית

gcloud

TPU v2/v3

TPU v5e

Python

אפשרויות של דיסק אתחול

המסוף

gcloud

config.yaml

המאמרים הבאים

הגדרת משאבי מחשוב לאימון ללא שרת (serverless) ב-Gemini Enterprise Agent Platform

`config.yaml`

דוגמה ל-`CustomJob` שבה מצוינת מכונת TPU וירטואלית

`config.yaml`