Préparer le code d'entraînement

Réalisez un entraînement personnalisé sur Vertex AI pour exécuter votre propre code d'entraînement de machine learning (ML) dans le cloud plutôt que d'utiliser AutoML. Ce document décrit les bonnes pratiques à prendre en compte lorsque vous écrivez du code d'entraînement.

Choisir une structure de code d'entraînement

Commencez par déterminer la structure que vous souhaitez utiliser pour votre code d'entraînement de ML. Vous pouvez fournir le code d'entraînement à Vertex AI sous l'une des formes suivantes :

  • Un script Python à utiliser avec un conteneur prédéfini. Utilisez le SDK Vertex AI pour créer un job personnalisé. Cette méthode vous permet de fournir votre application d'entraînement sous la forme d'un script Python unique.

  • Une application d'entraînement Python à utiliser avec un conteneur prédéfini. Créez une distribution source Python avec du code qui entraîne un modèle de ML et l'exporte vers Cloud Storage. Cette application d'entraînement peut utiliser toutes les dépendances incluses dans le conteneur prédéfini que vous prévoyez d'utiliser.

    Utilisez cette option si l'un des conteneurs prédéfinis pour l'entraînement de Vertex AI inclut toutes les dépendances dont vous avez besoin pour l'entraînement. Si vous souhaitez par exemple effectuer l'entraînement avec PyTorch, scikit-learn, TensorFlow ou XGBoost, alors il s'agit probablement de la meilleure option.

    Pour en savoir plus sur les bonnes pratiques spécifiques à cette option, consultez le guide sur la création d'une application d'entraînement Python.

  • Une image de conteneur personnalisée. Créez une image de conteneur Docker avec du code qui entraîne un modèle de ML et l'exporte vers Cloud Storage. Incluez toutes les dépendances requises par votre code dans l'image de conteneur.

    Utilisez cette option si vous souhaitez utiliser des dépendances qui ne sont pas incluses dans l'un des conteneurs prédéfinis pour l'entraînement de Vertex AI. Il s'agit de la meilleure option si vous souhaitez effectuer l'entraînement à l'aide d'un framework ML Python qui n'est pas disponible dans un conteneur prédéfini ou à l'aide d'un langage de programmation autre que Python,.

    Pour en savoir plus sur les bonnes pratiques spécifiques à cette option, consultez le guide sur la création d'une image de conteneur personnalisée.

Le reste de ce document décrit les bonnes pratiques concernant les deux structures de code d'entraînement.

Bonnes pratiques pour tous les codes d'entraînement personnalisés

Lorsque vous écrivez du code d'entraînement personnalisé pour Vertex AI, gardez à l'esprit qu'il s'exécutera sur une ou plusieurs instances de machine virtuelle (VM) gérées par Google Cloud. Cette section décrit les bonnes pratiques applicables à l'intégralité du code d'entraînement personnalisé.

Accéder aux services Google Cloud dans votre code

Plusieurs des sections suivantes décrivent l'accès à d'autres services Google Cloud à partir de votre code. Pour accéder aux services Google Cloud, écrivez le code d'entraînement de manière à utiliser les identifiants par défaut de l'application. De nombreuses bibliothèques clientes Google Cloud s'authentifient par défaut avec les identifiants par défaut de l'application. Vous n'avez pas besoin de configurer de variables d'environnement. Vertex AI configure automatiquement les identifiants par défaut de l'application pour s'authentifier en tant qu'agent de service de code personnalisé Vertex AI pour votre projet (par défaut) ou compte de service personnalisé (si vous en avez configuré un).

Toutefois, lorsque vous utilisez une bibliothèque cliente Google Cloud dans votre code, Vertex AI peut ne pas toujours se connecter par défaut au bon projet Google Cloud. Si vous rencontrez des erreurs d'autorisation, une connexion au mauvais projet peut être le problème.

Ce problème se produit car Vertex AI n'exécute pas votre code directement dans votre projet Google Cloud. Le Vertex AI exécute à la place votre code dans l'un des différents projets gérés par Google. Vertex AI utilise ces projets exclusivement pour les opérations liées à votre projet. Par conséquent, n'essayez pas de déduire un ID de projet de l'environnement de votre code d'entraînement ou de prédiction mais spécifiez plutôt les ID de projet de manière explicite.

Si vous ne souhaitez pas coder en dur un ID de projet dans votre code d'entraînement, vous pouvez référencer la variable d'environnement CLOUD_ML_PROJECT_ID : Vertex AI définit cette variable d'environnement dans chaque conteneur d'entraînement personnalisé pour qu'il contienne le numéro du projet dans lequel vous avez lancé l'entraînement personnalisé. De nombreux outils Google Cloud peuvent accepter un numéro de projet dès lors qu'il est associé à un ID de projet.

Par exemple, si vous souhaitez utiliser le client Python pour Google BigQuery afin d'accéder à une table BigQuery du même projet, n'essayez pas de déduire le projet dans votre code d'entraînement :

Sélection implicite d'un projet

from google.cloud import bigquery

client = bigquery.Client()

Utilisez plutôt un code qui sélectionne explicitement un projet :

Sélection explicite d'un projet

import os

from google.cloud import bigquery

project_number = os.environ["CLOUD_ML_PROJECT_ID"]

client = bigquery.Client(project=project_number)

Si vous rencontrez des erreurs d'autorisation après avoir configuré votre code de cette manière, lisez la section suivante sur les ressources auxquelles votre code peut accéder pour ajuster les autorisations disponibles pour votre code d'entraînement.

Ressources auxquelles votre code peut accéder

Par défaut, votre application d'entraînement peut accéder à toutes les ressources Google Cloud disponibles pour l'agent de service de code personnalisé Vertex AI (CCSA) de votre projet. Vous pouvez accorder à l'agent CCSA, et donc à votre application d'entraînement, l'accès à un nombre limité d'autres ressources en suivant les instructions de la section Accorder aux agents de service Vertex AI l'accès à d'autres ressources. Si votre application d'entraînement nécessite plus qu'un accès en lecture aux ressources Google Cloud non répertoriées sur cette page, elle doit acquérir un jeton d'accès OAuth 2.0 avec le https://www.googleapis.com/auth/cloud-platform, ce qui ne peut être fait qu'en utilisant un compte de service personnalisé.

Par exemple, considérons l'accès de votre code d'entraînement aux ressources Cloud Storage :

Par défaut, Vertex AI peut accéder à n'importe quel bucket Cloud Storage du projet Google Cloud dans lequel vous effectuez l'entraînement personnalisé. Vous pouvez également accorder à Vertex AI l'accès aux buckets Cloud Storage d'autres projets, ou personnaliser précisément les buckets auxquels une tâche spécifique peut accéder à l'aide d'un compte de service personnalisé.

Lisez et écrivez des données dans des fichiers Cloud Storage avec Cloud Storage FUSE

Dans toutes les tâches d'entraînement personnalisées, Vertex AI installe des buckets Cloud Storage auxquels vous avez accès dans le répertoire /gcs/ du système de fichiers de chaque nœud d'entraînement. Au lieu d'utiliser le client Python pour Cloud Storage ou une autre bibliothèque pour accéder à Cloud Storage, vous pouvez lire et écrire directement sur le système de fichiers local, afin de lire ou d'écrire des données depuis/vers Cloud Storage. Par exemple, pour charger des données à partir de gs://BUCKET/data.csv, vous pouvez utiliser le code Python suivant :

file = open('/gcs/BUCKET/data.csv', 'r')

Vertex AI utilise Cloud Storage FUSE pour installer les buckets de stockage. Notez que les répertoires installés par Cloud Storage FUSE ne sont pas compatibles avec POSIX.

Les identifiants que vous utilisez pour l'entraînement personnalisé déterminent les buckets auxquels vous pouvez accéder de cette manière. La section précédente concernant les ressources auxquelles votre code peut accéder décrit exactement les buckets auxquels vous pouvez accéder par défaut et explique comment personnaliser cet accès.

Charger les données d'entrée

Le code de ML utilise généralement des données d'entraînement afin d'entraîner un modèle. Lorsque vous créez une application d'entraînement Python ou une image de conteneur personnalisée, ne stockez pas les données d'entraînement avec votre code. Le stockage de données avec le code peut résulter en un projet mal organisé, compliquer la réutilisation du code sur différents ensembles de données et provoquer des erreurs pour les ensembles de données volumineux.

Vous pouvez charger des données à partir d'un ensemble de données géré Vertex AI ou écrire votre propre code pour charger des données à partir d'une source externe à Vertex AI, telle que BigQuery ou Cloud Storage.

Pour optimiser les performances lorsque vous chargez des données à partir de Cloud Storage, utilisez un bucket situé dans la région où vous effectuez l'entraînement personnalisé. Pour savoir comment stocker des données dans Cloud Storage, consultez les pages Créer des buckets de stockage et Importer des objets.

Pour savoir quels buckets Cloud Storage vous permettent de charger des données, consultez la section précédente concernant les ressources auxquelles votre code peut accéder.

Pour charger des données à partir de Cloud Storage dans votre code d'entraînement, utilisez la fonctionnalité Cloud Storage FUSE décrite dans la section précédente ou utilisez une bibliothèque compatible avec le service d'identifiants par défaut de l'application (ADC). Vous n'avez pas besoin de fournir explicitement des identifiants d'authentification dans votre code.

Par exemple, vous pouvez utiliser l'une des bibliothèques clientes présentées dans le guide Cloud Storage pour Télécharger des objets. Le client Python pour Cloud Storage est spécifiquement inclus dans les conteneurs prédéfinis. La classe tf.io.gfile.GFile de TensorFlow est également compatible avec les identifiants par défaut de l'application (ADC).

Charger un ensemble de données volumineux

Selon les types de machines que vous prévoyez d'utiliser pour votre entraînement personnalisé, vos VM risquent de ne pas pouvoir charger en mémoire l'intégralité d'un ensemble de données volumineux.

Si vous avez besoin de lire des données trop volumineuses pour tenir en mémoire, diffusez les données ou lisez-les progressivement. Les bonnes pratiques à cet effet diffèrent en fonction du framework de ML utilisé. Par exemple, la classe tf.data.Dataset de TensorFlow peut diffuser des données TFRecord ou des données textuelles à partir de Cloud Storage.

Réaliser un entraînement personnalisé sur plusieurs VM avec le parallélisme des données est un autre moyen de réduire la quantité de données chargées en mémoire par chaque VM. Consultez la section Rédiger du code pour l'entraînement distribué du présent document.

Exporter un modèle de ML entraîné

À la fin de l'entraînement, le code de ML exporte généralement un modèle entraîné sous la forme d'un ou plusieurs artefacts de modèle. Vous pouvez ensuite utiliser ces artefacts pour obtenir des prédictions.

Une fois l'entraînement personnalisé terminé, vous ne pouvez plus accéder aux VM qui ont exécuté votre code d'entraînement. Par conséquent, votre code d'entraînement doit exporter les artefacts du modèle vers un emplacement situé en dehors de Vertex AI.

Nous vous recommandons d'exporter les artefacts de modèle vers un bucket Cloud Storage. Comme décrit dans la section précédente sur les ressources auxquelles votre code peut accéder, Vertex AI peut accéder à n'importe quel bucket Cloud Storage du projet Google Cloud dans lequel vous effectuez l'entraînement personnalisé. Utilisez une bibliothèque compatible avec les identifiants par défaut de l'application (ADC) pour exporter les artefacts de votre modèle. Par exemple, les API TensorFlow pour l'enregistrement de modèles Keras peuvent exporter des artefacts directement vers un chemin d'accès Cloud Storage.

Si vous souhaitez utiliser votre modèle entraîné pour diffuser des prédictions sur Vertex AI, votre code doit exporter des artefacts de modèle dans un format compatible avec l'un des conteneurs prédéfinis pour la prédiction. Pour en savoir plus, consultez le guide sur l'exportation d'artefacts de modèle pour la prédiction.

Variables d'environnement pour les répertoires Cloud Storage spéciaux

Si vous spécifiez le champ d'API baseOutputDirectory, Vertex AI définit les variables d'environnement suivantes lors de l'exécution du code d'entraînement :

Les valeurs de ces variables d'environnement diffèrent légèrement selon que vous utilisez ou non le réglage d'hyperparamètres. Pour en savoir plus, consultez la documentation de référence de l'API pour baseOutputDirectory.

L'utilisation de ces variables d'environnement facilite la réutilisation du même code d'entraînement (par exemple, avec des données ou des options de configuration différentes) et l'enregistrement des artefacts et des points de contrôle du modèle dans différents emplacements, en modifiant simplement le champ d'API baseOutputDirectory. Toutefois, vous n'êtes pas obligé d'utiliser les variables d'environnement dans votre code. Par exemple, vous pouvez également coder en dur les emplacements où enregistrer les points de contrôle et exporter des artefacts de modèles.

En outre, si vous utilisez un TrainingPipeline pour l'entraînement personnalisé sans spécifier le champ modelToUpload.artifactUri, Vertex AI utilise la valeur de la variable d'environnement AIP_MODEL_DIR pour modelToUpload.artifactUri. (Pour le réglage des hyperparamètres, Vertex AI utilise la valeur de la variable d'environnement AIP_MODEL_DIR issue du meilleur essai.)

Assurer la résilience aux redémarrages

Les VM qui exécutent votre code d'entraînement redémarrent occasionnellement. Par exemple, Google Cloud peut avoir besoin de redémarrer une VM pour des raisons de maintenance. Lorsqu'une VM redémarre, Vertex AI redémarre l'exécution de votre code depuis le début.

Si vous prévoyez que votre code d'entraînement s'exécute pendant plus de quatre heures, ajoutez plusieurs comportements à votre code pour le rendre résilient au redémarrage :

  • Exportez fréquemment votre progression vers Cloud Storage, au moins une fois toutes les quatre heures, afin de ne pas perdre votre progression si vos VM redémarrent.

  • Au début de votre code d'entraînement, vérifiez si une progression d'entraînement existe déjà dans votre emplacement d'exportation. Si c'est le cas, chargez l'état d'entraînement enregistré plutôt que de repartir de zéro.

Quatre heures sont une référence, et non une limite stricte. Si la priorité est de garantir la résilience, envisagez d'ajouter ces comportements à votre code, même si vous ne vous attendez pas à ce qu'il s'exécute aussi longtemps.

La marche à suivre dépend du framework de ML que vous utilisez. Par exemple, si vous utilisez TensorFlow Keras, découvrez comment utiliser le rappel ModelCheckpoint à cette fin.

Pour en savoir plus sur la manière dont Vertex AI gère les VM, consultez la page Comprendre le service d'entraînement personnalisé.

Bonnes pratiques concernant les fonctionnalités d'entraînement personnalisé facultatif

Si vous souhaitez utiliser certaines fonctionnalités facultatives d'entraînement personnalisé, vous devrez peut-être apporter des modifications supplémentaires à votre code d'entraînement. Cette section décrit les bonnes pratiques s'appliquant au code pour le réglage des hyperparamètres, les GPU, l'entraînement distribué et Vertex AI TensorBoard.

Écrire le code pour activer la journalisation automatique

Vous pouvez activer la journalisation automatique à l'aide du SDK Vertex AI pour Python afin de capturer automatiquement les paramètres et les métriques de performances lors de l'envoi du job personnalisé. Pour en savoir plus, consultez la section Exécuter un job d'entraînement avec suivi des tests.

Écrire le code pour renvoyer les journaux de conteneurs

Lorsque vous écrivez des journaux à partir de votre service ou job, ils sont automatiquement récupérés par Cloud Logging à condition qu'ils soient écrits dans l'un des emplacements suivants :

La plupart des développeurs sont censés écrire des journaux à l'aide des flux de résultat standard et d'erreur standard.

Les journaux de conteneur écrits dans ces emplacements compatibles sont automatiquement associés au service, à la révision et à l'emplacement Vertex AI, ou au job d'entraînement personnalisé. Les exceptions contenues dans ces journaux sont capturées et signalées dans Error Reporting.

Utiliser du texte simple au lieu des données JSON structurées dans les journaux

Lorsque vous écrivez des journaux, vous pouvez envoyer une simple chaîne de texte ou une seule ligne de données JSON sérialisées, également appelées données "structurées". Ces données sont récupérées et analysées par Cloud Logging, puis placées dans jsonPayload. En revanche, le message en texte simple est placé dans textPayload.

Écrire des journaux structurés

Vous pouvez transmettre des journaux JSON structurés de plusieurs manières. Les méthodes les plus courantes consistent à utiliser la bibliothèque de journalisation Python ou à transmettre du code JSON brut à l'aide de print.

Bibliothèque de journalisation Python

import json
import logging
from pythonjsonlogger import jsonlogger


class CustomJsonFormatter(jsonlogger.JsonFormatter):
 """Formats log lines in JSON."""
  def process_log_record(self, log_record):
    """Modifies fields in the log_record to match Cloud Logging's expectations."""
    log_record['severity'] = log_record['levelname']
    log_record['timestampSeconds'] = int(log_record['created'])
    log_record['timestampNanos'] = int(
        (log_record['created'] % 1) * 1000 * 1000 * 1000)


    return log_record




def configure_logger():
  """Configures python logger to format logs as JSON."""
  formatter = CustomJsonFormatter(
        '%(name)s|%(levelname)s|%(message)s|%(created)f'
        '|%(lineno)d|%(pathname)s', '%Y-%m-%dT%H:%M:%S')
  root_logger = logging.getLogger()
  handler = logging.StreamHandler()
  handler.setFormatter(formatter)
  root_logger.addHandler(handler)
  root_logger.setLevel(logging.WARNING)


logging.warning("This is a warning log")

JSON brut

import json


def log(severity, message):
  global_extras = {"debug_key": "debug_value"}
  structured_log = {"severity": severity, "message": message, **global_extras}
  print(json.dumps(structured_log))


def main(args):
  log("DEBUG", "Debugging the application.")
  log("INFO", "Info.")
  log("WARNING", "Warning.")
  log("ERROR", "Error.")
  log("CRITICAL", "Critical.")

Champs JSON spéciaux dans les messages

Lorsque vous fournissez un journal structuré sous forme de dictionnaire JSON, certains champs spéciaux sont supprimés de jsonPayload et écrits dans le champ correspondant de la LogEntry générée, comme décrit dans la documentation sur les champs spéciaux.

Par exemple, si vos données JSON incluent une propriété severity, celle-ci est supprimée de jsonPayload et apparaît en tant que propriété severity de l'entrée de journal. La propriété message est utilisée comme texte d'affichage principal de l'entrée de journal, le cas échéant.

Corréler les journaux de conteneur avec un journal de requêtes (services uniquement)

Dans l'explorateur de journaux, les journaux corrélés par la même propriété trace sont visualisables au format "parent-enfant". Lorsque vous cliquez sur l'icône en forme de triangle située à gauche de l'entrée de journal de requête, les journaux de conteneur associés à cette requête sont imbriqués sous le journal de requête.

Les journaux de conteneur ne sont pas automatiquement corrélés avec les journaux de requête, sauf si vous utilisez une bibliothèque cliente Cloud Logging. Pour mettre en corrélation des journaux de conteneur avec des journaux de requête sans utiliser de bibliothèque cliente, vous pouvez utiliser une ligne de journal JSON structurée contenant un champ logging.googleapis.com/trace avec l'identifiant de trace extrait de l'en-tête X-Cloud-Trace-Context.

Afficher les journaux

Pour afficher les journaux de conteneur dans la console Google Cloud, procédez comme suit :

  1. Dans la console Google Cloud, accédez à la page Jobs personnalisés Vertex AI.

    Accéder à la page Tâches personnalisées

  2. Cliquez sur le nom du job personnalisé pour lequel vous souhaitez consulter les journaux.

  3. Cliquez sur Afficher les journaux.

Écrire le code pour les réglages d'hyperparamètres

Vertex AI peut appliquer des réglages d'hyperparamètres à votre code d'entraînement de ML. Obtenez plus d'informations sur le fonctionnement du réglage d'hyperparamètres sur Vertex AI et sur la configuration d'une ressource HyperparameterTuningJob.

Si vous souhaitez utiliser le réglage d'hyperparamètres, votre code d'entraînement doit effectuer les opérations suivantes :

  • Analyser des arguments de ligne de commande représentant les hyperparamètres et utiliser les valeurs analysées pour définir les hyperparamètres d'entraînement.

  • Signaler de manière intermittente la métrique de réglage d'hyperparamètres à Vertex AI.

Analyser les arguments de ligne de commande

Pour les tâches de réglage d'hyperparamètres, Vertex AI exécute votre code d'entraînement plusieurs fois, avec différents arguments de ligne de commande à chaque fois. Votre code d'entraînement doit analyser ces arguments de ligne de commande et les utiliser en tant qu'hyperparamètres pour l'entraînement. Par exemple, pour ajuster le taux d'apprentissage de votre optimiseur, vous pouvez analyser un argument de ligne de commande nommé --learning_rate. Découvrez comment définir les arguments de ligne de commande fournis par Vertex AI.

Nous vous recommandons d'utiliser la bibliothèque argparse de Python pour analyser les arguments de ligne de commande.

Signaler la métrique des réglages d'hyperparamètres

Votre code d'entraînement doit signaler de manière intermittente la métrique d'hyperparamètres que vous essayez d'optimiser à Vertex AI. Par exemple, si vous souhaitez optimiser la précision de votre modèle, vous pouvez signaler cette métrique à la fin de chaque époque d'entraînement. Vertex AI utilise cette information pour décider des hyperparamètres à utiliser pour le prochain essai d'entraînement. Découvrez comment sélectionner et spécifier une métrique de réglage d'hyperparamètres.

Utilisez la bibliothèque Python cloudml-hypertune pour signaler la métrique de réglage d'hyperparamètres. Cette bibliothèque est incluse dans tous les conteneurs prédéfinis pour l'entraînement et vous pouvez utiliser pip pour l'installer dans un conteneur personnalisé.

Pour savoir comment installer et utiliser cette bibliothèque, consultez la page sur le dépôt GitHub cloudml-hypertune, ou reportez-vous à l'atelier de programmation Vertex AI : réglages d'hyperparamètres.

Écrire le code pour les GPU

Vous pouvez sélectionner des VM avec des unités de traitement graphique (GPU) pour exécuter votre code d'entraînement personnalisé. Découvrez comment configurer l'entraînement personnalisé pour utiliser des VM compatibles avec les GPU.

Si vous souhaitez effectuer l'entraînement avec des GPU, assurez-vous que votre code d'entraînement peut les exploiter. Selon le framework de ML que vous utilisez, vous devrez peut-être modifier votre code. Par exemple, si vous utilisez TensorFlow Keras, vous n'avez besoin d'ajuster votre code que si vous souhaitez utiliser plusieurs GPU. Certains frameworks de ML ne peuvent pas utiliser de GPU.

Assurez-vous également que votre conteneur est compatible avec les GPU : sélectionnez un conteneur prédéfini pour l'entraînement compatible avec les GPU, ou installez NVIDIA CUDA Toolkit et NVIDIA cuDNN sur votre conteneur personnalisé. Pour ce faire, vous pouvez utiliser une image de base du dépôt Docker nvidia/cuda. Une autre méthode consiste à utiliser une instance de conteneurs de deep learning comme image de base.

Écrire le code pour l'entraînement distribué

Pour effectuer un entraînement sur de grands ensembles de données, vous pouvez exécuter votre code sur plusieurs VM d'un cluster distribué géré par Vertex AI. Découvrez comment configurer plusieurs VM pour l'entraînement.

Certains frameworks de ML, tels que TensorFlow et PyTorch, vous permettent d'exécuter du code d'entraînement identique sur plusieurs machines en coordonnant automatiquement la répartition du travail sur la base des variables d'environnement définies sur chaque machine. Découvrez si Vertex AI définit des variables d'environnement pour rendre cela possible avec votre framework de ML.

Vous pouvez également exécuter un conteneur différent sur plusieurs nœuds d'un pools de nœuds de calcul. Un pool de nœuds de calcul est un groupe de VM que vous configurez pour utiliser les mêmes options de calcul et le même conteneur. Dans ce cas, nous recommandons toujours d'utiliser les variables d'environnement définies par Vertex AI pour coordonner la communication entre les VM. Vous pouvez personnaliser le code d'entraînement de chaque pool de nœuds de calcul afin de réaliser des tâches arbitraires de votre choix. La manière de procéder dépend de votre objectif et du framework de ML que vous utilisez.

Suivre et visualiser les tests d'entraînement personnalisés avec Vertex AI TensorBoard

Vertex AI TensorBoard est une version gérée de TensorBoard, un projet Google Open Source permettant de visualiser les tests de machine learning. Avec Vertex AI TensorBoard, vous pouvez suivre, visualiser et comparer les tests de ML, et les partager avec votre équipe. Vous pouvez également utiliser Cloud Profiler pour identifier et corriger les goulots d'étranglement de performance afin d'entraîner les modèles plus rapidement et à moindre coût.

Pour utiliser Vertex AI TensorBoard avec un entraînement personnalisé, procédez comme suit :

Pour obtenir un guide étape par étape, consultez la page Utiliser Vertex AI TensorBoard avec un entraînement personnalisé.

Étapes suivantes