Creazione pipeline di addestramento

Le pipeline di addestramento consentono di eseguire l'addestramento di machine learning (ML) personalizzato e creare automaticamente una risorsa Model in base all'output dell'addestramento.

Prima di creare una pipeline

Prima di creare una pipeline di addestramento su Vertex AI, devi creare un'applicazione di addestramento Python o un contenitore personalizzato per definire il codice di addestramento e le dipendenze che vuoi eseguire su Vertex AI. Se crei un'applicazione di addestramento Python con TensorFlow, scikit-learn o XGBoost, puoi utilizzare i nostri container predefiniti per eseguire il codice. Se non sai quale di queste opzioni scegliere, consulta i requisiti del codice di addestramento per saperne di più.

Opzioni pipeline di addestramento

Una pipeline di addestramento include job di addestramento con passaggi aggiuntivi. Questa guida spiega due diverse pipeline di addestramento:

  • Avvia un CustomJob e carica il modello risultante in Vertex AI
  • Avvia un job di ottimizzazione degli iperparametri e carica il modello risultante in Vertex AI

Inoltre, puoi utilizzare i set di dati Vertex AI (set di dati gestiti) nella pipeline di addestramento. Scopri di più sulla configurazione della pipeline di addestramento per l'utilizzo di un set di dati gestito.

Cosa include un CustomJob

Quando crei un job personalizzato, devi specificare le impostazioni necessarie per consentire a Vertex AI di eseguire il tuo codice di addestramento, tra cui:

All'interno dei pool di worker, puoi specificare le seguenti impostazioni:

Se vuoi creare un job personalizzato autonomo all'esterno di una pipeline di addestramento su Vertex AI, consulta la guida ai job personalizzati.

Configurare la pipeline per l'utilizzo di un set di dati gestito

Nella pipeline di addestramento puoi configurare il job di addestramento personalizzato o il job di ottimizzazione degli iperparametri per utilizzare un set di dati gestito. I set di dati gestiti consentono di gestire i set di dati con le applicazioni e i modelli di addestramento.

Per utilizzare un set di dati gestito nella pipeline di addestramento:

  1. Crea il tuo set di dati.
  2. Aggiorna l'applicazione di addestramento per utilizzare un set di dati gestito. Per ulteriori informazioni, scopri come Vertex AI passa il tuo set di dati all'applicazione di addestramento.
  3. Specifica un set di dati gestito quando crei la pipeline di addestramento. Ad esempio, se crei la pipeline di addestramento utilizzando l'API REST, specifica le impostazioni del set di dati nella sezione inputDataConfig.

    Devi creare la pipeline di addestramento nella stessa area geografica in cui hai creato il set di dati.

Per scoprire di più, consulta il riferimento API all'indirizzo TrainingPipeline.

Configura addestramento distribuito

All'interno della pipeline di addestramento, puoi configurare il tuo job di addestramento personalizzato o il tuo job di ottimizzazione degli iperparametri per l'addestramento distribuito specificando più pool di worker.

Tutti gli esempi in questa pagina mostrano i job di addestramento con replica singola con un pool di worker. Per modificarle per l'addestramento distribuito:

  • Utilizza il tuo primo pool di worker per configurare la replica principale e imposta il conteggio delle repliche su 1.
  • Aggiungi altri pool di worker per configurare le repliche dei worker, le repliche del server dei parametri o le repliche del valutatore, se il tuo framework di machine learning supporta queste attività cluster aggiuntive per l'addestramento distribuito.

Scopri di più sull'utilizzo della formazione distribuita.

Caricamento modello job personalizzato

Questa pipeline di addestramento include un job personalizzato con un ulteriore passaggio di comodità, che semplifica il deployment del modello su Vertex AI dopo l'addestramento. Questa pipeline di addestramento svolge due attività principali:

  1. La pipeline di addestramento crea una risorsa CustomJob. Il job personalizzato esegue l'applicazione di addestramento utilizzando le risorse di calcolo specificate.

  2. Al termine del job personalizzato, la pipeline di addestramento trova gli artefatti del modello creati dall'applicazione di addestramento nella directory di output specificata per il bucket Cloud Storage. Utilizza questi artefatti per creare una risorsa model, che ti configurerà per il deployment del modello.

    La dimensione totale del file degli artefatti del modello deve essere al massimo di 10 GB.

Esistono due modi diversi per impostare la località degli artefatti del modello:

  • Se imposti un elemento baseOutputDirectory per il job di addestramento, assicurati che il codice di addestramento salvi gli artefatti del modello in quella posizione, utilizzando la variabile di ambiente $AIP_MODEL_DIR impostata da Vertex AI. Una volta completato il job di addestramento, Vertex AI cerca gli artefatti del modello risultanti in gs://BASE_OUTPUT_DIRECTORY/model.
  • Se imposti il campo modelToUpload.artifactUri, la pipeline di addestramento carica gli artefatti del modello da tale URI. Devi impostare questo campo se non hai impostato baseOutputDirectory.

Se specifichi sia baseOutputDirectory che modelToUpload.artifactUri, Vertex AI utilizza modelToUpload.artifactUri.

Per creare questo tipo di pipeline di addestramento:

console

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

    Vai alle pipeline di addestramento

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

  3. Nel passaggio Addestramento, specifica le seguenti impostazioni:

    1. Se vuoi utilizzare un set di dati gestito per l'addestramento, specifica un set di dati e un set di annotazione.

      In caso contrario, nell'elenco a discesa Set di dati, seleziona Nessun set di dati gestito.

    2. Seleziona Formazione personalizzata (avanzata).

    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 tuo modello. Fai clic su Continua.

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

    1. Seleziona se utilizzare un contenitore predefinito o un contenitore personalizzato per l'addestramento.

    2. A seconda dell'opzione scelta, procedi in uno dei seguenti modi:

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

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

      Al termine dell'addestramento, Vertex AI cerca gli artefatti del modello in una sottodirectory di questo URI per creare un Model. Questa sottodirectory è disponibile per il tuo codice di addestramento come variabile di ambiente AIP_MODEL_DIR.

      Se non utilizzi l'ottimizzazione degli iperparametri, Vertex AI prevede di trovare artefatti del modello in BASE_OUTPUT_DIRECTORY/model/.

    4. Nel campo Argomenti, puoi specificare facoltativamente argomenti che possono essere utilizzati da Vertex AI all'avvio del codice di addestramento. Il comportamento di questi argomenti varia a seconda del tipo di contenitore in uso:

    Fai clic su Continua.

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

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

    1. Nell'elenco a discesa Regione, seleziona un'area geograficache supporta l'addestramento personalizzato"

    2. Nella sezione Pool di worker 0, specifica le risorse di calcolo da utilizzare per l'addestramento.

      Se specifichi gli acceleratori, assicurati che il tipo di acceleratore scelto sia disponibile nell'area geografica selezionata.

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

    Fai clic su Continua.

  8. Nel passaggio Contenitore delle previsioni, specifica le seguenti impostazioni:

    1. Seleziona se utilizzi un contenitore predefinito o un contenitore personalizzato per pubblicare previsioni dal modello addestrato.

    2. A seconda dell'opzione scelta, procedi in uno dei seguenti modi:

    3. Il campo Directory modelli contiene il valore precedentemente impostato nel campo Directory di output del modello del passaggio Contenitore addestramento. La modifica di uno di questi campi ha lo stesso effetto. Per ulteriori informazioni su questo campo, consulta le istruzioni precedenti.

    4. Lascia vuoti i campi nella sezione Schema di previsione.

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

REST &CMD LINE

Utilizza il seguente esempio di codice per creare una pipeline di addestramento con il metodo create della risorsa trainingPipeline.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • LOCATION_ID: l'area geografica in cui viene eseguito il codice di addestramento e in cui è archiviato Model.
  • PROJECT_ID: il tuo ID progetto.
  • TRAINING_PIPELINE_NAME: campo obbligatorio. Un nome visualizzato per la pipelinePipe training.
  • Se la tua applicazione di addestramento utilizza un set di dati Vertex AI, specifica quanto segue:
    • DATASET_ID: l'ID del set di dati.
    • ANNOTATIONS_FILTER: filtra il set di dati in base alle annotazioni specificate.
    • ANNOTATION_SCHEMA_URI: filtra il set di dati in base all'URI dello schema di annotazione specificato.
    • Utilizza una delle seguenti opzioni per specificare la modalità di suddivisione degli elementi di dati in set di addestramento, convalida e test.
      • Per suddividere il set di dati in base a frazioni che definiscono le dimensioni di ogni set, specifica quanto segue:
        • TRAINING_FRACTION: la frazione del set di dati da utilizzare per addestrare il modello.
        • VALIDATION_FRACTION: la frazione del set di dati da utilizzare per convalidare il modello.
        • TEST_FRACTION: la frazione del set di dati da utilizzare per valutare il modello.
      • Per suddividere il set di dati in base ai filtri, specifica quanto segue:
        • TRAINING_FILTER: filtra il set di dati in base agli elementi dati da utilizzare per l'addestramento del modello.
        • VALIDATION_FILTER: filtra il set di dati in base agli elementi dati da utilizzare per la convalida del modello.
        • TEST_FILTER: filtra il set di dati in base agli elementi di dati da utilizzare per valutare il modello.
      • Per utilizzare una suddivisione predefinita, specifica quanto segue:
        • PREDEFINED_SPLIT_KEY: il nome della colonna da utilizzare per suddividere il set di dati. I valori accettabili in questa colonna includono "addestramento", "convalida" e "test".
      • Per suddividere il set di dati in base al timestamp sugli elementi di dati, specifica quanto segue:
        • TIMESTAMP_TRAINING_FRACTION: la frazione del set di dati da utilizzare per addestrare il modello.
        • TIMESTAMP_VALIDATION_FRACTION: la frazione del set di dati da utilizzare per convalidare il modello.
        • TIMESTAMP_TEST_FRACTION: la frazione del set di dati da utilizzare per valutare il modello.
        • TIMESTAMP_SPLIT_KEY: il nome della colonna timestamp da utilizzare per suddividere il set di dati.
    • OUTPUT_URI_PREFIX: la località di Cloud Storage in cui Vertex AI esporta il set di dati di addestramento, una volta suddiviso in set di addestramento, convalida e test.
  • Definisci il job di addestramento personalizzato:
    • MACHINE_TYPE: il tipo di macchina. Fai riferimento ai tipi di macchine disponibili per l'addestramento.
    • (Facoltativo) ACCELERATOR_TYPE: Il tipo di acceleratore da collegare a ciascuna prova.
    • (Facoltativo) ACCELERATOR_COUNT: Il numero di acceleratori da collegare a ciascuna prova.
    • REPLICA_COUNT: il numero di repliche di worker da utilizzare per ogni prova.
    • Se la tua applicazione di addestramento viene eseguita in un container personalizzato, specifica quanto segue:
      • CUSTOM_CONTAINER_IMAGE_URI: URI di un'immagine container in Artifact Registry, Container Registry o Docker Hub da eseguire su ogni replica worker.
      • (Facoltativo) CUSTOM_CONTAINER_COMMAND: Il comando da richiamare all'avvio del container. Questo comando sostituisce il punto di accesso predefinito del container.
      • (Facoltativo) CUSTOM_CONTAINER_ARGS: Gli argomenti da trasmettere all'avvio del container.
    • Se la tua applicazione di addestramento è un pacchetto Python eseguito in un container predefinito, specifica quanto segue:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: URI dell'immagine container che esegue il pacchetto Python fornito. Fai riferimento ai container predefiniti disponibili per l'addestramento.
      • PYTHON_PACKAGE_URIS: la posizione Cloud Storage dei file del pacchetto Python che sono il programma di addestramento e i relativi pacchetti dipendenti. Il numero massimo di URI di pacchetto è 100.
      • PYTHON_MODULE: il nome del modulo Python da eseguire dopo l'installazione dei pacchetti.
      • (Facoltativo) PYTHON_PACKAGE_ARGS: Argomenti della riga di comando da trasmettere al modulo Python.
    • (Facoltativo) TIMEOUT: Il tempo di esecuzione massimo per il job.
  • MODEL_NAME: nome visualizzato per il modello caricato (creato) dalla TrainingPipeline.
  • MODEL_DESCRIPTION: una descrizione del modello.
  • IMAGE_URI: l'URI dell'immagine container da utilizzare per l'esecuzione delle previsioni. Ad esempio, us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Utilizza container predefiniti o container personalizzati.
  • modelToUpload.labels: qualsiasi insieme di coppie chiave-valore per organizzare i modelli. Ad esempio:
    • "env": "prod"
    • "tier": "backend"
  • Specifica LABEL_NAME e LABEL_VALUE per tutte le etichette che vuoi applicare a questa pipeline di addestramento.

Metodo HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines

Corpo JSON richiesta:

{
  "displayName": "TRAINING_PIPELINE_NAME",
  "inputDataConfig": {
    "datasetId": DATASET_ID,
    "annotationsFilter": ANNOTATIONS_FILTER,
    "annotationSchemaUri": ANNOTATION_SCHEMA_URI,

    // Union field split can be only one of the following:
    "fractionSplit": {
      "trainingFraction": TRAINING_FRACTION,
      "validationFraction": VALIDATION_FRACTION,
      "testFraction": TEST_FRACTION
    },
    "filterSplit": {
      "trainingFilter": TRAINING_FILTER,
      "validationFilter": VALIDATION_FILTER,
      "testFilter": TEST_FILTER
    },
    "predefinedSplit": {
      "key": PREDEFINED_SPLIT_KEY
    },
    "timestampSplit": {
      "trainingFraction": TIMESTAMP_TRAINING_FRACTION,
      "validationFraction": TIMESTAMP_VALIDATION_FRACTION,
      "testFraction": TIMESTAMP_TEST_FRACTION,
      "key": TIMESTAMP_SPLIT_KEY
    }
    // End of list of possible types for union field split.
    "gcsDestination": {
      "outputUriPrefix": OUTPUT_URI_PREFIX
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "workerPoolSpecs": [
        {
          "machineSpec": {
            "machineType": MACHINE_TYPE,
            "acceleratorType": ACCELERATOR_TYPE,
            "acceleratorCount": ACCELERATOR_COUNT
          },
          "replicaCount": REPLICA_COUNT,

          // 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": PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,
            "packageUris": [
              PYTHON_PACKAGE_URIS
            ],
            "pythonModule": PYTHON_MODULE,
            "args": [
              PYTHON_PACKAGE_ARGS
            ]
          }
          // End of list of possible types for union field task.
        }
      ],
      "scheduling": {
        "TIMEOUT": TIMEOUT
      }
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "IMAGE_URI"
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

Curling

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

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

PowerShell

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

$cred = gcloud auth application-default 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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

La risposta contiene informazioni sulle specifiche e sull'TRAININGPIPELINE_ID.

Java

Per informazioni su come installare e utilizzare la libreria client per Vertex AI, consulta le librerie client di Vertex AI. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di AI AI.

import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.Model;
import com.google.cloud.aiplatform.v1.ModelContainerSpec;
import com.google.cloud.aiplatform.v1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1.PipelineServiceSettings;
import com.google.cloud.aiplatform.v1.TrainingPipeline;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class CreateTrainingPipelineCustomJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelDisplayName = "MODEL_DISPLAY_NAME";
    String containerImageUri = "CONTAINER_IMAGE_URI";
    String baseOutputDirectoryPrefix = "BASE_OUTPUT_DIRECTORY_PREFIX";
    createTrainingPipelineCustomJobSample(
        project, displayName, modelDisplayName, containerImageUri, baseOutputDirectoryPrefix);
  }

  static void createTrainingPipelineCustomJobSample(
      String project,
      String displayName,
      String modelDisplayName,
      String containerImageUri,
      String baseOutputDirectoryPrefix)
      throws IOException {
    PipelineServiceSettings settings =
        PipelineServiceSettings.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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PipelineServiceClient client = PipelineServiceClient.create(settings)) {
      JsonObject jsonMachineSpec = new JsonObject();
      jsonMachineSpec.addProperty("machineType", "n1-standard-4");

      JsonArray jsonArgs = new JsonArray();
      jsonArgs.add("--model_dir=$(AIP_MODEL_DIR)");

      // A working docker image can be found at
      // gs://cloud-samples-data/ai-platform/mnist_tfrecord/custom_job
      JsonObject jsonContainerSpec = new JsonObject();
      jsonContainerSpec.addProperty("imageUri", containerImageUri);
      jsonContainerSpec.add("args", jsonArgs);

      JsonObject jsonJsonWorkerPoolSpec0 = new JsonObject();
      jsonJsonWorkerPoolSpec0.addProperty("replicaCount", 1);
      jsonJsonWorkerPoolSpec0.add("machineSpec", jsonMachineSpec);
      jsonJsonWorkerPoolSpec0.add("containerSpec", jsonContainerSpec);

      JsonArray jsonWorkerPoolSpecs = new JsonArray();
      jsonWorkerPoolSpecs.add(jsonJsonWorkerPoolSpec0);

      JsonObject jsonBaseOutputDirectory = new JsonObject();
      // The GCS location for outputs must be accessible by the project's AI Platform
      // service account.
      jsonBaseOutputDirectory.addProperty("output_uri_prefix", baseOutputDirectoryPrefix);

      JsonObject jsonTrainingTaskInputs = new JsonObject();
      jsonTrainingTaskInputs.add("workerPoolSpecs", jsonWorkerPoolSpecs);
      jsonTrainingTaskInputs.add("baseOutputDirectory", jsonBaseOutputDirectory);

      Value.Builder trainingTaskInputsBuilder = Value.newBuilder();
      JsonFormat.parser().merge(jsonTrainingTaskInputs.toString(), trainingTaskInputsBuilder);
      Value trainingTaskInputs = trainingTaskInputsBuilder.build();
      String trainingTaskDefinition =
          "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml";
      String imageUri = "gcr.io/cloud-aiplatform/prediction/tf-cpu.1-15:latest";
      ModelContainerSpec containerSpec =
          ModelContainerSpec.newBuilder().setImageUri(imageUri).build();
      Model modelToUpload =
          Model.newBuilder()
              .setDisplayName(modelDisplayName)
              .setContainerSpec(containerSpec)
              .build();
      TrainingPipeline trainingPipeline =
          TrainingPipeline.newBuilder()
              .setDisplayName(displayName)
              .setTrainingTaskDefinition(trainingTaskDefinition)
              .setTrainingTaskInputs(trainingTaskInputs)
              .setModelToUpload(modelToUpload)
              .build();
      LocationName parent = LocationName.of(project, location);
      TrainingPipeline response = client.createTrainingPipeline(parent, trainingPipeline);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }
}

Python

Per informazioni su come installare e utilizzare la libreria client per Vertex AI, consulta le librerie client di Vertex AI. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python AI Vertex.

I seguenti esempi mostrano come utilizzare l'SDK Vertex AI per Python per creare una pipeline di addestramento personalizzato. Scegli se utilizzare un contenitore personalizzato o un contenitore predefinito per l'addestramento:

Contenitore predefinito

Quando utilizzi l'SDK Vertex AI per Python per creare una pipeline di addestramento che esegue il tuo codice Python in un container predefinito, puoi fornire il tuo codice di addestramento in uno dei seguenti modi:

  • Specifica l'URI di un pacchetto di distribuzione di origine Python in Cloud Storage.

    Questa opzione è disponibile anche quando crei una pipeline di addestramento senza utilizzare l'SDK Vertex AI per Python.

  • Specifica il percorso di uno script Python sulla tua macchina locale. Prima di creare una pipeline di addestramento, l'SDK Vertex AI per Python pacchettizza lo script come distribuzione di origine e lo carica nel bucket Cloud Storage a tua scelta.

    Questa opzione è disponibile solo quando utilizzi l'SDK Vertex AI per Python.

Per visualizzare un esempio di codice per ciascuna di queste opzioni, seleziona la scheda corrispondente:

Pacchetto

Il seguente esempio utilizza la classe CustomPythonPackageTrainingJob.

def create_training_pipeline_custom_package_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    python_package_gcs_uri: str,
    python_module_name: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 1,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomPythonPackageTrainingJob(
        display_name=display_name,
        python_package_gcs_uri=python_package_gcs_uri,
        python_module_name=python_module_name,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Script

Il seguente esempio utilizza la classe CustomTrainingJob.

def create_training_pipeline_custom_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    script_path: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 0,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomTrainingJob(
        display_name=display_name,
        script_path=script_path,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Contenitore personalizzato

Il seguente esempio utilizza la classe CustomContainerTrainingJob.

def create_training_pipeline_custom_container_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 1,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomContainerTrainingJob(
        display_name=display_name,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Caricamento del modello e del job di ottimizzazione degli iperparametri

Questa pipeline di addestramento include un job di ottimizzazione degli iperparametri con un ulteriore passaggio di comodità che semplifica il deployment del modello su Vertex AI dopo l'addestramento. Questa pipeline di addestramento fa due cose principali:

  1. La pipeline di addestramento crea una risorsa di job di ottimizzazione iperparametri. Il job di ottimizzazione degli iperparametri crea più prove. Per ogni prova, un job personalizzato esegue l'applicazione di addestramento utilizzando le risorse di calcolo e gli iperparametri specificati.

  2. Al termine del job di ottimizzazione degli iperparametri, la pipeline di addestramento rileva gli artefatti del modello dalla prova migliore, all'interno della directory di output (baseOutputDirectory) specificata per il bucket Cloud Storage. La pipeline di addestramento utilizza questi artefatti per creare una risorsa model, che ti consente di configurare il deployment del modello.

Per questa pipeline di addestramento, devi specificare un elemento baseOutputDirectory in cui Vertex AI cerca gli artefatti del modello partendo dalla prova migliore.

I job di ottimizzazione degli iperparametri hanno impostazioni aggiuntive da configurare. Scopri di più sulle impostazioni di una HyperparameterTuningJob.

REST &CMD LINE

Utilizza il seguente esempio di codice per creare una pipeline di addestramento con il metodo create della risorsa trainingPipeline.

Prima di utilizzare uno qualsiasi dei dati della richiesta, effettua le seguenti sostituzioni:

  • LOCATION_ID: l'area geografica del tuo progetto.
  • PROJECT_ID: il tuo ID progetto.
  • TRAINING_PIPELINE_NAME: campo obbligatorio. Un nome visualizzato per la pipelinePipe training.
  • Se la tua applicazione di addestramento utilizza un set di dati Vertex AI, specifica quanto segue:
    • DATASET_ID: l'ID del set di dati.
    • ANNOTATIONS_FILTER: filtra il set di dati in base alle annotazioni specificate.
    • ANNOTATION_SCHEMA_URI: filtra il set di dati in base all'URI dello schema di annotazione specificato.
    • Utilizza una delle seguenti opzioni per specificare la modalità di suddivisione degli elementi di dati in set di addestramento, convalida e test.
      • Per suddividere il set di dati in base a frazioni che definiscono le dimensioni di ogni set, specifica quanto segue:
        • TRAINING_FRACTION: la frazione del set di dati da utilizzare per addestrare il modello.
        • VALIDATION_FRACTION: la frazione del set di dati da utilizzare per convalidare il modello.
        • TEST_FRACTION: la frazione del set di dati da utilizzare per valutare il modello.
      • Per suddividere il set di dati in base ai filtri, specifica quanto segue:
        • TRAINING_FILTER: filtra il set di dati in base agli elementi dati da utilizzare per l'addestramento del modello.
        • VALIDATION_FILTER: filtra il set di dati in base agli elementi dati da utilizzare per la convalida del modello.
        • TEST_FILTER: filtra il set di dati in base agli elementi di dati da utilizzare per valutare il modello.
      • Per utilizzare una suddivisione predefinita, specifica quanto segue:
        • PREDEFINED_SPLIT_KEY: il nome della colonna da utilizzare per suddividere il set di dati. I valori accettabili in questa colonna includono "addestramento", "convalida" e "test".
      • Per suddividere il set di dati in base al timestamp sugli elementi di dati, specifica quanto segue:
        • TIMESTAMP_TRAINING_FRACTION: la frazione del set di dati da utilizzare per addestrare il modello.
        • TIMESTAMP_VALIDATION_FRACTION: la frazione del set di dati da utilizzare per convalidare il modello.
        • TIMESTAMP_TEST_FRACTION: la frazione del set di dati da utilizzare per valutare il modello.
        • TIMESTAMP_SPLIT_KEY: il nome della colonna timestamp da utilizzare per suddividere il set di dati.
    • OUTPUT_URI_PREFIX: la località di Cloud Storage in cui Vertex AI esporta il set di dati di addestramento, una volta suddiviso in set di addestramento, convalida e test.
  • Specifica il tuo job di ottimizzazione degli iperparametri:
    • Specifica le metriche:
      • METRIC_ID: il nome di questa metrica.
      • METRIC_GOAL: l'obiettivo di questa metrica. Può essere MAXIMIZE o MINIMIZE.
    • Specifica gli iperparametri:
      • PARAMETER_ID: il nome di questo iperparametro.
      • (Facoltativo) PARAMETER_SCALE: Indica come ridimensionare il parametro. Non impostare i parametri CATEGORICI. Può essere UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE o SCALE_TYPE_UNSPECIFIED
      • Se questo iperparametro è di tipo DOUBLE, specifica i valori minimo (DOUBLE_MIN_VALUE) e massimo (DOUBLE_MAX_VALUE).
      • Se questo tipo di iperparametro è INTEGER, specifica i valori minimo (INTEGER_MIN_VALUE) e massimo (INTEGER_MAX_VALUE) per questo iperparametro.
      • Se questo tipo di iperparametro è CATEGORICO, specifica i valori accettabili (CATEGORICAL_VALUES) come array di stringhe.
      • Se questo tipo di iperparametro è DISCRETE, specifica i valori accettabili (DISCRETE_VALUES) come array di numeri.
    • (Facoltativo) ALGORITHM: L'algoritmo di ricerca da utilizzare in questo job di ottimizzazione degli iperparametri. Può essere ALGORITHM_UNSPECIFIED, GRID_SEARCH o RANDOM_SEARCH.
    • MAX_TRIAL_COUNT: il numero massimo di prove da eseguire in questo job.
    • PARALLEL_TRIAL_COUNT: il numero massimo di prove che possono essere eseguite in parallelo.
    • MAX_FAILED_TRIAL_COUNT: numero di job che non possono riuscire prima dell'esecuzione del job di ottimizzazione degli iperparametri.
    • Definisci il job di addestramento personalizzato di prova:
      • MACHINE_TYPE: il tipo di macchina. Fai riferimento ai tipi di macchine disponibili per l'addestramento.
      • (Facoltativo) ACCELERATOR_TYPE: Il tipo di acceleratore da collegare a ciascuna prova.
      • (Facoltativo) ACCELERATOR_COUNT: Il numero di acceleratori da collegare a ciascuna prova.
      • REPLICA_COUNT: il numero di repliche di worker da utilizzare per ogni prova.
      • Se la tua applicazione di addestramento viene eseguita in un container personalizzato, specifica quanto segue:
        • CUSTOM_CONTAINER_IMAGE_URI: URI di un'immagine container in Artifact Registry, Container Registry o Docker Hub da eseguire su ogni replica worker.
        • (Facoltativo) CUSTOM_CONTAINER_COMMAND: Il comando da richiamare all'avvio del container. Questo comando sostituisce il punto di accesso predefinito del container.
        • (Facoltativo) CUSTOM_CONTAINER_ARGS: Gli argomenti da trasmettere all'avvio del container.
      • Se la tua applicazione di addestramento è un pacchetto Python eseguito in un container predefinito, specifica quanto segue:
        • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: URI dell'immagine container che esegue il pacchetto Python fornito. Fai riferimento ai container predefiniti disponibili per l'addestramento.
        • PYTHON_PACKAGE_URIS: la posizione Cloud Storage dei file del pacchetto Python che sono il programma di addestramento e i relativi pacchetti dipendenti. Il numero massimo di URI di pacchetto è 100.
        • PYTHON_MODULE: il nome del modulo Python da eseguire dopo l'installazione dei pacchetti.
        • (Facoltativo) PYTHON_PACKAGE_ARGS: Argomenti della riga di comando da trasmettere al modulo Python.
    • Informazioni sulle opzioni di pianificazione del lavoro.
    • (Facoltativo) TIMEOUT: La durata massima di ciascuna prova.
    • Specifica LABEL_NAME e LABEL_VALUE per tutte le etichette che vuoi applicare a questo job di ottimizzazione degli iperparametri.
  • MODEL_NAME: nome visualizzato per il modello caricato (creato) dalla TrainingPipeline.
  • MODEL_DESCRIPTION: facoltativo. Una descrizione del modello.
  • PREDICTION_IMAGE_URI: campo obbligatorio. Specifica una delle due opzioni seguenti:
  • modelToUpload.labels: facoltativo. Qualsiasi insieme di coppie chiave-valore per organizzare i modelli. Ad esempio:
    • "env": "prod"
    • "tier": "backend"
  • Specifica LABEL_NAME e LABEL_VALUE per tutte le etichette che vuoi applicare a questa pipeline di addestramento.

Metodo HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines

Corpo JSON richiesta:

{
  "displayName": "TRAINING_PIPELINE_NAME",
  "inputDataConfig": {
    "datasetId": DATASET_ID,
    "annotationsFilter": ANNOTATIONS_FILTER,
    "annotationSchemaUri": ANNOTATION_SCHEMA_URI,

    // Union field split can be only one of the following:
    "fractionSplit": {
      "trainingFraction": TRAINING_FRACTION,
      "validationFraction": VALIDATION_FRACTION,
      "testFraction": TEST_FRACTION
    },
    "filterSplit": {
      "trainingFilter": TRAINING_FILTER,
      "validationFilter": VALIDATION_FILTER,
      "testFilter": TEST_FILTER
    },
    "predefinedSplit": {
      "key": PREDEFINED_SPLIT_KEY
    },
    "timestampSplit": {
      "trainingFraction": TIMESTAMP_TRAINING_FRACTION,
      "validationFraction": TIMESTAMP_VALIDATION_FRACTION,
      "testFraction": TIMESTAMP_TEST_FRACTION,
      "key": TIMESTAMP_SPLIT_KEY
    }
    // End of list of possible types for union field split.
    "gcsDestination": {
      "outputUriPrefix": OUTPUT_URI_PREFIX
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/hyperparameter_tuning_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "studySpec": {
    "metrics": [
      {
        "metricId": METRIC_ID,
        "goal": METRIC_GOAL
      }
    ],
    "parameters": [
      {
        "parameterId": PARAMETER_ID,
        "scaleType": PARAMETER_SCALE,

        // Union field parameter_value_spec can be only one of the following:
        "doubleValueSpec": {
            "minValue": DOUBLE_MIN_VALUE,
            "maxValue": DOUBLE_MAX_VALUE
        },
        "integerValueSpec": {
            "minValue": INTEGER_MIN_VALUE,
            "maxValue": INTEGER_MAX_VALUE
        },
        "categoricalValueSpec": {
            "values": [
              CATEGORICAL_VALUES
            ]
        },
        "discreteValueSpec": {
            "values": [
              DISCRETE_VALUES
            ]
        }
        // End of list of possible types for union field parameter_value_spec.
      }
    ],
    "ALGORITHM": ALGORITHM
  },
  "maxTrialCount": MAX_TRIAL_COUNT,
  "parallelTrialCount": PARALLEL_TRIAL_COUNT,
  "maxFailedTrialCount": MAX_FAILED_TRIAL_COUNT,
  "trialJobSpec": {
      "workerPoolSpecs": [
        {
          "machineSpec": {
            "machineType": MACHINE_TYPE,
            "acceleratorType": ACCELERATOR_TYPE,
            "acceleratorCount": ACCELERATOR_COUNT
          },
          "replicaCount": REPLICA_COUNT,

          // 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": PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,
            "packageUris": [
              PYTHON_PACKAGE_URIS
            ],
            "pythonModule": PYTHON_MODULE,
            "args": [
              PYTHON_PACKAGE_ARGS
            ]
          }
          // End of list of possible types for union field task.
        }
      ],
      "scheduling": {
        "TIMEOUT": TIMEOUT
      }
    },
    "labels": {
      LABEL_NAME_1": LABEL_VALUE_1,
      LABEL_NAME_2": LABEL_VALUE_2
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "description": "MODEL_DESCRIPTION",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "PREDICTION_IMAGE_URI"
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

Curling

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

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

PowerShell

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

$cred = gcloud auth application-default 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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

La risposta contiene informazioni sulle specifiche e sull'TRAININGPIPELINE_ID.

Monitora addestramento

Per visualizzare i log di addestramento:

  1. Nella sezione Vertex AI, in Google Cloud Console, vai alla pagina Formazione.

    Vai alla pagina Formazione

  2. Fai clic sul nome del job per passare alla pagina di Job personalizzato.

  3. Fai clic su Visualizza i log.

Puoi anche utilizzare una shell interattiva per ispezionare i container di addestramento mentre la pipeline di addestramento è in esecuzione.

Visualizza il tuo modello addestrato

Al termine del completamento della pipeline di addestramento personalizzato, puoi trovare il modello addestrato in Google Cloud Console, nella sezione Vertex AI, alla pagina Modelli.

Vai alla pagina Modelli

Passaggi successivi