Crea job di addestramento personalizzati

I job di addestramento personalizzato (CustomJob risorse nell'API Vertex AI) sono la base per eseguire il codice di addestramento personalizzato di machine learning (ML) in Vertex AI.

Prima di inviare un job

Prima di creare un CustomJob in Vertex AI, devi creare un'applicazione di addestramento Python o un'immagine container personalizzata per definire il codice di addestramento e le dipendenze che vuoi eseguire su Vertex AI.

Ti consigliamo di utilizzare la funzionalità di autopackaging di Google Cloud CLI, descritto in una sezione successiva di questa guida, per creare un Docker dell'immagine container dal codice sulla tua macchina locale, esegui il push di questa immagine container Artifact Registry e creare un CustomJob, il tutto con un unico comando.

In caso contrario, devi creare manualmente un'applicazione di addestramento Python o un'immagine container personalizzata.

Se non sai quale di queste opzioni scegliere, consulta i requisiti per i codici di formazione per saperne di più.

Che cosa include un job personalizzato

Quando crei un job personalizzato, devi specificare le impostazioni configurate da Vertex AI per eseguire il codice di addestramento, tra cui:

Nei pool di worker, puoi specificare le seguenti impostazioni:

Puoi anche configurare i job personalizzati in modo che vengano eseguiti su una risorsa permanente anziché creare nuove risorse di calcolo durante l'avvio del job. Per scoprire di più su risorsa permanente, vedi Panoramica della risorsa permanente.

Configurare l'addestramento distribuito

Puoi configurare un CustomJob per l'addestramento distribuito specificando in più pool di worker.

La maggior parte degli esempi in questa pagina mostra job di addestramento a replica singola con un worker piscina. Per modificarle per l'addestramento distribuito:

  • Utilizza il primo pool di worker per configurare la replica principale e imposta il numero di repliche su 1.
  • Aggiungi altri pool di worker per configurare repliche dei worker, repliche dei server dei parametri o strumento di valutazione di repliche, se il framework di machine learning supporta questi cluster aggiuntivi per l'addestramento distribuito.

Scopri di più su utilizzando l'addestramento distribuito.

Crea un CustomJob

Per creare un CustomJob, segui le istruzioni riportate in una delle seguenti schede, a seconda dello strumento che vuoi utilizzare. Se utilizzi la CLI gcloud, puoi utilizzare un unico comando per eseguire l'autopacchettizzazione del codice di addestramento sulla tua macchina locale in un'immagine container Docker, eseguire il push dell'immagine container su Artifact Registry e creare un CustomJob. Le altre opzioni presuppongono che tu abbia già creato un'applicazione di addestramento Python o un'immagine container personalizzata.

gcloud

I seguenti esempi utilizzano il comando gcloud ai custom-jobs create.

Se il codice di addestramento si trova sul tuo computer locale, ti consigliamo di seguire la sezione Con il pacchettizzazione automatica. In alternativa, se hai già creato un'applicazione di addestramento Python o un'immagine container personalizzata, vai alla sezione Senza imballaggio automatico.

Con il confezionamento automatico

Se disponi del codice di addestramento sul computer locale, puoi utilizzare un singolo per effettuare le seguenti operazioni:

  • Crea un'immagine Docker personalizzata basata sul tuo codice.
  • Esegui il push dell'immagine in Artifact Registry.
  • Avvia un CustomJob basato sull'immagine.

Il risultato è simile alla creazione di un CustomJob utilizzando qualsiasi altro strumento container; puoi usare questa versione del comando se preferisci il tuo flusso di lavoro.

Prima di iniziare

Poiché questa versione del comando crea ed esegue il push di un'immagine Docker, devi eseguire la seguente configurazione sul tuo computer locale:

  1. Installa Docker Engine.

  2. Se utilizzi Linux, configura Docker in modo da poterlo eseguire senza sudo.

  3. Enable the Artifact Registry API.

    Enable the API

  4. Configura l'autenticazione per Docker, per poter eseguire il push delle immagini Docker in Artifact Registry:

    gcloud auth configure-docker

Crea ed esegui il push dell'immagine Docker, quindi crea un CustomJob

Il seguente comando crea un'immagine Docker basata su un'immagine container di addestramento predefinita e sul tuo codice Python locale, esegue il push dell'immagine in Artifact Registry e crea un CustomJob.

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,local-package-path=WORKING_DIRECTORY,script=SCRIPT_PATH

Sostituisci quanto segue:

  • LOCATION: la regione in cui verrà eseguito il container o il pacchetto Python.

  • JOB_NAME: campo obbligatorio. Un nome visualizzato per CustomJob.

  • MACHINE_TYPE: il tipo di macchina. Consulta i tipi di macchine disponibili per l'addestramento.

  • REPLICA_COUNT: il numero di repliche dei worker da usare. Nella maggior parte dei casi, imposta questo valore su 1 per il primo pool di worker.

  • EXECUTOR_IMAGE_URI: l'URI dell'immagine container che viene eseguita il codice fornito. Consulta le di container predefiniti disponibili addestramento.

    Questa immagine funge da immagine di base per la nuova immagine Docker che stai creando con questo comando.

  • WORKING_DIRECTORY: una directory nel file system locale contenente lo script del punto di ingresso che esegue il codice di addestramento (vedi il seguente elemento dell'elenco).

    Puoi utilizzare la directory principale dello script o una directory di livello superiore . Ti consigliamo di utilizzare una directory di livello superiore per specificare un nome di modulo Python completo (vedi l'elemento dell'elenco seguente). Ti consigliamo inoltre di utilizzare una directory di livello superiore se contiene un file requirements.txt o setup.py. Per saperne di più, consulta Installare le dipendenze.

    Tieni presente che anche se specificare una directory di livello superiore, questo comando copia solo del tuo script del punto di ingresso all'immagine Docker.

  • SCRIPT_PATH: il percorso relativo a WORKING_DIRECTORY nel tuo file locale di addestramento, allo script che rappresenta il punto di ingresso del codice di addestramento. Può essere uno script Python (che termina con .py) o uno script Bash.

    Ad esempio, se vuoi eseguire /hello-world/trainer/task.py e WORKING_DIRECTORY è /hello-world, utilizza trainer/task.py per questo valore.

    Utilizza python-module anziché script

    Se vuoi, puoi sostituire script=SCRIPT_PATH con python-module=PYTHON_MODULE per specificare il nome di un modulo Python in WORKING_DIRECTORY da eseguire come entry point per l'addestramento. Ad esempio, invece di script=trainer/task.py, potresti specificare python-module=trainer.task.

    In questo caso, il container Docker risultante carica il codice come modulo piuttosto che come script. Ti consigliamo di utilizzare questa opzione se lo script del punto di ingresso importa altri moduli Python in WORKING_DIRECTORY.

Installa le dipendenze

Quando utilizzi il pacchettizzazione automatica, puoi installare le dipendenze Python nel contenitore con gli stessi metodi disponibili quando utilizzi il comando local-run della CLI gcloud. Scoprire i vari modi per installare Python di dipendenze, leggi le Installa le dipendenze della guida al comando local-run.

La sintassi per specificare le dipendenze è leggermente diversa quando utilizzi la pacchettizzazione automatica rispetto a quando si usa il comando local-run. Anziché usare i flag a riga di comando per specificare le dipendenze, devi utilizzare le opzioni nel valore del flag --worker-pool-spec. Inoltre, i valori all'interno di questi devono essere separate da punto e virgola anziché da virgole. Nello specifico, la sintassi:

  • Anziché il flag --local-package-path del comando local-run, utilizza l'opzione local-package-path nel valore del flag --worker-pool-spec. Se la directory di lavoro specificata con questa opzione contiene File requirements.txt o setup.py, pacchettizzazione automatica delle dipendenze per le installazioni in base a questo file.

    L'esempio precedente mostra questa sintassi.

  • (Facoltativo) Anziché il flag --requirements, utilizza l'opzione requirements nel valore del flag --worker-pool-spec. Anziché separare le dipendenze PyPI con virgole, utilizza i punti e virgola.

  • (Facoltativo) Anziché il flag --extra-packages, utilizza l'opzione extra-packages nel valore del flag --worker-pool-spec. Anziché separare le dipendenze locali con le virgole, utilizza i punti e virgola.

  • (Facoltativo) Anziché il flag --extra-dirs, utilizza l'opzione extra-dirs nella il valore del flag --worker-pool-spec. Anziché separare i percorsi delle directory con virgole, utilizza i punti e virgola.

L'esempio seguente mostra come installare le dipendenze utilizzando tutte le tecniche facoltative. (puoi specificare qualsiasi sottoinsieme). Per dimostrare la sintassi del punto e virgola, l'esempio specifica due valori per ogni opzione. Per ridurre la lunghezza dell'esempio, le altre opzioni --worker-pool-spec vengono sostituite con [...].

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=[...],requirements=PYPI_DEP_1;PYPI_DEP_2,extra-packages=LOCAL_DEP_1;LOCAL_DEP_2,extra-dirs=EXTRA_DIR_1;EXTRA_DIR_2

Per conoscere i valori appropriati per questi segnaposto, consulta "Installa le dipendenze" nella guida al comando local-run.

Senza pacchettizzazione automatica

Se non utilizzi la pacchettizzazione automatica, puoi creare un CustomJob con un comando in modo simile a uno dei seguenti. In base al fatto che tu abbia creato un'applicazione di addestramento Python o un'immagine container personalizzata, scegli una delle seguenti schede:

App di addestramento Python

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE

Sostituisci quanto segue:

  • LOCATION: la regione in cui verrà eseguito il container o il pacchetto Python.
  • JOB_NAME: campo obbligatorio. Un nome visualizzato per CustomJob.
  • PYTHON_PACKAGE_URIS: elenco separato da virgole di URI di Cloud Storage che specificano i file del pacchetto Python, ovvero il programma di addestramento e i rispettivi pacchetti dipendenti. Il numero massimo di URI dei pacchetti è 100.
  • MACHINE_TYPE: il tipo di macchina. Consulta di tipi di macchine addestramento.
  • REPLICA_COUNT: il numero di repliche dei worker da utilizzare. Nella maggior parte dei casi, imposta questo valore su 1 per il primo pool di worker.
  • EXECUTOR_IMAGE_URI: l'URI dell'immagine container che viene eseguita il codice fornito. Consulta le di container predefiniti disponibili addestramento.
  • PYTHON_MODULE: il nome del modulo Python da eseguire dopo l'installazione del .

Immagine del container personalizzato

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

Sostituisci quanto segue:

  • LOCATION: la regione in cui verrà eseguito il container o il pacchetto Python.
  • JOB_NAME: campo obbligatorio. Un nome visualizzato per CustomJob.
  • MACHINE_TYPE: tipo di macchina. Consulta di tipi di macchine addestramento.
  • REPLICA_COUNT: il numero di repliche dei worker da usare. Nella maggior parte dei casi, imposta questo valore su 1 per primo pool di worker.
  • CUSTOM_CONTAINER_IMAGE_URI: l'URI di un'immagine container in Artifact Registry o Docker Hub da eseguire su ogni replica del worker.

Addestramento distribuito

Per eseguire l'addestramento distribuito, specifica il flag --worker-pool-spec più volte, una per ogni pool di worker.

Se utilizzi la pacchettizzazione automatica, devi specificare solo local-package-path, script e altre opzioni relative alla pacchettizzazione automatica nel primo pool di worker. Ometti i campi relativi al codice di addestramento nei pool di worker successivi, che useranno tutti lo stesso container di addestramento creato tramite il pacchettizzazione automatica.

Ad esempio, il seguente comando adatta un esempio di pacchettistica automatica precedente per utilizzare un secondo pool di worker:

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,local-package-path=WORKING_DIRECTORY,script=SCRIPT_PATH \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT

Se non utilizzi il pacchettizzazione automatica, specifica ogni pool di worker in modo completo e indipendente; non omettere alcun campo.

I comandi seguenti adattano gli esempi precedenti per utilizzare un secondo pool di worker:

App di addestramento Python

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,executor-image-uri=SECOND_POOL_EXECUTOR_IMAGE_URI,python-module=SECOND_POOL_PYTHON_MODULE

Immagine del container personalizzato

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 \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,container-image-uri=SECOND_POOL_CUSTOM_CONTAINER_IMAGE_URI

Configurazione avanzata

Se vuoi specificare opzioni di configurazione non disponibili negli esempi precedenti, puoi utilizzare il flag --config per indicare il percorso di un file config.yaml nell'ambiente locale contenente i campi di CustomJobSpec. Ad esempio:

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

Ecco un esempio di file config.yaml.

Console

Nella console Google Cloud, non puoi creare direttamente una risorsa CustomJob. Tuttavia, puoi creare una risorsa TrainingPipeline che crea un CustomJob.

Le seguenti istruzioni descrivono come creare un elemento TrainingPipeline che crea un CustomJob e non fa altro. Se vuoi utilizzare altre funzionalità TrainingPipeline, come l'addestramento con un set di dati gestito sulla creazione di una risorsa Model al termine dell'addestramento, leggi Creazione di una risorsa di archiviazione dei dati.

  1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Pipeline di addestramento.

    Vai a Pipeline di addestramento

  2. Fai clic su Crea per aprire il riquadro Addestra nuovo modello.

  3. Nel passaggio Metodo di addestramento, specifica le seguenti impostazioni:

    1. Nell'elenco a discesa Set di dati, seleziona Nessun set di dati gestito.

    2. Seleziona Addestramento personalizzato (avanzato).

    Fai clic su Continua.

  4. Nel passaggio Dettagli modello, scegli Addestra nuovo modello o Addestra nuova versione. Se selezioni Addestra nuovo modello, inserisci un nome a tua scelta,MODEL_NAME, per il modello. Fai clic su Continua.

  5. Nel passaggio Container di addestramento, specifica le seguenti impostazioni:

    1. Scegli se utilizzare un container predefinito o un container personalizzato container per l'addestramento.

    2. A seconda della tua scelta, esegui una delle seguenti operazioni:

    3. Nel campo Directory di output del modello, puoi specificare l'URI Cloud Storage di una directory in un bucket a cui hai accesso. La directory non deve ancora esistere.

      Questo valore viene passato a Vertex AI nel campo dell'API baseOutputDirectory, che imposta diverse variabili di ambiente a cui l'applicazione di addestramento può accedere durante l'esecuzione.

    4. Facoltativo: nel campo Argomenti puoi specificare gli argomenti per Vertex AI da utilizzare quando inizia a eseguire il codice di addestramento. La lunghezza massima di tutti gli argomenti combinati è di 100.000 caratteri. Il comportamento di questi argomenti varia a seconda del tipo di contenitore utilizzato:

    Fai clic su Continua.

  6. Nel passaggio Ottimizzazione degli iperparametri, assicurati che la casella Attiva La casella di controllo Ottimizzazione degli iperparametri non è selezionata. Fai clic su Continua.

  7. Nel passaggio Computing e prezzi, specifica le seguenti impostazioni:

    1. Nell'elenco a discesa Regione, seleziona una "regione che supporta l'addestramento personalizzato".

    2. Nella sezione Pool di worker 0, specifica compute risorse da usare per la formazione.

      Se specifichi gli acceleratori, assicurati che il tipo di acceleratore inserito scegli è disponibile nel regione.

      Se desideri eseguire attività distribuite addestramento, quindi fai clic su Aggiungi altro nei pool di worker e specificare un set aggiuntivo di risorse di computing per ogni pool di worker aggiuntivo desiderato.

    Fai clic su Continua.

  8. Nel passaggio Container di previsione, seleziona Nessuna previsione container.

  9. Fai clic su Inizia addestramento per avviare la pipeline di addestramento personalizzato.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • LOCATION: la regione in cui verrà installato il container o il pacchetto Python vengono eseguiti tutti i test delle unità.
  • PROJECT_ID: il tuo ID progetto.
  • JOB_NAME: obbligatorio. Un nome visualizzato per CustomJob.
  • Definisci il job di addestramento personalizzato:
    • MACHINE_TYPE: il tipo di macchina. Consulta di tipi di macchine addestramento.
    • ACCELERATOR_TYPE: (facoltativo) Il tipo di acceleratore da collegare al job.
    • ACCELERATOR_COUNT: (facoltativo) Il numero di acceleratori da collegare al job.
    • DISK_TYPE: (facoltativo) Il tipo di disco di avvio da utilizzare per il job, pd-standard (predefinito) o pd-ssd. Scopri di più sui tipi di dischi.
    • DISK_SIZE: (facoltativo) Le dimensioni in GB del disco di avvio da utilizzare per il job. La il valore predefinito è 100.
    • REPLICA_COUNT: il numero di repliche dei worker da utilizzare. Nella maggior parte dei casi, imposta questo valore su 1 per primo pool di worker.
    • Se l'applicazione di addestramento viene eseguita in un contenitore personalizzato, specifica quanto segue:
      • CUSTOM_CONTAINER_IMAGE_URI: l'URI di un'immagine container in Artifact Registry o Docker Hub da eseguire su ciascuna replica worker. /li>
      • CUSTOM_CONTAINER_COMMAND: (facoltativo) Il comando da richiamare all'avvio del container. Questo comando esegue l'override dell'entry point predefinito del container.
      • CUSTOM_CONTAINER_ARGS: (facoltativo) Gli argomenti da passare all'avvio del container.
    • Se l'applicazione di addestramento è un pacchetto Python eseguito in un container predefinito, specificare quanto segue:
      • EXECUTOR_IMAGE_URI: l'URI dell'immagine container che viene eseguita il codice fornito. Consulta le di container predefiniti disponibili addestramento.
      • PYTHON_PACKAGE_URIS: elenco separato da virgole di Cloud Storage URI che specificano i file del pacchetto Python, ovvero il programma di addestramento e dei pacchetti dipendenti. Il numero massimo di URI dei pacchetti è 100.
      • PYTHON_MODULE: il nome del modulo Python da eseguire dopo l'installazione del .
      • PYTHON_PACKAGE_ARGS: (facoltativo) Argomenti della riga di comando da passare il modulo Python.
    • Scopri di più sulle opzioni di pianificazione dei job.
    • TIMEOUT: (facoltativo) Il tempo di esecuzione massimo per il job.
  • Specifica LABEL_NAME e LABEL_VALUE per le eventuali etichette da applicare a questo job personalizzato.

Metodo HTTP e URL: 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs

Corpo JSON della richiesta: 

{
  "displayName": "JOB_NAME",
  "jobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": MACHINE_TYPE,
          "acceleratorType": ACCELERATOR_TYPE,
          "acceleratorCount": ACCELERATOR_COUNT
        },
        "replicaCount": REPLICA_COUNT,
        "diskSpec": {
          "bootDiskType": DISK_TYPE,
          "bootDiskSizeGb": DISK_SIZE
        },

        // Union field task can be only one of the following:
        "containerSpec": {
          "imageUri": CUSTOM_CONTAINER_IMAGE_URI,
          "command": [
            CUSTOM_CONTAINER_COMMAND
          ],
          "args": [
            CUSTOM_CONTAINER_ARGS
          ]
        },
        "pythonPackageSpec": {
          "executorImageUri": EXECUTOR_IMAGE_URI,
          "packageUris": [
            PYTHON_PACKAGE_URIS
          ],
          "pythonModule": PYTHON_MODULE,
          "args": [
            PYTHON_PACKAGE_ARGS
          ]
        }
        // End of list of possible types for union field task.
      }
      // Specify one workerPoolSpec for single replica training, or multiple workerPoolSpecs
      // for distributed training.
    ],
    "scheduling": {
      "timeout": TIMEOUT
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. ed esegui questo comando: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs"

PowerShell

Salva il corpo della richiesta in un file denominato request.json. ed esegui questo comando: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs" | Select-Object -Expand Content

La risposta contiene informazioni sulle specifiche e sul JOB_ID.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Vertex AI.

Per autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 


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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Vertex AI.

Per autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta documentazione di riferimento dell'API Python. 

def create_custom_job_with_experiment_autologging_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    script_path: str,
    container_uri: str,
    service_account: str,
    experiment: str,
    experiment_run: Optional[str] = None,
) -> None:
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket, experiment=experiment)

    job = aiplatform.CustomJob.from_local_script(
        display_name=display_name,
        script_path=script_path,
        container_uri=container_uri,
        enable_autolog=True,
    )

    job.run(
        service_account=service_account,
        experiment=experiment,
        experiment_run=experiment_run,
    )

Passaggi successivi