Configurare le risorse di calcolo per l'addestramento personalizzato

Quando esegui l'addestramento personalizzato, il codice di addestramento viene eseguito su una o più istanze di macchine virtuali (VM). Puoi configurare i tipi di VM da utilizzare per l'addestramento: l'utilizzo di VM con più risorse di calcolo può accelerare l'addestramento e consentirti di lavorare con set di dati più grandi, ma può anche comportare maggiori costi di addestramento.

In alcuni casi, puoi utilizzare le GPU anche per accelerare l'addestramento. Le GPU comportano costi aggiuntivi.

Puoi anche personalizzare facoltativamente il tipo e le dimensioni dei dischi di avvio delle VM di training.

Questo documento descrive le diverse risorse di calcolo che puoi utilizzare per l'addestramento personalizzato e come configurarle.

Gestire costi e disponibilità

Per aiutarti a gestire i costi o garantire la disponibilità delle risorse VM, Vertex AI fornisce quanto segue:

• Per assicurarti che le risorse VM siano disponibili quando i job di addestramento ne hanno bisogno, puoi utilizzare le prenotazioni di Compute Engine. Le prenotazioni offrono un alto livello di garanzia per l'ottenimento di capacità per le risorse Compute Engine. Per saperne di più, consulta la sezione Utilizzare le prenotazioni con l'addestramento.

• Per ridurre il costo di esecuzione dei job di addestramento, puoi utilizzare le VM spot. Le VM spot sono istanze di macchina virtuale (VM) che rappresentano la capacità in eccesso di Compute Engine. Le VM spot beneficiano di sconti significativi, ma Compute Engine potrebbe arrestarle o eliminarle preventivamente per recuperare capacità in qualsiasi momento. Per ulteriori informazioni, consulta Utilizzare le VM spot con l'addestramento.

• Per i job di addestramento personalizzato che richiedono risorse GPU, Dynamic Workload Scheduler ti consente di pianificare i job in base alla disponibilità delle risorse GPU richieste. Per saperne di più, consulta Pianificare job di addestramento in base alla disponibilità delle risorse.

Dove specificare le risorse di calcolo

Specifica i dettagli di configurazione all'interno di un WorkerPoolSpec. A seconda di come esegui l'addestramento personalizzato, inserisci questo WorkerPoolSpec in uno dei seguenti campi API:

• Se stai creando una risorsa CustomJob, specifica WorkerPoolSpec in CustomJob.jobSpec.workerPoolSpecs.

  Se utilizzi Google Cloud CLI, puoi utilizzare il flag --worker-pool-spec o il flag --config nel comando gcloud ai custom-jobs create per specificare le opzioni del pool di worker.

  Scopri di più sulla creazione di un CustomJob.

• Se stai creando una HyperparameterTuningJob risorsa, specifica WorkerPoolSpec in HyperparameterTuningJob.trialJobSpec.workerPoolSpecs.

  Se utilizzi gcloud CLI, puoi utilizzare il flag --config nel comando gcloud ai hpt-tuning-jobs create per specificare le opzioni del worker pool.

  Scopri di più sulla creazione di un HyperparameterTuningJob.

• Se stai creando una TrainingPipeline risorsa senza ottimizzazione degli iperparametri, specifica WorkerPoolSpec in TrainingPipeline.trainingTaskInputs.workerPoolSpecs.

  Scopri di più sulla creazione di un TrainingPipeline personalizzato.

• Se stai creando un TrainingPipeline con l'ottimizzazione degli iperparametri, specifica WorkerPoolSpec in TrainingPipeline.trainingTaskInputs.trialJobSpec.workerPoolSpecs.

Se esegui l'addestramento distribuito, puoi utilizzare impostazioni diverse per ogni pool di worker.

Tipi di macchine

Nel tuo WorkerPoolSpec, devi specificare uno dei seguenti tipi di macchine nel campo machineSpec.machineType. Ogni replica nel pool di worker viene eseguita su una VM separata con il tipo di macchina specificato.

* I tipi di macchine contrassegnati con asterischi nell'elenco precedente devono essere utilizzati con determinate GPU o TPU. Consulta le sezioni seguenti di questa guida.

Per scoprire le specifiche tecniche di ogni tipo di macchina, leggi la documentazione di Compute Engine sui tipi di macchine. Per scoprire il costo dell'utilizzo di ogni tipo di macchina per l'addestramento personalizzato, consulta la sezione Prezzi.

Gli esempi seguenti mostrano dove specificare un tipo di macchina quando crei un CustomJob:

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

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

/**
 * 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();

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)

Per maggiori informazioni, leggi la guida alla creazione di un CustomJob.

GPU

Se hai scritto il codice di addestramento per utilizzare le GPU, puoi configurare il pool di worker in modo che utilizzi una o più GPU su ogni VM. Per utilizzare le GPU, devi utilizzare un tipo di macchina A2, N1 o G2. Inoltre, l'utilizzo di tipi di macchine più piccoli come n1-highmem-2 con GPU potrebbe causare errori di logging per alcuni carichi di lavoro a causa di vincoli della CPU. Se il job di addestramento smette di restituire log, valuta la possibilità di selezionare un tipo di macchina più grande.

Vertex AI supporta i seguenti tipi di GPU per l'addestramento personalizzato:

• NVIDIA_B200^* (include GPUDirect-RDMA)
• NVIDIA_H100_MEGA_80GB^* (include GPUDirect-TCPXO)
• NVIDIA_H100_80GB
• NVIDIA_H200_141GB^* (include GPUDirect-RDMA)
• NVIDIA_A100_80GB
• NVIDIA_TESLA_A100 (NVIDIA A100 da 40 GB)
• NVIDIA_TESLA_P4
• NVIDIA_TESLA_P100
• NVIDIA_TESLA_T4
• NVIDIA_TESLA_V100
• NVIDIA_L4

Per saperne di più sulle specifiche tecniche di ogni tipo di GPU, leggi la breve documentazione di Compute Engine sulle GPU per i carichi di lavoro di calcolo. Per scoprire il costo dell'utilizzo di ogni tipo di macchina per l'addestramento personalizzato, consulta la sezione Prezzi.

In WorkerPoolSpec, specifica il tipo di GPU che vuoi utilizzare nel campo machineSpec.acceleratorType e il numero di GPU che vuoi che ogni VM nel pool di worker utilizzi nel campo machineSpec.acceleratorCount. Tuttavia, le tue scelte per questi campi devono soddisfare le seguenti limitazioni:

• Il tipo di GPU scelto deve essere disponibile nella località in cui esegui l'addestramento personalizzato. Non tutti i tipi di GPU sono disponibili in tutte le regioni. Scopri di più sulla disponibilità a livello regionale.

• Puoi utilizzare solo un determinato numero di GPU nella configurazione. Ad esempio, puoi utilizzare 2 o 4 GPU NVIDIA_TESLA_T4 su una VM, ma non 3. Per vedere quali valori di acceleratorCount sono validi per ogni tipo di GPU, consulta la tabella di compatibilità seguente.

• Devi assicurarti che la configurazione della GPU fornisca CPU virtuali e memoria sufficienti al tipo di macchina con cui la utilizzi. Ad esempio, se utilizzi il tipo di macchina n1-standard-32 nel pool di worker, ogni VM ha 32 CPU virtuali e 120 GB di memoria. Poiché ogni GPU NVIDIA_TESLA_V100 può fornire fino a 12 CPU virtuali e 76 GB di memoria, devi utilizzare almeno 4 GPU per ogni VM n1-standard-32 per supportare i suoi requisiti. (2 GPU forniscono risorse insufficienti e non puoi specificare 3 GPU.)

  La seguente tabella di compatibilità tiene conto di questo requisito.

  Tieni presente la seguente limitazione aggiuntiva sull'utilizzo delle GPU per l'addestramento personalizzato che differisce dall'utilizzo delle GPU con Compute Engine:

  • Una configurazione con 4 GPU NVIDIA_TESLA_P100 fornisce solo fino a 64 CPU virtuali e fino a 208 GB di memoria in tutte le regioni e le zone.

• Per i job che utilizzano Dynamic Workload Scheduler o VM spot, aggiorna il campo scheduling.strategy di CustomJob alla strategia scelta.

La seguente tabella di compatibilità elenca i valori validi per machineSpec.acceleratorCount a seconda delle tue scelte per machineSpec.machineType e machineSpec.acceleratorType:

^* Il tipo di macchina specificato è disponibile solo quando utilizzi Dynamic Workload Scheduler o VM spot.

Gli esempi seguenti mostrano dove puoi specificare le GPU quando crei un CustomJob:

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

/**
 * 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();

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)

Per maggiori informazioni, leggi la guida alla creazione di un CustomJob.

GPUDirect Networking

Su Vertex Training, alcune macchine delle serie H100, H200 e B200 sono preconfigurate con lo stack di rete GPUDirect. GPUDirect può aumentare la velocità di rete tra le GPU fino a due volte rispetto alle GPU senza GPUDirect.

GPUDirect lo fa riducendo l'overhead necessario per trasferire i payload dei pacchetti tra le GPU, migliorando significativamente il throughput su larga scala.

GPUDirect-TCPXO

Il tipo di macchina a3-megagpu-8g ha:

• 8 GPU NVIDIA H100 per macchina
• Larghezza di banda fino a 200 Gbps sulla NIC principale
• 8 NIC secondarie che supportano fino a 200 Gbps per il trasferimento di dati della GPU
• GPUDirect-TCPXO, che migliora ulteriormente la comunicazione tra GPU e VM

Le GPU con GPUDirect sono particolarmente adatte all'addestramento distribuito di modelli di grandi dimensioni.

GPUDirect-RDMA

I tipi di macchina a3-ultragpu-8g e a4-highgpu-8g hanno:

• 8 GPU NVIDIA H200/B200 per macchina
• 2 NIC host che forniscono una larghezza di banda di 400 Gbps
• 8 NIC che offrono fino a 3200 Gbps per il trasferimento di dati della GPU
• GPUDirect-RDMA, che consente prestazioni di rete più elevate per la comunicazione GPU per workload di addestramento ML su larga scala tramite RoCE (RDMA su Converged Ethernet)

TPU

Per utilizzare le Tensor Processing Unit (TPU) per l'addestramento personalizzato su Vertex AI, puoi configurare un pool di worker in modo che utilizzi una VM TPU.

Quando utilizzi una VM TPU in Vertex AI, devi utilizzare un solo pool di worker per l'addestramento personalizzato e devi configurare questo pool di worker in modo che utilizzi una sola replica.

TPU v2 e v3

Per utilizzare le VM TPU v2 o v3 nel pool di worker, devi utilizzare una delle seguenti configurazioni:

• Per configurare una VM TPU con TPU v2, specifica i seguenti campi in WorkerPoolSpec:

  • Imposta machineSpec.machineType su cloud-tpu.
  • Imposta machineSpec.acceleratorType su TPU_V2.
  • Imposta machineSpec.acceleratorCount su 8 per una singola TPU o su 32 or multiple of 32 per i pod di TPU.
  • Imposta replicaCount su 1.

• Per configurare una VM TPU con TPU v3, specifica i seguenti campi in WorkerPoolSpec:

  • Imposta machineSpec.machineType su cloud-tpu.
  • Imposta machineSpec.acceleratorType su TPU_V3.
  • Imposta machineSpec.acceleratorCount su 8 per una singola TPU o su 32+ per i pod di TPU.
  • Imposta replicaCount su 1.

Per informazioni sulla disponibilità regionale delle TPU, consulta Utilizzo degli acceleratori.

TPU v5e

TPU v5e richiede JAX 0.4.6+, TensorFlow 2.15+ o PyTorch 2.1+. Per configurare una VM TPU con TPU v5e, specifica i seguenti campi in WorkerPoolSpec:

• Imposta machineSpec.machineType su ct5lp-hightpu-1t, ct5lp-hightpu-4t o ct5lp-hightpu-8t.
• Imposta machineSpec.tpuTopology su una topologia supportata per il tipo di macchina. Per maggiori dettagli consulta la tabella seguente.
• Imposta replicaCount su 1.

La seguente tabella mostra i tipi di macchine TPU v5e e le topologie supportate per l'addestramento personalizzato:

I job di addestramento personalizzato eseguiti su VM TPU v5e sono ottimizzati per il throughput e la disponibilità. Per saperne di più, consulta Tipi di acceleratori di addestramento v5e.

Per informazioni sulla disponibilità regionale delle TPU, consulta Utilizzo degli acceleratori. Per saperne di più su TPU v5e, consulta la sezione Addestramento per Cloud TPU v5e.

Confronto tra tipi di macchine:

TPU v6e

TPU v6e richiede Python 3.10+, JAX 0.4.37+, PyTorch 2.1+ che utilizza PJRT come runtime predefinito o TensorFlow che utilizza solo la versione 2.18+ del runtime tf-nightly. Per configurare una VM TPU con TPU v6e, specifica i seguenti campi in WorkerPoolSpec:

• Imposta machineSpec.machineType su ct6e.
• Imposta machineSpec.tpuTopology su una topologia supportata per il tipo di macchina. Per maggiori dettagli consulta la tabella seguente.
• Imposta replicaCount su 1.

La seguente tabella mostra i tipi di macchine TPU v6e e le topologie supportate per l'addestramento personalizzato:

Per informazioni sulla disponibilità regionale delle TPU, consulta Utilizzo degli acceleratori. Per saperne di più su TPU v6e, consulta la sezione Addestramento di Cloud TPU v6e.

Confronto tra tipi di macchine:

Esempio CustomJob che specifica una VM TPU

Il seguente esempio mostra come specificare una VM TPU quando crei un CustomJob:

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

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

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

Per ulteriori informazioni sulla creazione di un job di addestramento personalizzato, vedi Creare job di addestramento personalizzati.

Opzioni del disco di avvio

Se vuoi, puoi personalizzare i dischi di avvio delle VM di addestramento. Tutte le VM in un worker pool utilizzano lo stesso tipo e le stesse dimensioni del disco di avvio.

• Per personalizzare il tipo di disco di avvio utilizzato da ogni VM di addestramento,specifica il campo diskSpec.bootDiskType nel tuo WorkerPoolSpec.

  Puoi impostare questo campo su uno dei seguenti valori:

  • pd-standard per utilizzare un disco permanente standard supportato da un hard disk standard
  • pd-ssd per utilizzare un disco permanente SSD supportato da un'unità a stato solido
  • hyperdisk-balanced per IOPS e throughput più elevati.

  Il valore predefinito è pd-ssd (hyperdisk-balanced è il valore predefinito per a3-ultragpu-8g e a4-highgpu-8g).

  L'utilizzo di pd-ssd o hyperdisk-balanced potrebbe migliorare il rendimento se il codice di addestramento legge e scrive sul disco. Scopri di più sui tipi di disco. Vedi anche Macchine supportate da Hyperdisk.

• Per personalizzare le dimensioni (in GB) del disco di avvio utilizzato da ogni VM di addestramento,specifica il campo diskSpec.bootDiskSizeGb nel file WorkerPoolSpec.

  Puoi impostare questo campo su un numero intero compreso tra 100 e 64.000 inclusi. Il valore predefinito è 100.

  Potresti voler aumentare la dimensione del disco di avvio se il codice di addestramento scrive molti dati temporanei sul disco. Tieni presente che tutti i dati scritti sul disco di avvio sono temporanei e non possono essere recuperati al termine dell'addestramento.

La modifica del tipo e delle dimensioni dei dischi di avvio influisce sui prezzi dell'addestramento personalizzato.

I seguenti esempi mostrano dove puoi specificare le opzioni del disco di avvio quando crei un CustomJob:

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

Per maggiori informazioni, leggi la guida alla creazione di un CustomJob.

Passaggi successivi

• Scopri come creare una risorsa permanente per eseguire job di addestramento personalizzato.
• Scopri come eseguire l'addestramento personalizzato creando un CustomJob.