GSP965

Présentation

Les pipelines vous permettent d'automatiser et de reproduire votre workflow de ML. Vertex AI intègre toutes les offres de ML de Google Cloud pour créer une expérience de développement simple. Auparavant, les modèles entraînés avec AutoML et les modèles personnalisés étaient accessibles via des services distincts. Vertex AI regroupe ces deux types de modèles en une seule API, ainsi que d'autres nouveaux produits. Vertex AI inclut également divers produits MLOps comme Vertex Pipelines. Dans cet atelier, vous apprendrez à créer et exécuter des pipelines de ML avec Vertex Pipelines.

En quoi les pipelines de ML sont-ils utiles ?

Avant de vous lancer, vous devez comprendre les avantages d'un pipeline. Imaginez que vous créez un workflow de ML incluant le traitement de données, l'entraînement d'un modèle, le réglage d'hyperparamètres, l'évaluation et le déploiement d'un modèle. Chacune de ces étapes peut avoir des dépendances différentes, ce qui peut se révéler problématique si vous traitez l'ensemble du workflow comme un monolithe. Lorsque vous commencerez le scaling de votre processus de ML, vous souhaiterez peut-être partager votre workflow de ML avec le reste de votre équipe, afin qu'elle puisse l'exécuter et participer à l'écriture du code. Cela peut s'avérer difficile sans un processus fiable et reproductible. Avec les pipelines, chaque étape de votre processus de ML est son propre conteneur. Ainsi, vous pouvez développer des étapes de façon indépendante et suivre les entrées et sorties de chaque étape de manière reproductible. Vous pouvez également planifier ou déclencher des exécutions de votre pipeline en fonction d'autres événements dans votre environnement cloud, comme la disponibilité de nouvelles données d'entraînement.

Objectifs de l'atelier

• Utiliser le SDK Kubeflow Pipelines pour créer des pipelines de ML évolutifs

• Créer et exécuter un pipeline d'introduction en trois étapes acceptant du texte en entrée

• Créer et exécuter un pipeline qui entraîne, évalue et déploie un modèle de classification AutoML

• Utiliser des composants prédéfinis pour interagir avec les services Vertex AI services, fournis via la bibliothèque google_cloud_pipeline_components

• Planifier une tâche de pipeline avec Cloud Scheduler

Prérequis

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google. L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue Se connecter. Cliquez sur Suivant.

4. Copiez le mot de passe inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue de bienvenue. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis dans le panneau de gauche. Ne saisissez pas vos identifiants Google Cloud Skills Boost. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

5. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas aux essais offerts.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Vous pouvez afficher le menu qui contient la liste des produits et services Google Cloud en cliquant sur le menu de navigation en haut à gauche.

Créer une instance de notebook Vertex

1. Cliquez sur le menu de navigation.

2. Cliquez sur Vertex AI, puis sur Workbench.

3. Sur la page des instances de notebook, accédez à l'onglet Notebooks gérés par l'utilisateur, puis attendez que ai-notebook soit entièrement créé.

La création du notebook prend quelques minutes.

4. Une fois l'instance créée, sélectionnez Ouvrir JupyterLab :

Vérifiez que le notebook a été créé.

Configuration de Vertex Pipelines

Vous devrez installer quelques bibliothèques supplémentaires pour utiliser Vertex Pipelines :

• Kubeflow Pipelines : SDK utilisé pour créer le pipeline. Vertex Pipelines est compatible avec l'exécution de pipelines créés avec Kubeflow Pipelines ou TFX.

• Google Cloud Pipeline Components : cette bibliothèque fournit des composants prédéfinis qui permettent d'interagir plus facilement avec les services Vertex AI à partir de vos étapes de pipeline.

Étape 1 : Créez un notebook Python et installez les bibliothèques

Dans le menu de lancement de votre instance de notebook, créez un notebook en sélectionnant Python 3 :

Pour accéder au menu de lancement, cliquez sur le signe + en haut à gauche de votre instance de notebook.

Pour installer les deux services nécessaires pour cet atelier, vous devez d'abord définir l'option utilisateur dans une cellule du notebook :

USER_FLAG = "--user"

Exécutez ensuite les commandes suivantes depuis votre notebook :

!pip3 install {USER_FLAG} google-cloud-aiplatform==1.0.0 --upgrade !pip3 install {USER_FLAG} kfp google-cloud-pipeline-components==0.1.1 --upgrade

Une fois ces packages installés, vous devrez redémarrer le noyau :

import os if not os.getenv("IS_TESTING"): # Automatically restart kernel after installs import IPython app = IPython.Application.instance() app.kernel.do_shutdown(True)

Pour finir, vérifiez que vous avez correctement installé les packages. Utilisez la version 1.6 du SDK KFP ou une version ultérieure :

!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))" !python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"

Étape 2 : Définissez l'ID et le bucket de votre projet

Dans cet atelier, vous allez référencer votre ID de projet Cloud et le bucket que vous avez créé un peu plus tôt. Ensuite, vous allez créer des variables pour chacun d'eux.

Si vous ne connaissez pas votre ID de projet, vous pouvez l'obtenir en exécutant la commande suivante :

import os PROJECT_ID = "" # Get your Google Cloud project ID from gcloud if not os.getenv("IS_TESTING"): shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null PROJECT_ID = shell_output[0] print("Project ID: ", PROJECT_ID)

Ensuite, créez une variable pour stocker le nom de votre bucket.

BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"

Étape 3 : Importez les bibliothèques

Ajoutez le code suivant pour importer les bibliothèques que vous utiliserez dans cet atelier :

from typing import NamedTuple import kfp from kfp import dsl from kfp.v2 import compiler from kfp.v2.dsl import (Artifact, Dataset, Input, InputPath, Model, Output, OutputPath, ClassificationMetrics, Metrics, component) from kfp.v2.google.client import AIPlatformClient from google.cloud import aiplatform from google_cloud_pipeline_components import aiplatform as gcc_aip

Étape 4 : Définissez les constantes

La dernière chose à faire avant de créer le pipeline est de définir des variables constantes. PIPELINE_ROOT est le chemin d'accès Cloud Storage dans lequel les artefacts créés par votre pipeline seront écrits. Ici, vous utilisez us-central1 comme région, mais si vous avez choisi une autre region lorsque vous avez créé votre bucket, modifiez la variable REGION dans le code ci-dessous :

PATH=%env PATH %env PATH={PATH}:/home/jupyter/.local/bin REGION="us-central1" PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/" PIPELINE_ROOT

Une fois que vous avez exécuté le code ci-dessus, le répertoire racine de votre pipeline doit s'afficher. Il s'agit de l'emplacement Cloud Storage dans lequel les artefacts de votre pipeline seront écrits. Il est au format gs://<nom_bucket>/pipeline_root/

Créer votre premier pipeline

Créez un pipeline court à l'aide du SDK KFP. Ce pipeline n'implique pas de ML (ne vous inquiétez pas, on y viendra), car cet exercice vise à vous apprendre :

• comment créer des composants personnalisés dans le SDK KFP ;
• comment exécuter et surveiller un pipeline dans Vertex Pipelines.

Vous allez créer un pipeline qui affiche une phrase en utilisant deux sorties : un nom de produit et une description d'emoji. Ce pipeline comporte trois composants :

• product_name : ce composant accepte un nom de produit en entrée et renvoie cette chaîne en sortie.

• emoji : ce composant accepte la description textuelle d'un emoji et la convertit en emoji. Par exemple, le code textuel pour ✨ est "sparkles". Ce composant utilise une bibliothèque d'emoji pour vous montrer comment gérer des dépendances externes dans votre pipeline.

• build_sentence : ce dernier composant utilise la sortie des deux précédents pour créer une phrase contenant cet emoji. Par exemple, le résultat peut être "Vertex Pipelines, c'est ✨".

Étape 1 : Créez un composant basé sur une fonction Python

Le SDK KFP vous permet de créer des composants basés sur des fonctions Python. Commencez par créer le composant product_name, qui accepte simplement une chaîne en entrée et la renvoie.

Ajoutez le code suivant à votre notebook :

@component(base_image="python:3.9", output_component_file="first-component.yaml") def product_name(text: str) -> str: return text

Examinons de plus près cette syntaxe :

• Le décorateur @component compile cette fonction en un composant lorsque le pipeline est exécuté. Vous l'utiliserez à chaque fois que vous écrirez un composant personnalisé.

• Le paramètre base_image spécifie l'image de conteneur que ce composant utilise.

• Le paramètre facultatif output_component_file spécifie le fichier yaml dans lequel écrire le composant compilé. Une fois la cellule exécutée, ce fichier doit être écrit dans votre instance de notebook. Si vous souhaitez partager ce composant avec une autre personne, vous pouvez lui envoyer le fichier yaml qui a été généré afin qu'elle le charge à l'aide de la commande suivante :

product_name_component = kfp.components.load_component_from_file('./first-component.yaml')

Le code -> str après la définition de la fonction spécifie le type de sortie pour ce composant.

Étape 2 : Créez deux composants supplémentaires

Pour terminer le pipeline, vous allez créer deux autres composants. Le premier accepte une chaîne en entrée et la convertit en l'emoji correspondant, le cas échéant. Il renvoie un tuple avec le texte d'entrée transmis, ainsi que l'emoji correspondant :

@component(packages_to_install=["emoji"]) def emoji( text: str, ) -> NamedTuple( "Outputs", [ ("emoji_text", str), # Return parameters ("emoji", str), ], ): import emoji emoji_text = text emoji_str = emoji.emojize(':' + emoji_text + ':', use_aliases=True) print("output one: {}; output_two: {}".format(emoji_text, emoji_str)) return (emoji_text, emoji_str)

Ce composant est un peu plus complexe que le précédent. Voici les nouveautés :

• Le paramètre packages_to_install indique au composant les éventuelles dépendances de bibliothèques externes pour ce conteneur. Dans le cas présent, vous utilisez une bibliothèque appelée emoji.
• Ce composant renvoie un tuple NamedTuple nommé Outputs. Notez que chacune des chaînes de ce tuple dispose de clés : emoji_text et emoji. Dans le prochain composant, vous les utiliserez pour accéder à la sortie.

Le dernier composant de ce pipeline utilise la sortie des deux premiers et les combine pour renvoyer une chaîne :

@component def build_sentence( product: str, emoji: str, emojitext: str ) -> str: print("We completed the pipeline, hooray!") end_str = product + ", c'est " if len(emoji) > 0: end_str += emoji else: end_str += emojitext return(end_str)

Vous vous demanderez peut-être comment ce composant sait qu'il doit utiliser la sortie des étapes précédentes. Bonne question. Vous le découvrirez à l'étape suivante.

Étape 3 : Assemblez les composants en un pipeline

Les définitions de composants ci-dessus ont permis de créer des fonctions de fabrique pouvant être utilisées dans la définition d'un pipeline afin de créer des étapes. Pour configurer un pipeline, utilisez le décorateur @dsl.pipeline, fournissez le nom et la description du pipeline et indiquez le chemin d'accès racine dans lequel les artefacts de votre pipeline doivent être écrits. Le terme "artefacts" désigne tous les fichiers de sortie générés par votre pipeline. Ce pipeline d'introduction n'en génère pas, mais ce sera le cas du prochain.

Dans le prochain bloc de code, vous allez définir une fonction intro_pipeline. C'est à ce niveau que vous devez spécifier les entrées des premières étapes de votre pipeline, et comment elles sont connectées :

• product_task accepte un nom de produit en entrée. Ici, vous transmettez "Vertex Pipelines", mais vous pouvez indiquer le nom de produit que vous souhaitez.

• emoji_task accepte le code textuel d'un emoji en entrée. Vous pouvez également modifier cette information. Par exemple, "party_face" correspond à l'emoji 🥳. Étant donné que ce composant et le composant product_task ne reçoivent pas d'entrées d'autres étapes, vous devez indiquer manuellement les entrées lorsque vous définissez votre pipeline.

• La dernière étape du pipeline, consumer_task, compte trois paramètres d'entrée :

  • La sortie de product_task. Cette étape ne produisant qu'une seule sortie, vous pouvez la référencer à l'aide de product_task.output.
  • La sortie emoji de l'étape emoji_task. Reportez-vous au composant emoji défini ci-dessus, pour lequel vous avez nommé les paramètres de sortie.
  • Il en va de même pour la sortie nommée emoji_text du composant emoji. Si votre pipeline reçoit du texte qui ne correspond pas à un emoji, il utilisera ce texte pour construire une phrase.

@dsl.pipeline( name="hello-world", description="An intro pipeline", pipeline_root=PIPELINE_ROOT, ) # You can change the `text` and `emoji_str` parameters here to update the pipeline output def intro_pipeline(text: str = "Vertex Pipelines", emoji_str: str = "sparkles"): product_task = product_name(text) emoji_task = emoji(emoji_str) consumer_task = build_sentence( product_task.output, emoji_task.outputs["emoji"], emoji_task.outputs["emoji_text"], )

Étape 4 : Compilez et exécutez le pipeline

Une fois que vous avez défini votre pipeline, vous pouvez le compiler. Le code suivant génère un fichier JSON qui vous permettra d'exécuter le pipeline :

compiler.Compiler().compile( pipeline_func=intro_pipeline, package_path="intro_pipeline_job.json" )

Instanciez ensuite un client API :

api_client = AIPlatformClient( project_id=PROJECT_ID, region=REGION, )

Enfin, exécutez le pipeline :

response = api_client.create_run_from_job_spec( job_spec_path="intro_pipeline_job.json", # pipeline_root=PIPELINE_ROOT # this argument is necessary if you did not specify PIPELINE_ROOT as part of the pipeline definition. )

L'exécution du pipeline doit générer un lien permettant de consulter cette exécution dans votre console. Une fois l'exécution terminée, le résultat doit ressembler à ceci :

L'exécution de ce pipeline prend 5 à 6 minutes. Lorsqu'elle est terminée, vous pouvez cliquer sur le composant build-sentence pour afficher le résultat final :

Maintenant que vous maîtrisez le fonctionnement du SDK KFP et de Vertex Pipelines, vous êtes prêt à construire un pipeline qui crée et déploie un modèle de ML à l'aide d'autres services Vertex AI.

Vérifiez que votre pipeline d'emoji est terminé.

Créer un pipeline de ML de bout en bout

Il est temps de créer votre premier pipeline de ML. Dans ce pipeline, vous utiliserez l'ensemble de données UCI Machine Learning Dry Beans, de : KOKLU, M. et OZKAN, I.A., (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques." publié dans "Computers and Electronics in Agriculture", 174, 105507. DOI.

L'exécution de ce pipeline prend plus de 2 heures. Vous n'aurez pas besoin d'attendre tout ce temps pour terminer l'atelier. Suivez les instructions jusqu'au démarrage de votre tâche de pipeline.

Il s'agit d'un ensemble de données tabulaire, que vous utiliserez dans votre pipeline pour entraîner, évaluer et déployer un modèle AutoML qui répartit des haricots en sept types en fonction de leurs caractéristiques.

Ce pipeline va :

• créer un ensemble de données dans Vertex AI ;
• entraîner un modèle de classification tabulaire avec AutoML ;
• obtenir des métriques d'évaluation sur ce modèle ;
• décider, à partir des métriques d'évaluation, s'il faut déployer le modèle à l'aide d'une logique conditionnelle dans Vertex Pipelines ;
• déployer le modèle sur un point de terminaison grâce à Vertex Prediction.

Chacune des étapes énoncées correspond à un composant. La plupart des étapes du pipeline utilisent des composants prédéfinis pour les services Vertex AI via la bibliothèque google_cloud_pipeline_components que vous avez importée plus tôt au cours de cet atelier de programmation. Dans cette section, nous allons commencer par définir un composant personnalisé. Ensuite, nous définirons les autres étapes du pipeline à l'aide de composants prédéfinis. Ces composants facilitent l'accès aux services Vertex AI, comme l'entraînement et le déploiement de modèles.

La majorité du temps passé sur cette étape correspond à l'entraînement AutoML du pipeline, soit environ une heure.

Étape 1 : Composant personnalisé pour l'évaluation du modèle

Le composant personnalisé que vous allez définir servira vers la fin du pipeline, une fois l'entraînement du modèle terminé. Ce composant a plusieurs fonctions :

• Obtenir les métriques d'évaluation du modèle de classification AutoML entraîné
• Analyser les métriques et en générer un rendu dans l'interface Vertex Pipelines
• Comparer les métriques à un seuil pour déterminer si le modèle doit être déployé

Avant de définir le composant, vous devez comprendre ses paramètres d'entrée et de sortie. Ce pipeline accepte en entrée des métadonnées de votre projet Cloud, le modèle entraîné obtenu (vous définirez ce composant plus tard), les métriques d'évaluation du modèle et un paramètre thresholds_dict_str. Vous définirez thresholds_dict_str lorsque vous exécuterez le pipeline. Dans le cas de ce modèle de classification, il s'agira de l'aire sous la courbe ROC pour laquelle vous devez déployer le modèle. Par exemple, si vous indiquez 0,95, cela signifie que vous souhaitez que le pipeline ne déploie ce modèle que si cette métrique dépasse 95 %.

Le composant d'évaluation renvoie une chaîne qui indique s'il faut ou non déployer le modèle. Ajoutez le code suivant dans une cellule de notebook pour créer ce composant personnalisé :

@component( base_image="gcr.io/deeplearning-platform-release/tf2-cpu.2-3:latest", output_component_file="tables_eval_component.yaml", # Optional: you can use this to load the component later packages_to_install=["google-cloud-aiplatform"], ) def classif_model_eval_metrics( project: str, location: str, # "us-central1", api_endpoint: str, # "us-central1-aiplatform.googleapis.com", thresholds_dict_str: str, model: Input[Model], metrics: Output[Metrics], metricsc: Output[ClassificationMetrics], ) -> NamedTuple("Outputs", [("dep_decision", str)]): # Return parameter. """This function renders evaluation metrics for an AutoML Tabular classification model. It retrieves the classification model evaluation generated by the AutoML Tabular training process, does some parsing, and uses that info to render the ROC curve and confusion matrix for the model. It also uses given metrics threshold information and compares that to the evaluation results to determine whether the model is sufficiently accurate to deploy. """ import json import logging from google.cloud import aiplatform # Fetch model eval info def get_eval_info(client, model_name): from google.protobuf.json_format import MessageToDict response = client.list_model_evaluations(parent=model_name) metrics_list = [] metrics_string_list = [] for evaluation in response: print("model_evaluation") print(" name:", evaluation.name) print(" metrics_schema_uri:", evaluation.metrics_schema_uri) metrics = MessageToDict(evaluation._pb.metrics) for metric in metrics.keys(): logging.info("metric: %s, value: %s", metric, metrics[metric]) metrics_str = json.dumps(metrics) metrics_list.append(metrics) metrics_string_list.append(metrics_str) return ( evaluation.name, metrics_list, metrics_string_list, ) # Use the given metrics threshold(s) to determine whether the model is # accurate enough to deploy. def classification_thresholds_check(metrics_dict, thresholds_dict): for k, v in thresholds_dict.items(): logging.info("k {}, v {}".format(k, v)) if k in ["auRoc", "auPrc"]: # higher is better if metrics_dict[k] < v: # if under threshold, don't deploy logging.info( "{} < {}; returning False".format(metrics_dict[k], v) ) return False logging.info("threshold checks passed.") return True def log_metrics(metrics_list, metricsc): test_confusion_matrix = metrics_list[0]["confusionMatrix"] logging.info("rows: %s", test_confusion_matrix["rows"]) # log the ROC curve fpr = [] tpr = [] thresholds = [] for item in metrics_list[0]["confidenceMetrics"]: fpr.append(item.get("falsePositiveRate", 0.0)) tpr.append(item.get("recall", 0.0)) thresholds.append(item.get("confidenceThreshold", 0.0)) print(f"fpr: {fpr}") print(f"tpr: {tpr}") print(f"thresholds: {thresholds}") metricsc.log_roc_curve(fpr, tpr, thresholds) # log the confusion matrix annotations = [] for item in test_confusion_matrix["annotationSpecs"]: annotations.append(item["displayName"]) logging.info("confusion matrix annotations: %s", annotations) metricsc.log_confusion_matrix( annotations, test_confusion_matrix["rows"], ) # log textual metrics info as well for metric in metrics_list[0].keys(): if metric != "confidenceMetrics": val_string = json.dumps(metrics_list[0][metric]) metrics.log_metric(metric, val_string) # metrics.metadata["model_type"] = "AutoML Tabular classification" logging.getLogger().setLevel(logging.INFO) aiplatform.init(project=project) # extract the model resource name from the input Model Artifact model_resource_path = model.uri.replace("aiplatform://v1/", "") logging.info("model path: %s", model_resource_path) client_options = {"api_endpoint": api_endpoint} # Initialize client that will be used to create and send requests. client = aiplatform.gapic.ModelServiceClient(client_options=client_options) eval_name, metrics_list, metrics_str_list = get_eval_info( client, model_resource_path ) logging.info("got evaluation name: %s", eval_name) logging.info("got metrics list: %s", metrics_list) log_metrics(metrics_list, metricsc) thresholds_dict = json.loads(thresholds_dict_str) deploy = classification_thresholds_check(metrics_list[0], thresholds_dict) if deploy: dep_decision = "true" else: dep_decision = "false" logging.info("deployment decision is %s", dep_decision) return (dep_decision,)

Étape 2 : Ajoutez les composants Google Cloud prédéfinis

À cette étape, vous allez définir vos autres composants de pipeline et découvrir comment ils s'agencent.

Tout d'abord, définissez le nom à afficher de votre exécution de pipeline à l'aide d'un horodatage :

import time DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time()))) print(DISPLAY_NAME)

Ensuite, copiez le code suivant dans une nouvelle cellule de notebook :

@kfp.dsl.pipeline(name="automl-tab-beans-training-v2", pipeline_root=PIPELINE_ROOT) def pipeline( bq_source: str = "bq://aju-dev-demos.beans.beans1", display_name: str = DISPLAY_NAME, project: str = PROJECT_ID, gcp_region: str = "us-central1", api_endpoint: str = "us-central1-aiplatform.googleapis.com", thresholds_dict_str: str = '{"auRoc": 0.95}', ): dataset_create_op = gcc_aip.TabularDatasetCreateOp( project=project, display_name=display_name, bq_source=bq_source ) training_op = gcc_aip.AutoMLTabularTrainingJobRunOp( project=project, display_name=display_name, optimization_prediction_type="classification", budget_milli_node_hours=1000, column_transformations=[ {"numeric": {"column_name": "Area"}}, {"numeric": {"column_name": "Perimeter"}}, {"numeric": {"column_name": "MajorAxisLength"}}, {"numeric": {"column_name": "MinorAxisLength"}}, {"numeric": {"column_name": "AspectRation"}}, {"numeric": {"column_name": "Eccentricity"}}, {"numeric": {"column_name": "ConvexArea"}}, {"numeric": {"column_name": "EquivDiameter"}}, {"numeric": {"column_name": "Extent"}}, {"numeric": {"column_name": "Solidity"}}, {"numeric": {"column_name": "roundness"}}, {"numeric": {"column_name": "Compactness"}}, {"numeric": {"column_name": "ShapeFactor1"}}, {"numeric": {"column_name": "ShapeFactor2"}}, {"numeric": {"column_name": "ShapeFactor3"}}, {"numeric": {"column_name": "ShapeFactor4"}}, {"categorical": {"column_name": "Class"}}, ], dataset=dataset_create_op.outputs["dataset"], target_column="Class", ) model_eval_task = classif_model_eval_metrics( project, gcp_region, api_endpoint, thresholds_dict_str, training_op.outputs["model"], ) with dsl.Condition( model_eval_task.outputs["dep_decision"] == "true", name="deploy_decision", ): deploy_op = gcc_aip.ModelDeployOp( # noqa: F841 model=training_op.outputs["model"], project=project, machine_type="e2-standard-4", )

Que se passe-t-il dans ce code ?

• D'abord, comme dans le pipeline précédent, vous définissez les paramètres d'entrée du pipeline. Vous devez le faire manuellement, car ces paramètres ne dépendent pas de la sortie d'autres étapes du pipeline.

• Le reste du pipeline utilise quelques composants prédéfinis pour interagir avec les services Vertex AI :

  • TabularDatasetCreateOp crée un ensemble de données tabulaire dans Vertex AI à partir d'une source d'ensemble de données dans Cloud Storage ou BigQuery. Dans ce pipeline, vous transmettez les données via une URL de table BigQuery.
  • AutoMLTabularTrainingJobRunOp lance une tâche d'entraînement AutoML pour un ensemble de données tabulaire. Vous devez transmettre quelques paramètres de configuration à ce composant, y compris le type de modèle (dans ce cas, classification), des données sur les colonnes, la durée d'exécution souhaitée pour l'entraînement, ainsi qu'un pointeur vers l'ensemble de données. Notez que pour transmettre l'ensemble de données à ce composant, vous fournissez la sortie du composant précédent via dataset_create_op.outputs["dataset"].
  • ModelDeployOp déploie un modèle donné vers un point de terminaison dans Vertex AI. D'autres options de configuration sont disponibles, mais dans le cas présent, vous indiquez le type de machine du point de terminaison, le projet et le modèle que vous souhaitez déployer. Pour transmettre le modèle, vous accédez aux sorties de l'étape d'entraînement de votre pipeline.

• Ce pipeline utilise également la logique conditionnelle, une fonctionnalité de Vertex Pipelines qui vous permet de définir une condition ainsi que des branches différentes selon le résultat de cette condition. Souvenez-vous que lorsque vous avez défini le pipeline, vous avez transmis un paramètre thresholds_dict_str. Il s'agit du seuil de justesse qui détermine si le modèle doit être déployé sur un point de terminaison. Pour l'implémenter, utilisez la classe Condition du SDK KFP. La condition transmise est la sortie du composant d'évaluation personnalisé que vous avez défini plus tôt dans cet atelier. Si la condition est vraie, le pipeline continue d'exécuter le composant deploy_op. Si la justesse n'atteint pas le seuil prédéfini, le pipeline s'arrête et ne déploie pas le modèle.

Étape 3 : Compilez et exécutez le pipeline de ML de bout en bout

Maintenant que le pipeline est entièrement défini, il est temps de le compiler :

compiler.Compiler().compile( pipeline_func=pipeline, package_path="tab_classif_pipeline.json" )

Ensuite, lancez l'exécution du pipeline :

response = api_client.create_run_from_job_spec( "tab_classif_pipeline.json", pipeline_root=PIPELINE_ROOT, parameter_values={"project": PROJECT_ID, "display_name": DISPLAY_NAME} )

Cliquez sur le lien qui apparaît après l'exécution de la cellule ci-dessus pour afficher votre pipeline dans la console. L'exécution de ce pipeline prend un peu plus d'une heure, principalement consacrée à l'étape d'entraînement AutoML. Le pipeline terminé doit ressembler à l'exemple suivant :

Si vous activez le bouton "Développer les artefacts" en haut, vous pourrez consulter les détails des différents artefacts créés à partir de votre pipeline. Par exemple, si vous cliquez sur l'artefact dataset, vous pourrez consulter les détails de l'ensemble de données Vertex AI créé. Vous pouvez cliquer sur le lien affiché pour accéder à la page de cet ensemble de données :

De même, pour consulter les visualisations de métriques résultant de votre composant d'évaluation personnalisé, cliquez sur l'artefact nommé metricsc. Sur le côté droit du tableau de bord, vous pourrez consulter la matrice de confusion du modèle :

Pour consulter le modèle et le point de terminaison créés à partir de cette exécution de pipeline, accédez à la section dédiée aux modèles et cliquez sur le modèle nommé automl-beans. Le modèle déployé sur un point de terminaison doit s'afficher :

Vous pouvez également accéder à cette page en cliquant sur l'artefact endpoint dans le graphique du pipeline.

En plus de consulter le graphique du pipeline dans la console, vous pouvez également utiliser Vertex Pipelines pour effectuer le suivi de la traçabilité. Le suivi de la traçabilité désigne le suivi des artefacts créés via votre pipeline. Ce suivi peut vous aider à comprendre où les artefacts ont été créés et comment ils sont utilisés dans un workflow de ML. Par exemple, pour consulter le suivi de la traçabilité pour l'ensemble de données créé dans ce pipeline, cliquez sur l'artefact de l'ensemble de données, puis sur Afficher la traçabilité :

Cette option affiche tous les emplacements dans lesquels l'artefact est utilisé :

Attendez que la tâche d'entraînement du pipeline ait commencé, puis validez votre progression ci-dessous. Vérifiez si la tâche d'entraînement de votre pipeline de ML de bout en bout a démarré.

Étape 4 : Comparez les métriques de plusieurs exécutions de pipeline

Si vous exécutez ce pipeline plusieurs fois, vous pouvez chercher à comparer les métriques des différentes exécutions. La méthode aiplatform.get_pipeline_df() vous permet d'accéder aux métadonnées des exécutions. Voici comment obtenir les métadonnées de toutes les exécutions du pipeline et les charger dans un DataFrame Pandas :

pipeline_df = aiplatform.get_pipeline_df(pipeline="automl-tab-beans-training-v2") small_pipeline_df = pipeline_df.head(2) small_pipeline_df

Vous venez d'apprendre à créer et exécuter un pipeline de ML de bout en bout dans Vertex Pipelines, et à en obtenir les métadonnées.

Félicitations !

Dans cet atelier, vous avez créé et exécuté un pipeline d'emoji. Vous avez également appris à créer et exécuter un pipeline de ML de bout en bout dans Vertex Pipelines, et à en obtenir les métadonnées.

Terminer votre quête

Cet atelier d'auto-formation fait partie de la quête Building Machine Learning Solutions with Vertex AI. Une quête est une série d'ateliers associés qui constituent une formation. Si vous terminez une quête, vous obtenez un badge attestant de votre réussite. Vous pouvez rendre publics les badges que vous recevez et ajouter leur lien dans votre CV en ligne ou sur vos comptes de réseaux sociaux. Inscrivez-vous à cette quête pour obtenir immédiatement les crédits associés à cet atelier si vous l'avez suivi. Découvrez les autres quêtes disponibles dans le catalogue.

Atelier suivant

Continuez la quête "Building and Deploying Machine Learning Solutions with Vertex AI" en suivant le prochain atelier intitulé Building and Deploying Machine Learning Solutions with Vertex AI: atelier challenge.

Étapes suivantes et informations supplémentaires

Reproduisez ce scénario dans votre propre projet Google Cloud grâce à l'atelier de programmation de l'équipe Relations avec les développeurs !

• Introduction à Vertex Pipelines par Sara Robinson

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 24 janvier 2022

Dernier test de l'atelier : 4 octobre 2021

Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.