crea job di addestramento personalizzato

gcloud

Negli esempi riportati di seguito viene utilizzato il comando gcloud ai custom-jobs create.

Se il codice di addestramento è sul computer locale, ti consigliamo di seguire la sezione Con autopackaging. In alternativa, se hai già creato un'applicazione di addestramento Python o un'immagine container personalizzata, passa alla sezione Senza autopackaging.

Con autopackaging

Se hai un codice di addestramento sul computer locale, puoi utilizzare un singolo comando per:

• Crea un'immagine Docker personalizzata in base al tuo codice.
• Esegui il push dell'immagine in Artifact Registry.
• Avvia una CustomJob in base all'immagine.

Il risultato è simile alla creazione di un oggetto CustomJob con qualsiasi altro container personalizzato; puoi utilizzare questa versione del comando se preferisci per 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. Attiva l'API Container Registry.

   Abilita l'API

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

   gcloud auth configure-docker
   

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

Il comando seguente crea un'immagine Docker basata su un'immagine container di addestramento predefinita e sul codice Python locale, esegue il push dell'immagine in Artifact Registry e crea un oggetto 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: 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 utilizzare. Nella maggior parte dei casi, imposta 1 per il pool di primo worker.

• EXECUTOR_IMAGE_URI: l'URI dell'immagine container che esegue il codice fornito. Consulta i container predefiniti disponibili per l'addestramento.

  Questa è l'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 tuo codice di addestramento (vedi la voce di elenco seguente).

  Puoi utilizzare la directory padre dello script o una directory di livello superiore. Potresti voler utilizzare una directory di livello superiore per specificare un nome completo del modulo Python (vedi la voce dell'elenco che segue). Ti consigliamo inoltre di utilizzare una directory di livello superiore se contiene un file requirements.txt o setup.py. Per scoprire di più, consulta Installare le dipendenze.

  Tieni presente che anche se specifichi una directory di livello superiore, questo comando copia solo la directory padre dello script del punto di ingresso nell'immagine Docker.

• SCRIPT_PATH: il percorso, relativo a WORKING_DIRECTORY nel file system locale, allo script che è il punto di ingresso per il 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.

  Usa python-module anziché script

  Facoltativamente, puoi sostituire script=SCRIPT_PATH con python-module=PYTHON_MODULE per specificare il nome di un modulo Python in WORKING_DIRECTORY da eseguire come punto di ingresso per l'addestramento. Ad esempio, anziché script=trainer/task.py, puoi specificare python-module=trainer.task.

  In questo caso, il container Docker risultante carica il codice come modulo anziché 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 la pacchettizzazione automatica, puoi installare le dipendenze Python nel tuo container negli stessi modi disponibili quando usi il comando local-run dell'interfaccia a riga di comando gcloud. Per informazioni sui vari modi per installare le dipendenze Python, leggi la sezione Installare le dipendenze nella guida per il comando local-run.

La sintassi per specificare le dipendenze è leggermente diversa quando utilizzi autopackaging rispetto a quando utilizzi il comando local-run. Anziché utilizzare i flag della riga di comando per specificare le dipendenze, devi utilizzare le opzioni nel valore del flag --worker-pool-spec. Inoltre, i valori all'interno di queste opzioni devono essere separati 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 un file requirements.txt o setup.py, la pacchettizzazione automatica installa le dipendenze in base a questo file.

  L'esempio precedente illustra questa sintassi.

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

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

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

L'esempio seguente mostra come installare le dipendenze utilizzando tutte le tecniche facoltative. Puoi specificarne qualsiasi sottoinsieme. Per dimostrare la sintassi con punto e virgola, l'esempio specifica due valori per ogni opzione. Per ridurre la lunghezza dell'esempio, 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 informazioni sui valori appropriati per questi segnaposto, consulta "Installa dipendenze" nella guida al comando local-run.

Senza autopackaging

Se non usi la pacchettizzazione automatica, puoi creare CustomJob con un comando simile a uno dei seguenti. A seconda che tu abbia creato un'applicazione di addestramento Python o un'immagine container personalizzata, scegli una delle seguenti schede:

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

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

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 utilizzeranno tutti lo stesso container di addestramento creato dalla pacchettizzazione automatica.

Ad esempio, il seguente comando adatta un esempio di pacchettizzazione 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 la pacchettizzazione automatica, specifica ogni pool di worker in modo completo e indipendente; non omettere alcun campo.

I comandi seguenti adattano gli esempi precedenti in modo da utilizzare un secondo pool di worker:

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

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 che non sono disponibili negli esempi precedenti, puoi utilizzare il flag --config per specificare il percorso di un file config.yaml nel tuo ambiente locale contenente i campi di CustomJobSpec. Ad esempio:

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

Esamina 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 istruzioni seguenti descrivono come creare un TrainingPipeline che crei un CustomJob e non faccia altro. Se vuoi utilizzare funzionalità TrainingPipeline aggiuntive, come l'addestramento con un set di dati gestito o la creazione di una risorsa Model al termine dell'addestramento, leggi Creazione di pipeline di addestramento.

1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina pipeline di addestramento.

   Vai a Pipeline di addestramento

2. Fai clic su add_box 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 Contenitore di addestramento, specifica le seguenti impostazioni:

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

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

      • Se vuoi utilizzare un container predefinito per l'addestramento, fornisci a Vertex AI le informazioni necessarie per utilizzare il pacchetto di addestramento che hai caricato su Cloud Storage:

        1. Usa gli elenchi a discesa Framework del modello e Versione del framework del modello per specificare il container predefinito che vuoi utilizzare.

        2. Nel campo Posizione pacchetto, specifica l'URI Cloud Storage dell'applicazione di addestramento Python che hai creato e caricato. Questo file solitamente termina con .tar.gz.

        3. Nel campo Modulo Python, inserisci il nome del modulo del punto di ingresso dell'applicazione di addestramento.

      • Se vuoi utilizzare un container personalizzato per l'addestramento, nel campo Immagine container, specifica l'URI Artifact Registry o Docker Hub dell'immagine container.

   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 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 da utilizzare per Vertex AI quando inizia l'esecuzione del codice di addestramento. La lunghezza massima per tutti gli argomenti combinati è di 100.000 caratteri. Il comportamento di questi argomenti varia a seconda del tipo di container in uso:

      • Se utilizzi un container predefinito, Vertex AI passa gli argomenti come flag della riga di comando al modulo Python.

      • Se utilizzi un container personalizzato, Vertex AI sostituisce l'istruzione CMD del container con gli argomenti.

   Fai clic su Continua.

6. Nel passaggio Ottimizzazione degli iperparametri, assicurati che la casella di controllo Abilita l'ottimizzazione degli iperparametri non sia selezionata. Fai clic su Continua.

7. Nel passaggio Calcolo 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 le risorse di calcolo da utilizzare per l'addestramento.

      Se specifichi acceleratori, assicurati che il tipo di acceleratore scelto sia disponibile nella regione selezionata.

      Se vuoi eseguire un addestramento distribuito, fai clic su Aggiungi altri pool di worker e specifica un set aggiuntivo di risorse di computing per ogni pool di worker aggiuntivo che vuoi.

   Fai clic su Continua.

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

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

REST

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

• LOCATION: la regione in cui verrà eseguito il container o il pacchetto Python.
• 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 i tipi di macchine disponibili per l'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 disco.
  • DISK_SIZE: (facoltativo) La dimensione in GB del disco di avvio da utilizzare per il job. Il valore predefinito è 100.
  • REPLICA_COUNT: il numero di repliche dei worker da utilizzare. Nella maggior parte dei casi, imposta 1 per il pool di primo worker.
  • Se l'applicazione di addestramento viene eseguita in un container personalizzato, specifica quanto segue:
    • CUSTOM_CONTAINER_IMAGE_URI: l'URI di un'immagine container in Artifact Registry, Container Registry o Docker Hub da eseguire su ogni replica worker.
    • CUSTOM_CONTAINER_COMMAND: (facoltativo) Il comando da richiamare all'avvio del container. Questo comando sostituisce il punto di ingresso 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, specifica quanto segue:
    • EXECUTOR_IMAGE_URI: l'URI dell'immagine container che esegue il codice fornito. Consulta i container predefiniti disponibili per l'addestramento.
    • PYTHON_PACKAGE_URIS: elenco separato da virgole di URI Cloud Storage che specificano i file dei pacchetti Python che rappresentano il programma di addestramento e i relativi pacchetti dipendenti. Il numero massimo di URI dei pacchetti è 100.
    • PYTHON_MODULE: il nome del modulo Python da eseguire dopo l'installazione dei pacchetti.
    • PYTHON_PACKAGE_ARGS: (facoltativo) Argomenti della riga di comando da passare al modulo Python.
  • Scopri di più sulle opzioni di pianificazione del lavoro.
  • TIMEOUT: (facoltativo) Il tempo di esecuzione massimo per il job.
• Specifica LABEL_NAME e LABEL_VALUE per le eventuali etichette che vuoi applicare al job personalizzato.

Metodo HTTP e URL:

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

$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 "http://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs" | Select-Object -Expand Content

La risposta contiene informazioni sulle specifiche e su TRAININGPIPELINE_ID.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/customJobs/JOB_ID",
  "displayName": "JOB_NAME",
  "trainingTaskInputs": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://BUCKET_NAME/training/hello-custom-training-1.0.tar.gz"
          ],
          "pythonModule": "trainer.task",
          "args": [
            "--model-dir=gs://BUCKET_NAME/output/"
          ]
        }
      }
    ]
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}

Java

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

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare 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
    // http://cloud.go888ogle.com.fqhub.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

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

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare 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, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la 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,
    )