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 l'addestramento, quindi specifica un set di dati Set di annotazioni.

      In caso contrario, nell'elenco a discesa Set di dati, seleziona Nessuna del set di dati.

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

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

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

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

      • Se vuoi usare un container predefinito per l'addestramento, Vertex AI con le informazioni necessarie per utilizzare l'addestramento caricato su Cloud Storage:

        1. Utilizza il framework modello e la versione del framework modello elenchi a discesa per specificare la container che vuoi per gli utilizzi odierni.

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

        3. Nel campo del modulo Python, inserisci il nome del modulo del tuo voce dell'applicazione di addestramento punto di accesso.

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

   3. Nel campo Directory di output del modello, specificare l'URI Cloud Storage di una directory in al bucket a cui hai accesso. Non è necessario che la directory esista ancora.

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

      Al termine dell'addestramento, Vertex AI cerca il modello artefatti 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 un iperparametro dell'ottimizzazione, Vertex AI si aspetta di trovare gli artefatti BASE_OUTPUT_DIRECTORY/model/.

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

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

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

   Fai clic su Continua.

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

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

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

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

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

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

   Fai clic su Continua.

8. Nel passaggio Container di previsione, specifica quanto segue. impostazioni:

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

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

      • Se vuoi utilizzare un container predefinito per fornire previsioni, utilizzare il framework modello, la versione del framework modello e Campi Tipo di acceleratore per scegliere quale previsione predefinita container da usare per la previsione.

        Abbina Framework modello e Versione framework modello alla il framework di machine learning usato per l'addestramento. Specifica solo un Tipo di acceleratore se in un secondo momento vuoi utilizzare GPU per le applicazioni online o previsioni batch.

      • Se vuoi utilizzare un container personalizzato per pubblicare le previsioni, le seguenti:

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

        2. Facoltativamente, puoi specificare un Comando per eseguire l'override ENTRYPOINT del container istruzioni.

   3. Il campo Directory modello contiene il valore impostato in precedenza Nel campo Directory di output del modello del Container di addestramento passaggio. La modifica di uno di questi campi ha lo stesso effetto. Consulta le istruzione precedente per visualizzare informazioni su questo campo.

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

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

REST

Usa il seguente esempio di codice per creare una pipeline di addestramento utilizzando 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ù, vedi Controllo delle versioni dei modelli con Vertex AI Model Registry.

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

• LOCATION_ID: la regione in cui viene eseguito il codice di addestramento e Model viene archiviato.
• PROJECT_ID: l'ID progetto.
• TRAINING_PIPELINE_NAME: campo 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 che specificare.
  • ANNOTATION_SCHEMA_URI: filtra il set di dati in base all'annotazione specificata URI dello schema.
  • Utilizza una delle seguenti opzioni per specificare in che modo gli elementi di dati vengono suddivisi in addestramento, di convalida e test.
    • Per suddividere il set di dati in base alle frazioni che definiscono la dimensione di ogni insieme, specifica le seguenti:
      • TRAINING_FRACTION: la frazione del set di dati da utilizzare per addestrare model.
      • VALIDATION_FRACTION: la frazione del set di dati da utilizzare per la convalida del modello.
      • TEST_FRACTION: la frazione del set di dati da utilizzare per valutare del 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 e convalidare il modello.
      • TEST_FILTER: filtra il set di dati in base agli elementi di dati da utilizzare per la valutazione del modello.
    • Per utilizzare una suddivisione predefinita, specifica quanto segue:
      • PREDEFINED_SPLIT_KEY: il nome della colonna da utilizzare per la suddivisione del set di dati. I valori accettati in questa colonna includono "addestramento", "convalida" 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 del modello.
      • TIMESTAMP_SPLIT_KEY: il nome della colonna del timestamp da utilizzare per la suddivisione del set di dati.
  • OUTPUT_URI_PREFIX: la località di Cloud Storage in cui Vertex AI esporta il set di dati di addestramento, dopo averlo suddiviso in set di dati.
• Definisci il job di addestramento personalizzato:
  • MACHINE_TYPE: tipo di macchina. Invita ai tipi di macchine disponibili per l'addestramento.
  • ACCELERATOR_TYPE: (facoltativo) Il tipo di acceleratore da associare a ogni Google Cloud.
  • ACCELERATOR_COUNT: (facoltativo) Il numero di acceleratori a cui associarsi ogni prova.
  • REPLICA_COUNT: il numero di repliche dei worker da usare 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, Container Registry o Docker Hub da eseguire su ciascun worker replica.
    • CUSTOM_CONTAINER_COMMAND: (facoltativo) Il comando da richiamare quando container. Questo comando esegue l'override dell'entry point predefinito del container.
    • CUSTOM_CONTAINER_ARGS: (facoltativo) Gli argomenti da passare quando avviando il container. La lunghezza massima di tutti gli argomenti combinati è 100.000 caratteri.
  • Se l'applicazione di addestramento è un pacchetto Python eseguito in un container predefinito, specificare quanto segue:
    • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: l'URI dell'immagine container che esegue pacchetto Python fornito. Consulta le di container predefiniti disponibili addestramento.
    • PYTHON_PACKAGE_URIS: la località di Cloud Storage del file Python dei pacchetti, ovvero il programma di addestramento e i pacchetti dipendenti. Il valore massimo di URI dei pacchetti è pari a 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 il modulo Python. La lunghezza massima di tutti gli argomenti combinati è 100.000 caratteri.
  • TIMEOUT: (facoltativo) Il tempo di esecuzione massimo per il 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 container da utilizzare per eseguendo previsioni. Ad esempio: us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Utilizza le funzionalità di container predefiniti o container personalizzati.
• modelToUpload.labels: qualsiasi insieme di coppie chiave/valore per organizzare di grandi dimensioni. Ad esempio:
  • "env": "prod"
  • "tier": "backend"
• Specifica LABEL_NAME e LABEL_VALUE per tutte le etichette che vuoi si applicano 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 sulla 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 per la configurazione di Java nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Java Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 per Python, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta documentazione di riferimento dell'API Python.

I seguenti esempi mostrano come utilizzare il parametro SDK Vertex AI per Python per creare un addestramento personalizzato una pipeline o un blocco note personalizzato. Scegli se utilizzare una un container predefinito o container 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

Usa il seguente esempio di codice per creare una pipeline di addestramento mediante Metodo create della risorsa trainingPipeline.

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

• LOCATION_ID: la regione del tuo progetto.
• PROJECT_ID: l'ID progetto.
• TRAINING_PIPELINE_NAME: campo 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 che specificare.
  • ANNOTATION_SCHEMA_URI: filtra il set di dati in base all'annotazione specificata URI dello schema.
  • Utilizza una delle seguenti opzioni per specificare in che modo gli elementi di dati vengono suddivisi in addestramento, di convalida e test.
    • Per suddividere il set di dati in base alle frazioni che definiscono la dimensione di ogni insieme, specifica le seguenti:
      • TRAINING_FRACTION: la frazione del set di dati da utilizzare per addestrare model.
      • VALIDATION_FRACTION: la frazione del set di dati da utilizzare per la convalida del modello.
      • TEST_FRACTION: la frazione del set di dati da utilizzare per valutare del 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 e convalidare il modello.
      • TEST_FILTER: filtra il set di dati in base agli elementi di dati da utilizzare per la valutazione del modello.
    • Per utilizzare una suddivisione predefinita, specifica quanto segue:
      • PREDEFINED_SPLIT_KEY: il nome della colonna da utilizzare per la suddivisione del set di dati. I valori accettati in questa colonna includono "addestramento", "convalida" 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 del modello.
      • TIMESTAMP_SPLIT_KEY: il nome della colonna del timestamp da utilizzare per la suddivisione del set di dati.
  • OUTPUT_URI_PREFIX: la località di Cloud Storage in cui Vertex AI esporta il set di dati di addestramento, dopo essere stato suddiviso in set di dati.
• 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.
    • PARAMETER_SCALE: (facoltativo) Come deve essere scalato il parametro. Non impostare 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 è DOPPIO, specifica il numero minimo (DOUBLE_MIN_VALUE) e massimi (DOUBLE_MAX_VALUE) per questo iperparametro.
    • Se il tipo di questo iperparametro è INTEGER, specifica il numero minimo (INTEGER_MIN_VALUE) e massimo (INTEGER_MAX_VALUE) per per questo iperparametro.
    • Se il tipo di questo iperparametro è CATEGORICO, 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 questa ottimizzazione degli iperparametri un lavoro. 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 avere esito negativo prima dell'iperparametro il job di ottimizzazione non riesce.
  • Definisci il job di addestramento personalizzato di prova:
    • MACHINE_TYPE: tipo di macchina. Consulta le tipi di macchine disponibili per l'addestramento.
    • ACCELERATOR_TYPE: (facoltativo) Il tipo di acceleratore da associare a ogni Google Cloud.
    • ACCELERATOR_COUNT: (facoltativo) Il numero di acceleratori a cui associarsi ogni prova.
    • REPLICA_COUNT: il numero di repliche dei worker da usare 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, Container Registry o Docker Hub da eseguire su ciascun worker replica.
      • CUSTOM_CONTAINER_COMMAND: (facoltativo) Il comando da richiamare quando il container in esecuzione. Questo comando esegue l'override dell'entry point predefinito del container.
      • CUSTOM_CONTAINER_ARGS: (facoltativo) Gli argomenti da passare quando avviando il container.
    • Se l'applicazione di addestramento è un pacchetto Python eseguito in un container predefinito, specificare quanto segue:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: l'URI dell'immagine container che esegue pacchetto Python fornito. Consulta le di container predefiniti disponibili addestramento.
      • PYTHON_PACKAGE_URIS: la località di Cloud Storage del file Python dei pacchetti, ovvero il programma di addestramento e i pacchetti dipendenti. Il valore massimo di URI dei pacchetti è pari a 100.
      • PYTHON_MODULE: il nome del modulo Python da eseguire dopo l'installazione del pacchetti.
      • PYTHON_PACKAGE_ARGS: (facoltativo) Argomenti della riga di comando da passare il modulo Python.
  • Scopri di più sulle opzioni di pianificazione dei job.
  • TIMEOUT: (facoltativo) Il tempo di esecuzione massimo per ogni prova.
  • Specifica LABEL_NAME e LABEL_VALUE per tutte le etichette che vuoi da 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: campo obbligatorio. Specifica una delle due opzioni seguenti:
  • L'URI dell'immagine di container predefinito per la previsione, ad esempio "tf2-cpu.2-1:latest".
  • L'URI dell'immagine del tuo container personalizzato da utilizzare per la previsione.
• modelToUpload.labels: facoltativo. Qualsiasi insieme di coppie chiave-valore per organizzare i tuoi modelli. Ad esempio:
  • "env": "prod"
  • "tier": "backend"
• Specifica LABEL_NAME e LABEL_VALUE per tutte le etichette che vuoi si applicano 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 sulla 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",
}