Creazione pipeline di addestramento

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

Se l'attività prevede solo l'esecuzione di un job di addestramento e la creazione automatica di una risorsa del modello senza orchestrare un workflow completo, potrebbe essere sufficiente utilizzare una pipeline di addestramento autonoma, come descritto in questo documento. Tuttavia, se il tuo obiettivo è creare un ciclo di vita ML end-to-end solido, automatizzato e ripetibile che prevede più passaggi (come trattamento dati, addestramento, valutazione, deployment o monitoraggio), Gemini Enterprise Agent Platform Pipelines è l'approccio consigliato, poiché è progettato per l'orchestrazione del workflow.

Prima di creare una pipeline

Prima di creare una pipeline di addestramento su Agent Platform, devi creare un'applicazione di addestramento Python o un container personalizzato per definire il codice di addestramento e le dipendenze che vuoi eseguire su Agent Platform. Se crei un'applicazione di addestramento Python utilizzando PyTorch, 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 della pipeline di addestramento

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

  • Avvia un CustomJob e carica il modello risultante su Agent Platform
  • Avvia un job di ottimizzazione degli iperparametri e carica il modello risultante su Agent Platform

Inoltre, puoi utilizzare 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 di cui ha bisogno Agent Platform per eseguire il codice di addestramento, tra cui:

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

Se vuoi creare un job personalizzato autonomo al di fuori di una pipeline di Vertex AI Training, consulta la guida ai job personalizzati.

Configura la pipeline per utilizzare un set di dati gestito

All'interno della pipeline di addestramento, puoi configurare il job di addestramento serverless o il job di ottimizzazione degli iperparametri in modo che utilizzi un set di dati gestito. I set di dati gestiti ti 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 saperne di più, consulta In che modo Agent Platform passa il 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 regione in cui hai creato il set di dati.

Per saperne di più, consulta il riferimento API su TrainingPipeline.

Configura l'addestramento distribuito

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

Tutti gli esempi in questa pagina mostrano job di addestramento con una singola replica e un pool di worker. Per modificarli 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 di worker, repliche di server dei parametri o repliche di valutatori, se il tuo framework di machine learning supporta queste attività aggiuntive del cluster per l'addestramento distribuito.

Scopri di più sull'utilizzo dell'addestramento distribuito.

Job personalizzato e caricamento del modello

Questa pipeline di addestramento incapsula un job personalizzato con un passaggio aggiuntivo che semplifica il deployment del modello su Agent Platform dopo l'addestramento. Questa pipeline di addestramento esegue due operazioni principali:

  1. La pipeline di addestramento crea una risorsa CustomJob. Il job personalizzato esegue l'applicazione di addestramento utilizzando le risorse di computing 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 modello, che ti prepara per il deployment del modello.

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

  • Se imposti un 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 Agent Platform. Al termine del job di addestramento, Agent Platform 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 quell'URI. Devi impostare questo campo se non hai impostato baseOutputDirectory.

Se specifichi sia baseOutputDirectory che modelToUpload.artifactUri, Agent Platform utilizza modelToUpload.artifactUri.

Per creare questo tipo di pipeline di addestramento:

Console

  1. Nella console Google Cloud , nella sezione Agent Platform, 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. Se vuoi utilizzare un set di dati gestito per l'addestramento, specifica un set di dati e un set di annotazioni.

      In caso contrario, 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. Seleziona se utilizzare un container predefinito o un container personalizzato per l'addestramento.

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

    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 necessariamente esistere già.

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

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

      Quando non utilizzi l'ottimizzazione degli iperparametri, Agent Platform prevede di trovare gli artefatti del modello in BASE_OUTPUT_DIRECTORY/model/.

    4. Facoltativo: nel campo Argomenti, puoi specificare gli argomenti che Agent Platform deve 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 container che utilizzi:

    Fai clic su Continua.

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

  7. Nel passaggio Compute 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 computing da utilizzare per l'addestramento.

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

      Se vuoi eseguire l'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, specifica le seguenti impostazioni:

    1. Seleziona se utilizzare un container predefinito o un container personalizzato per fornire previsioni dal modello addestrato.

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

    3. Il campo Directory del modello contiene il valore impostato in precedenza nel campo Directory di output del modello del passaggio Container di addestramento. La modifica di uno di questi campi ha lo stesso effetto. Per ulteriori informazioni su questo campo, consulta l'istruzione precedente.

    4. Lascia vuoti i campi nella sezione Predict schemata (Schemi di previsione).

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

REST

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

Nota: se vuoi impostare questa pipeline per creare una nuova versione del modello, puoi aggiungere facoltativamente PARENT_MODEL nel campo trainingPipeline.

Per saperne di più, consulta Controllo delle versioni dei modelli con Model Registry di Gemini Enterprise Agent Platform.

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

  • LOCATION_ID: la regione in cui viene eseguito il codice di addestramento e in cui viene archiviato Model.
  • PROJECT_ID: il tuo ID progetto.
  • TRAINING_PIPELINE_NAME: obbligatorio. Un nome visualizzato per la pipeline di addestramento.
  • Se l'applicazione di addestramento utilizza un set di dati Agent Platform, 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 in che modo gli elementi dati vengono suddivisi in set di addestramento, convalida e test.
      • Per suddividere il set di dati in base alle frazioni che definiscono le dimensioni di ciascun 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 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 accettati in questa colonna includono "training", "validation" e "test".
      • Per suddividere il set di dati in base al timestamp degli 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 del timestamp da utilizzare per suddividere il set di dati.
    • OUTPUT_URI_PREFIX: la posizione di Cloud Storage in cui Agent Platform esporta il set di dati di addestramento, dopo che è stato suddiviso in set di addestramento, convalida e test.
  • Definisci il job di addestramento personalizzato:
    • MACHINE_TYPE: il tipo di macchina. Scopri quali sono i tipi di macchina disponibili per l'addestramento.
    • ACCELERATOR_TYPE: (Facoltativo) Il tipo di acceleratore da collegare a ogni prova.
    • ACCELERATOR_COUNT: (Facoltativo) Il numero di acceleratori da collegare a ogni prova.
    • REPLICA_COUNT: il numero di repliche dei worker da utilizzare per ogni prova.
    • 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 o Docker Hub da eseguire su ogni replica worker.
      • CUSTOM_CONTAINER_COMMAND: (Facoltativo) Il comando da richiamare all'avvio del container. Questo comando esegue l'override dell'entrypoint predefinito del container.
      • CUSTOM_CONTAINER_ARGS: (Facoltativo) Gli argomenti da passare all'avvio del container. La lunghezza massima di tutti gli argomenti combinati è di 100.000 caratteri.
    • Se la tua applicazione di addestramento è un pacchetto Python eseguito in un container predefinito, specifica quanto segue:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: l'URI dell'immagine container che esegue il pacchetto Python fornito. Scopri quali sono i container predefiniti disponibili per l'addestramento.
      • PYTHON_PACKAGE_URIS: la posizione in Cloud Storage dei file del pacchetto Python, ovvero il programma di addestramento e i rispettivi 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. La lunghezza massima di tutti gli argomenti combinati è di 100.000 caratteri.
    • TIMEOUT: (Facoltativo) Il tempo di esecuzione massimo per il job.
  • MODEL_NAME: un nome visualizzato per il modello caricato (creato) dalla pipeline di addestramento.
  • 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 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 della 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 di queste opzioni:

curl

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

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth 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, quindi esegui il comando seguente: 

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

La risposta contiene informazioni sulle specifiche e sul TRAININGPIPELINE_ID.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Agent Platform per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Agent Platform Java.

Per eseguire l'autenticazione in Agent Platform, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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");

      // A working docker image can be found at
      // gs://cloud-samples-data/ai-platform/mnist_tfrecord/custom_job
      // This sample image accepts a set of arguments including model_dir.
      JsonObject jsonContainerSpec = new JsonObject();
      jsonContainerSpec.addProperty("imageUri", containerImageUri);
      JsonArray jsonArgs = new JsonArray();
      jsonArgs.add("--model_dir=$(AIP_MODEL_DIR)");
      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 scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installa l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

Gli esempi seguenti mostrano come utilizzare l'SDK Agent Platform per Python per creare una pipeline di addestramento serverless. Scegli se prevedi di utilizzare un container personalizzato o un container predefinito per l'addestramento:

Container predefinito

Quando utilizzi l'SDK Agent Platform per Python per creare una pipeline di addestramento che esegue il tuo codice Python in un container predefinito, puoi fornire il 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 Agent Platform per Python.

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

    Questa opzione è disponibile solo quando utilizzi l'SDK Agent Platform per Python.

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

Pacchetto

L'esempio seguente 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,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    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,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

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

Script

L'esempio seguente 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,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    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,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

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

Container personalizzato

L'esempio seguente 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,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    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,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

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

Job di ottimizzazione degli iperparametri e caricamento del modello

Questa pipeline di addestramento incapsula un job di ottimizzazione degli iperparametri con un passaggio aggiuntivo che semplifica il deployment del modello su Agent Platform dopo l'addestramento. Questa pipeline di addestramento esegue due operazioni principali:

  1. La pipeline di addestramento crea una risorsa job di ottimizzazione degli 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 computing e gli iperparametri specificati.

  2. Al termine del job di ottimizzazione degli iperparametri, la pipeline di addestramento trova 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 modello, che ti prepara per il deployment del modello.

Per questa pipeline di addestramento, devi specificare un baseOutputDirectory in cui Agent Platform cerca gli artefatti del modello della prova migliore.

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

REST

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

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

  • LOCATION_ID: la regione del progetto.
  • PROJECT_ID: il tuo ID progetto.
  • TRAINING_PIPELINE_NAME: obbligatorio. Un nome visualizzato per la pipeline di addestramento.
  • Se l'applicazione di addestramento utilizza un set di dati Agent Platform, 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 in che modo gli elementi dati vengono suddivisi in set di addestramento, convalida e test.
      • Per suddividere il set di dati in base alle frazioni che definiscono le dimensioni di ciascun 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 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 accettati in questa colonna includono "training", "validation" e "test".
      • Per suddividere il set di dati in base al timestamp degli 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 del timestamp da utilizzare per suddividere il set di dati.
    • OUTPUT_URI_PREFIX: la posizione di Cloud Storage in cui Agent Platform esporta il set di dati di addestramento, dopo che è stato suddiviso in set di addestramento, convalida e test.
  • Specifica il 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.
      • PARAMETER_SCALE: (Facoltativo) Come deve essere scalato il parametro. Lascia vuoto per i parametri CATEGORICAL. Può essere UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE o SCALE_TYPE_UNSPECIFIED
      • Se il tipo di questo iperparametro è DOUBLE, specifica i valori minimo (DOUBLE_MIN_VALUE) e massimo (DOUBLE_MAX_VALUE) per questo iperparametro.
      • Se il tipo di questo iperparametro è INTEGER, specifica i valori minimo (INTEGER_MIN_VALUE) e massimo (INTEGER_MAX_VALUE) per questo iperparametro.
      • Se il tipo di questo iperparametro è CATEGORICAL, specifica i valori accettabili (CATEGORICAL_VALUES) come array di stringhe.
      • Se il tipo di questo iperparametro è DISCRETE, specifica i valori accettabili (DISCRETE_VALUES) come un array di numeri.
    • ALGORITHM: (Facoltativo) 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: il numero di job che possono non riuscire prima che il job di ottimizzazione degli iperparametri non riesca.
    • Definisci il job di addestramento personalizzato di prova:
      • MACHINE_TYPE: il tipo di macchina. Scopri quali sono i tipi di macchina disponibili per l'addestramento.
      • ACCELERATOR_TYPE: (Facoltativo) Il tipo di acceleratore da collegare a ogni prova.
      • ACCELERATOR_COUNT: (Facoltativo) Il numero di acceleratori da collegare a ogni prova.
      • REPLICA_COUNT: il numero di repliche dei worker da utilizzare per ogni prova.
      • 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 o Docker Hub da eseguire su ogni replica worker.
        • CUSTOM_CONTAINER_COMMAND: (Facoltativo) Il comando da richiamare all'avvio del container. Questo comando esegue l'override dell'entrypoint predefinito del container.
        • CUSTOM_CONTAINER_ARGS: (Facoltativo) Gli argomenti da passare 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: l'URI dell'immagine container che esegue il pacchetto Python fornito. Scopri quali sono i container predefiniti disponibili per l'addestramento.
        • PYTHON_PACKAGE_URIS: la posizione in Cloud Storage dei file del pacchetto Python, ovvero il programma di addestramento e i rispettivi 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 dei job.
    • TIMEOUT: (Facoltativo) Il tempo di esecuzione massimo per ogni prova.
    • Specifica LABEL_NAME e LABEL_VALUE per le etichette che vuoi applicare a questo job di ottimizzazione degli iperparametri.
  • MODEL_NAME: un nome visualizzato per il modello caricato (creato) dalla pipeline di addestramento.
  • MODEL_DESCRIPTION: (Facoltativo) Una descrizione del modello.
  • PREDICTION_IMAGE_URI: 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 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 della 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 di queste opzioni:

curl

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

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth 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, quindi esegui il comando seguente: 

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

La risposta contiene informazioni sulle specifiche e sul TRAININGPIPELINE_ID.

Monitora l'addestramento

Per visualizzare i log di addestramento:

  1. Nella console Google Cloud , nella sezione Agent Platform, vai alla pagina Addestramento.

    Vai alla pagina Addestramento

  2. Fai clic sul nome del job per andare alla pagina del job personalizzato.

  3. Fai clic su Visualizza log.

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

Visualizza il modello addestrato

Al termine della pipeline di addestramento serverless, puoi trovare il modello addestrato nella console Google Cloud , nella sezione Agent Platform, nella pagina Modelli.

Vai alla pagina Modelli

Passaggi successivi