Creazione pipeline di addestramento

Console

1. Nella console Google Cloud, nella sezione Vertex AI, 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. Se vuoi utilizzare un set di dati gestito per la formazione, 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 contenuto 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. Utilizza gli elenchi a discesa Framework modello e Versione framework modello per specificare il container predefinito da utilizzare.

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

        3. Nel campo Modulo Python, inserisci il nome del modulo dell'entry point della tua applicazione di addestramento.

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

   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 passato a Vertex AI nel campo baseOutputDirectory API, che imposta diverse variabili di ambiente a cui la tua applicazione di addestramento può accedere quando viene eseguita.

      Al termine dell'addestramento, Vertex AI cerca gli elementi 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, Vertex AI si aspetta di trovare gli elementi del modello in BASE_OUTPUT_DIRECTORY/model/.

   4. Facoltativo: nel campo Argomenti, puoi specificare gli argomenti da utilizzare da parte di Vertex AI quando inizia a eseguire il 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 contenitore utilizzato:

      • Se utilizzi un contenitore predefinito, Vertex AI trasmette gli argomenti come flag a riga di comando al modulo Python.

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

   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 Computing e prezzi, specifica le seguenti impostazioni:

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

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

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

      Se vuoi eseguire l'addestramento distribuito, fai clic su Aggiungi altri pool di worker e specifica un altro insieme di risorse di calcolo per ogni altro pool di worker 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 contenuto personalizzato per fornire le previsioni del modello addestrato.

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

      • Se vuoi utilizzare un container predefinito per fornire le previsioni, usa i campi Framework del modello, Versione del framework del modello e Tipo di acceleratore per scegliere il container di previsione predefinito da utilizzare per la previsione.

        Abbina Framework modello e Versione framework modello al framework di machine learning utilizzato per l'addestramento. Specifica un tipo di acceleratore solo se in un secondo momento vuoi utilizzare le GPU per le previsioni online o batch.

      • Se vuoi utilizzare un container personalizzato per fornire le previsioni, svolgi i seguenti passaggi:

        1. Nel campo Immagine container, specifica l'URI di Artifact Registry dell'immagine container.

        2. Se vuoi, puoi specificare un comando per sostituire l'ENTRYPOINT istruzione del contenitore.

   3. Il campo Model directory (Directory del modello) contiene il valore impostato in precedenza nel campo Model output directory (Directory di output del modello) del passaggio Training container (Contenitore 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 della sezione Predici schemata.

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

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, se vuoi puoi aggiungere PARENT_MODEL nel campo trainingPipeline.

Per scoprire di più, consulta Controllo delle versioni dei modelli con Vertex AI Model Registry.

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

• LOCATION_ID: la regione in cui viene eseguito il codice di addestramento e in cui viene memorizzato Model.
• PROJECT_ID: l'ID del tuo progetto.
• TRAINING_PIPELINE_NAME: obbligatorio. Un nome visualizzato per trainingPipeline.
• Se l'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 in che modo gli elementi dati vengono suddivisi in set di addestramento, convalida e test.
    • Per suddividere il set di dati in base a frazioni che definiscono le dimensioni di ciascun insieme, 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 di dati da utilizzare per l'addestramento del modello.
      • VALIDATION_FILTER: filtra il set di dati in base agli elementi di dati da utilizzare per convalidare il 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 "training", "validation" e "test".
    • Per suddividere il set di dati in base al timestamp degli elementi 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 Vertex AI esporta il set di dati di addestramento, dopo averlo suddiviso in set di addestramento, convalida e test.
• 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 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 contenitore 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 del worker.
    • CUSTOM_CONTAINER_COMMAND: (facoltativo) Il comando da richiamare all'avvio del container. Questo comando sostituisce l'entrypoint predefinito del container.
    • CUSTOM_CONTAINER_ARGS: (facoltativo) Gli argomenti da passare all'avvio del container. La lunghezza massima per tutti gli argomenti combinati è di 100.000 caratteri.
  • Se l'applicazione di addestramento è un pacchetto Python che viene eseguito in un container predefinito, specifica quanto segue:
    • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: l'URI dell'immagine del container che esegue il pacchetto Python fornito. Consulta 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 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. La lunghezza massima per tutti gli argomenti combinati è di 100.000 caratteri.
  • TIMEOUT: (facoltativo) Il tempo di esecuzione massimo del job.
• MODEL_NAME: un nome visualizzato per il modello caricato (creato) da TrainingPipeline.
• MODEL_DESCRIPTION: una descrizione del modello.
• IMAGE_URI: l'URI dell'immagine del container da utilizzare per eseguire le 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 eventuali etichette da 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 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 \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines"

$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.

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines/TRAININGPIPELINE_ID",
  "displayName": "TRAINING_PIPELINE_NAME",
  "input_data_config" {
    "dataset_id": "1234567891011121314"
    "gcs_destination" {
      "output_uri_prefix": "gs://BUCKET_NAME/data/20200915191342"
    }
    "annotation_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/annotation/image_classification_1.0.0.yaml"
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "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/"
          ]
        }
      }
    ]
  },
  "trainingTaskMetadata": {
    "backingCustomJob": "projects/PROJECT_ID/locations/LOCATION_ID/customJobs/CUSTOM_JOB_ID"
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest"
    }
  },
  "state": "PIPELINE_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 Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Vertex AI.

Per autenticarti a 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.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 per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

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

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

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

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

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 seguenti sostituzioni:

• LOCATION_ID: la regione del progetto.
• PROJECT_ID: l'ID del tuo progetto.
• TRAINING_PIPELINE_NAME: obbligatorio. Un nome visualizzato per trainingPipeline.
• Se l'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 in che modo gli elementi dati vengono suddivisi in set di addestramento, convalida e test.
    • Per suddividere il set di dati in base a frazioni che definiscono le dimensioni di ciascun insieme, 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 di dati da utilizzare per l'addestramento del modello.
      • VALIDATION_FILTER: filtra il set di dati in base agli elementi di dati da utilizzare per convalidare il 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 "training", "validation" e "test".
    • Per suddividere il set di dati in base al timestamp degli elementi 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 Vertex AI esporta il set di dati di addestramento dopo averlo 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: lo scopo di questa metrica. Può essere MAXIMIZE o MINIMIZE.
  • Specifica gli iperparametri:
    • PARAMETER_ID: il nome di questo iperparametro.
    • PARAMETER_SCALE: (facoltativo) La modalità di applicazione della scala al 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 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. Consulta i tipi di macchine 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 contenitore 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 del worker.
      • CUSTOM_CONTAINER_COMMAND: (facoltativo) Il comando da richiamare all'avvio del container. Questo comando sostituisce l'entrypoint predefinito del container.
      • CUSTOM_CONTAINER_ARGS: (facoltativo) Gli argomenti da passare all'avvio del container.
    • Se l'applicazione di addestramento è un pacchetto Python che viene eseguito in un container predefinito, specifica quanto segue:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: l'URI dell'immagine del container che esegue il pacchetto Python fornito. Consulta 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 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 dei job.
  • TIMEOUT: (facoltativo) Il tempo di esecuzione massimo per ogni prova.
  • Specifica LABEL_NAME e LABEL_VALUE per le eventuali etichette che vuoi applicare a questo job di ottimizzazione degli iperparametri.
• MODEL_NAME: un nome visualizzato per il modello caricato (creato) da TrainingPipeline.
• MODEL_DESCRIPTION: facoltativo. Una descrizione del modello.
• PREDICTION_IMAGE_URI: obbligatorio. Specifica una delle due seguenti opzioni:
  • L'URI dell'immagine del container predefinito da utilizzare per la previsione, ad esempio "tf2-cpu.2-1:latest".
  • L'URI immagine del tuo container personalizzato da utilizzare per la previsione.
• 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 eventuali etichette da 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 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 \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines"

$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.

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines/TRAININGPIPELINE_ID",
  "displayName": "TRAINING_PIPELINE_NAME",
  "input_data_config" {
    "dataset_id": "1234567891011121314"
    "gcs_destination" {
      "output_uri_prefix": "gs://BUCKET_NAME/data/20200915191342"
    }
    "annotation_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/annotation/image_classification_1.0.0.yaml"
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "name": "projects/12345/locations/us-central1/hyperparameterTuningJobs/6789",
  "displayName": "myHyperparameterTuningJob",
  "studySpec": {
    "metrics": [
      {
        "metricId": "myMetric",
        "goal": "MINIMIZE"
      }
    ],
    "parameters": [
      {
        "parameterId": "myParameter1",
        "integerValueSpec": {
          "minValue": "1",
          "maxValue": "128"
        },
        "scaleType": "UNIT_LINEAR_SCALE"
      },
      {
        "parameterId": "myParameter2",
        "doubleValueSpec": {
          "minValue": 1e-07,
          "maxValue": 1
        },
        "scaleType": "UNIT_LINEAR_SCALE"
      }
    ],
    "ALGORITHM": "RANDOM_SEARCH"
  },
  "maxTrialCount": 20,
  "parallelTrialCount": 1,
  "trialJobSpec": {
    "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://my-bucket/my-training-application/trainer.tar.bz2"
          ],
          "pythonModule": "my-trainer.trainer"
        }
      }
    ]
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}