Créer des tâches d'entraînement personnalisées

Les tâches d'entraînement personnalisées constituent le moyen de base d'exécuter votre code d'entraînement de machine learning (ML) personnalisé dans Vertex AI.

Avant d'envoyer une tâche

Avant d'envoyer une tâche d'entraînement personnalisée à Vertex AI, vous devez créer une application d'entraînement Python ou un conteneur personnalisé pour définir le code d'entraînement et les dépendances que vous voulez exécuter sur l'IA Vertex. Si vous créez une application d'entraînement Python, vous pouvez exécuter votre code à l'aide de nos conteneurs prédéfinis. Si vous ne savez pas quelle option choisir, reportez-vous aux exigences concernant le code d'entraînement pour en savoir plus.

Contenu d'une tâche personnalisée

Lorsque vous créez une tâche personnalisée, vous spécifiez les paramètres dont Vertex AI a besoin pour exécuter votre code d'entraînement, y compris :

Au sein des pools de nœuds de calcul, vous pouvez spécifier les paramètres suivants :

Configurer un entraînement distribué

Vous pouvez configurer une tâche d'entraînement personnalisée pour l'entraînement distribué en spécifiant plusieurs pools de nœuds de calcul.

La plupart des exemples de cette page présentent des tâches d'entraînement à instance dupliquée unique avec un pool de nœuds de calcul. Pour les modifier pour un entraînement distribué, procédez comme suit :

  • Utilisez votre premier pool de nœuds de calcul pour configurer votre instance dupliquée principale, puis définissez le nombre d'instances dupliquées sur 1.
  • Ajoutez ensuite d'autres pools de nœuds de calcul pour configurer des instances dupliquées de nœuds de calcul, des instances dupliquées de serveurs de paramètres ou des instances dupliquées d'évaluateurs, si votre framework de machine learning est compatible avec ces tâches de cluster supplémentaires pour l'entraînement distribué.

Découvrez comment utiliser l'entraînement distribué.

Créer une tâche personnalisée

Pour créer une tâche personnalisée, procédez comme suit :

Console

Dans Google Cloud Console, vous ne pouvez pas créer directement une ressource CustomJob. Toutefois, vous pouvez créer une ressource TrainingPipeline qui crée un CustomJob.

Les instructions suivantes décrivent comment créer un TrainingPipeline qui crée une CustomJob et qui ne fait rien d'autre. Si vous souhaitez utiliser des fonctionnalités TrainingPipeline supplémentaires, telles que l'entraînement avec un ensemble de données géré ou la création d'une ressource Model à la fin de l'entraînement, consultez la section Créer des pipelines d'entraînement

  1. Dans Cloud Console, dans la section Vertex AI, accédez à la page Entraîner des pipelines.

    Accéder à la page Pipelines d'entraînement

  2. Cliquez sur Créer pour ouvrir le volet Entraîner le nouveau modèle.

  3. À l'étape Sélectionner une méthode d'entraînement, spécifiez les paramètres suivants :

    1. Dans la liste déroulante Ensemble de données, sélectionnez Aucun ensemble de données géré.

    2. Sélectionnez Entraînement personnalisé (avancé).

    Cliquez sur Continuer.

  4. À l'étape Définir votre modèle, saisissez le nom de votre choix, MODEL_NAME, pour votre modèle. Cliquez sur Continuer.

  5. À l'étape Entraînement du conteneur, spécifiez les paramètres suivants :

    1. Indiquez d'utiliser ou non un conteneur prédéfini ou un conteneur prédéfini à des fins d'entraînement.

    2. Selon votre choix, effectuez l'une des opérations suivantes :

    3. Dans le champ Répertoire de sortie du modèle, spécifiez l'URI Cloud Storage d'un répertoire d'un bucket auquel vous avez accès. Le répertoire n'a pas besoin d'exister pour le moment.

      Cette valeur est transmise à Vertex AI dans le champ d'API baseOutputDirectory, qui définit plusieurs variables d'environnement auxquelles votre application d'entraînement peut accéder lorsqu'elle s'exécute.

    4. Dans le champ Arguments, vous pouvez éventuellement spécifier des arguments à utiliser par Vertex AI pour le lancement de l'exécution de votre code d'entraînement. Le comportement de ces arguments varie en fonction du type de conteneur que vous utilisez :

    Cliquez sur Continuer.

  6. À l'étape Réglage des hyperparamètres, assurez-vous que la case Activer le réglage d'hyperparamètres n'est pas cochée. Cliquez sur Continuer.

  7. À l'étape Calcul et tarification, spécifiez les paramètres suivants :

    1. Dans la liste déroulante Région, sélectionnez une région compatible avec l'entraînement personnalisé.

    2. Dans la section Pool de nœuds de calcul 0, spécifiez les ressources de calcul à utiliser pour l'entraînement.

      Si vous spécifiez des accélérateurs, assurez-vous que le type d'accélérateur que vous choisissez est disponible dans la région sélectionnée.

      Si vous souhaitez effectuer un entraînement distribué, cliquez sur Ajouter d'autres pools de nœuds de calcul et spécifiez un ensemble supplémentaire de ressources de calcul pour chaque pool de nœuds de calcul supplémentaire souhaité.

    Cliquez sur Continuer.

  8. À l'étape Prédiction de conteneur, sélectionnez Aucun conteneur de prédiction.

  9. Cliquez sur Démarrer l'entraînement pour démarrer le pipeline d'entraînement personnalisé.

gcloud

Les exemples suivants utilisent la commande gcloud beta ai custom-jobs create.

Selon que vous avez créé une application d'entraînement Python à utiliser avec un conteneur prédéfini ou utilisez un conteneur personnalisé, exécutez l'une des commandes suivantes :

Conteneur prédéfini

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE

Remplacez l'élément suivant :

  • LOCATION : région où le conteneur ou le package Python sera exécuté.
  • JOB_NAME : valeur obligatoire. nom à afficher pour CustomJob.
  • PYTHON_PACKAGE_URIS : liste d'URI Cloud Storage séparés par une virgule spécifiant les fichiers de package Python correspondant au programme d'entraînement et ses packages dépendants. Le nombre maximal d'URI de package est de 100.
  • MACHINE_TYPE : type de la machine. Consultez la section Types de machines disponibles pour l'entraînement.
  • REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser. Dans la plupart des cas, définissez cette valeur sur 1 pour votre premier pool de nœuds de calcul.
  • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le package Python fourni. Pour en savoir plus, consultez les conteneurs prédéfinis disponibles pour l'entraînement.
  • PYTHON_MODULE : nom du module Python à exécuter après l'installation des packages.

Conteneur personnalisé

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,container-image-uri=CUSTOM_CONTAINER_IMAGE_URI

Remplacez l'élément suivant :

  • LOCATION : région où le conteneur ou le package Python sera exécuté.
  • JOB_NAME : valeur obligatoire. nom à afficher pour CustomJob.
  • MACHINE_TYPE : type de la machine. Consultez la section Types de machines disponibles pour l'entraînement.
  • REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser. Dans la plupart des cas, définissez cette valeur sur 1 pour votre premier pool de nœuds de calcul.
  • CUSTOM_CONTAINER_IMAGE_URI : URI d'une image de conteneur dans Artifact Registry, Container Registry ou Docker Hub à exécuter sur chaque instance dupliquée de nœud de calcul.

Conteneur personnalisé basé sur le code local

Si vous disposez d'un code d'entraînement sur votre ordinateur local, vous pouvez utiliser une seule commande pour effectuer les opérations suivantes :

  • Créer une image Docker personnalisée basée sur votre code
  • Stocker l'image dans Container Registry
  • Démarrer une opération CustomJob basée sur l'image

Le résultat est semblable à la création d'un CustomJob à l'aide de tout autre conteneur personnalisé. Vous pouvez utiliser cette version de la commande si cela convient à votre workflow.

Avant de commencer

Étant donné que cette version de la commande crée et transfère une image Docker, vous devez effectuer la configuration suivante sur votre ordinateur local :

  1. Installez Docker Engine

  2. Si vous utilisez Linux, configurez Docker pour pouvoir l'exécuter sans sudo.

  3. Activez l'API Container Registry.

    Activer l'API

  4. Configurez l'authentification pour Docker afin de pouvoir stocker des images Docker dans Container Registry :

    gcloud auth configure-docker
    

Créer et transférer l'image Docker et créer un CustomJob

La commande suivante permet de créer une image Docker basée sur une image de conteneur d'entraînement prédéfinie et votre code Python local, de transférer l'image vers Container Registry et de créer un fichier CustomJob.

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,local-package-path=WORKING_DIRECTORY,script=SCRIPT_PATH

Remplacez l'élément suivant :

  • LOCATION : région où le conteneur ou le package Python sera exécuté.

  • JOB_NAME : valeur obligatoire. nom à afficher pour CustomJob.

  • MACHINE_TYPE : type de la machine. Consultez la section Types de machines disponibles pour l'entraînement.

  • REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser. Dans la plupart des cas, définissez cette valeur sur 1 pour votre premier pool de nœuds de calcul.

  • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le package Python fourni. Pour en savoir plus, consultez les conteneurs prédéfinis disponibles pour l'entraînement.

    Cette image sert d'image de base pour la nouvelle image Docker que vous créez à l'aide de cette commande.

  • WORKING_DIRECTORY : répertoire de votre système de fichiers local contenant le script de point d'entrée qui exécute le code d'entraînement (consultez l'élément de liste suivant).

    Vous pouvez utiliser le répertoire parent du script ou un répertoire de niveau supérieur. Si vous souhaitez spécifier un nom de module Python complet, vous pouvez utiliser un répertoire de niveau supérieur (voir l'élément de liste suivant). Vous pouvez également utiliser un répertoire de niveau supérieur s'il contient un fichier requirements.txt ou un fichier setup.py, afin d'installer des dépendances supplémentaires dans le conteneur. Cette fonctionnalité est similaire à la fonctionnalité correspondante de la commande gcloud beta ai custom-jobs local-run. Toutefois, même si vous spécifiez un répertoire de niveau supérieur, cette commande ne copie que le répertoire parent de votre script de point d'entrée dans l'image Docker.

  • SCRIPT_PATH : chemin d'accès, par rapport à WORKING_DIRECTORY sur votre système de fichiers local, vers le script qui est le point d'entrée de votre code d'entraînement. Il peut s'agir d'un script Python (se terminant par .py) ou d'un script Bash.

    Par exemple, si vous souhaitez exécuter /hello-world/trainer/task.py et que WORKING_DIRECTORY est défini sur /hello-world, utilisez trainer/task.py pour cette valeur.

    Utiliser python-module au lieu de script

    Vous pouvez éventuellement remplacer script=SCRIPT_PATH par python-module=PYTHON_MODULE pour spécifier dans WORKING_DIRECTORY le nom d'un module Python à exécuter en tant que point d'entrée pour l'entraînement. Par exemple, au lieu de script=trainer/task.py, vous pouvez spécifier python-module=trainer.task.

    Dans ce cas, le conteneur Docker obtenu charge votre code en tant que module plutôt que sous forme de script. Vous souhaiterez probablement utiliser cette option si votre script de point d'entrée importe d'autres modules Python dans WORKING_DIRECTORY.

Configurer un entraînement distribué

Si vous souhaitez effectuer un entraînement distribué, vous pouvez spécifier l'option --worker-pool-spec plusieurs fois, une fois pour chaque pool de nœuds de calcul. Les exemples suivants adaptent les exemples précédents pour utiliser un deuxième pool de nœuds de calcul :

Conteneur prédéfini

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,executor-image-uri=SECOND_POOL_PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,python-module=SECOND_POOL_PYTHON_MODULE

Conteneur personnalisé

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,container-image-uri=CUSTOM_CONTAINER_IMAGE_URI \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,container-image-uri=SECOND_POOL_CUSTOM_CONTAINER_IMAGE_URI

Conteneur personnalisé basé sur le code local

Lorsque vous utilisez local-package-path=WORKING_DIRECTORY dans la commande, vous ne devez configurer qu'un seul pool de nœuds de calcul. L'entraînement distribué n'est pas disponible.

Configuration avancée

Si vous souhaitez spécifier des options de configuration qui ne sont pas disponibles dans les exemples précédents, vous pouvez utiliser l'indicateur --config pour spécifier le chemin d'accès à un fichier config.yaml de votre environnement local contenant les champs CustomJobSpec. Exemple :

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

Consultez un exemple de fichier config.yaml.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • LOCATION : région où le conteneur ou le package Python sera exécuté.
  • PROJECT_ID : ID de votre projet ou numéro de projet.
  • JOB_NAME : valeur obligatoire. nom à afficher pour CustomJob.
  • Définissez la tâche d'entraînement personnalisée :
    • MACHINE_TYPE : type de la machine. Consultez la section Types de machines disponibles pour l'entraînement.
    • ACCELERATOR_TYPE : (Facultatif) Type d'accélérateur à associer à la tâche.
    • ACCELERATOR_COUNT : (Facultatif) Nombre d'accélérateurs à associer à la tâche.
    • DISK_TYPE : (Facultatif) Type de disque de démarrage à utiliser pour la tâche (pd-standard par défaut) ou pd-ssd. En savoir plus sur les types de disques
    • DISK_SIZE : (Facultatif) Taille en Go du disque de démarrage à utiliser pour la tâche. La valeur par défaut est 100.
    • REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser. Dans la plupart des cas, définissez cette valeur sur 1 pour votre premier pool de nœuds de calcul.
    • Si votre application d'entraînement s'exécute dans un conteneur personnalisé, spécifiez les éléments suivants :
      • CUSTOM_CONTAINER_IMAGE_URI : URI d'une image de conteneur dans Artifact Registry, Container Registry ou Docker Hub à exécuter sur chaque instance dupliquée de nœud de calcul.
      • CUSTOM_CONTAINER_COMMAND : (Facultatif) Commande à appeler au démarrage du conteneur. Cette commande ignore le point d'entrée par défaut du conteneur.
      • CUSTOM_CONTAINER_ARGS : (Facultatif) Arguments à transmettre lors du démarrage du conteneur.
    • Si votre application d'entraînement est un package Python qui s'exécute dans un conteneur prédéfini, spécifiez les éléments suivants :
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le package Python fourni. Pour en savoir plus, consultez les conteneurs prédéfinis disponibles pour l'entraînement.
      • PYTHON_PACKAGE_URIS : liste d'URI Cloud Storage séparés par une virgule spécifiant les fichiers de package Python correspondant au programme d'entraînement et ses packages dépendants. Le nombre maximal d'URI de package est de 100.
      • PYTHON_MODULE : nom du module Python à exécuter après l'installation des packages.
      • PYTHON_PACKAGE_ARGS : (Facultatif) Arguments de ligne de commande à transmettre au module Python.
    • Découvrez les options de planification des tâches.
    • TIMEOUT : (Facultatif) Durée d'exécution maximale pour la tâche.
  • Spécifiez les éléments LABEL_NAME et LABEL_VALUE pour tous les libellés que vous souhaitez appliquer à cette tâche personnalisée.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs

Corps JSON de la requête :

{
  "displayName": "JOB_NAME",
  "jobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": MACHINE_TYPE,
          "acceleratorType": ACCELERATOR_TYPE,
          "acceleratorCount": ACCELERATOR_COUNT
        },
        "replicaCount": REPLICA_COUNT,
        "diskSpec": {
          "bootDiskType": DISK_TYPE,
          "bootDiskSizeGb": DISK_SIZE
        },

        // Union field task can be only one of the following:
        "containerSpec": {
          "imageUri": CUSTOM_CONTAINER_IMAGE_URI,
          "command": [
            CUSTOM_CONTAINER_COMMAND
          ],
          "args": [
            CUSTOM_CONTAINER_ARGS
          ]
        },
        "pythonPackageSpec": {
          "executorImageUri": 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.
      }
      // Specify one workerPoolSpec for single replica training, or multiple workerPoolSpecs
      // for distributed training.
    ],
    "scheduling": {
      "timeout": TIMEOUT
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs" | Select-Object -Expand Content

La réponse contient des informations sur les spécifications, ainsi que sur TRAININGPIPELINE_ID.

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const customJobDisplayName = 'YOUR_CUSTOM_JOB_DISPLAY_NAME';
// const containerImageUri = 'YOUR_CONTAINER_IMAGE_URI';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Job Service Client library
const {JobServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const jobServiceClient = new JobServiceClient(clientOptions);

async function createCustomJob() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const customJob = {
    displayName: customJobDisplayName,
    jobSpec: {
      workerPoolSpecs: [
        {
          machineSpec: {
            machineType: 'n1-standard-4',
            acceleratorType: 'NVIDIA_TESLA_K80',
            acceleratorCount: 1,
          },
          replicaCount: 1,
          containerSpec: {
            imageUri: containerImageUri,
            command: [],
            args: [],
          },
        },
      ],
    },
  };
  const request = {parent, customJob};

  // Create custom job request
  const [response] = await jobServiceClient.createCustomJob(request);

  console.log('Create custom job response');
  console.log(`${JSON.stringify(response)}`);
}
createCustomJob();

Python

Cet exemple utilise le SDK Vertex pour Python. Avant d'exécuter l'exemple de code suivant, vous devez configurer l'authentification.

from google.cloud import aiplatform

def create_custom_job_sample(
    project: str,
    display_name: str,
    container_image_uri: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)
    custom_job = {
        "display_name": display_name,
        "job_spec": {
            "worker_pool_specs": [
                {
                    "machine_spec": {
                        "machine_type": "n1-standard-4",
                        "accelerator_type": aiplatform.gapic.AcceleratorType.NVIDIA_TESLA_K80,
                        "accelerator_count": 1,
                    },
                    "replica_count": 1,
                    "container_spec": {
                        "image_uri": container_image_uri,
                        "command": [],
                        "args": [],
                    },
                }
            ]
        },
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_custom_job(parent=parent, custom_job=custom_job)
    print("response:", response)

Étape suivante

  • Consultez la page Importer des modèles dans Vertex AI pour découvrir comment créer des tâches d'entraînement personnalisées afin d'exécuter vos applications d'entraînement personnalisées sur Vertex AI.