Créer un modèle à l’aide de notebooks JupyterLab
Ce tutoriel vous guide tout au long des étapes requises pour créer un modèle à l’aide du modèle de créateur de recettes des notebooks JupyterLab .
Concepts présentés :
- Recettes : une recette est un terme Adobe désignant une spécification de modèle et est un conteneur de niveau supérieur représentant un machine learning spécifique, un algorithme d’IA ou un ensemble d’algorithmes, une logique de traitement et la configuration requise pour créer et exécuter un modèle formé.
- Modèle : un modèle est une instance d’une recette de machine learning entraînée à l’aide de données historiques et de configurations dans le but de résoudre un cas d’usage commercial.
- Formation : la formation est le processus de formation de modèles et d’informations à partir de données étiquetées.
- Notation : la notation est le processus de génération d’informations à partir de données en utilisant un modèle formé.
Téléchargement des ressources requises assets
Avant de poursuivre ce tutoriel, vous devez créer les schémas et les jeux de données requis. Consultez le tutoriel sur la création de jeux de données et de schémas de modèle de propension Luma pour télécharger les ressources requises et configurer les prérequis.
Prise en main de l’environnement des notebooks JupyterLab
Vous pouvez créer une recette à partir de zéro dans Data Science Workspace. Pour commencer, accédez à Adobe Experience Platform et sélectionnez l’onglet Notebooks sur la gauche. Pour créer un notebook , sélectionnez le modèle Créateur de recettes dans la JupyterLab Launcher.
Le notebook Créateur de recettes vous permet d’exécuter des opérations de formation et de notation dans le notebook . Vous avez ainsi la possibilité d’apporter des modifications à leurs méthodes de train() et de score() entre deux expériences en cours d’exécution sur les données de formation et de notation. Une fois que vous êtes satisfait des résultats de la formation et de la notation, vous pouvez créer une recette et la publier en tant que modèle à l’aide de la fonctionnalité Recette vers modèle .
Lorsque vous sélectionnez le notebook Créateur de recettes à partir du lanceur, le notebook est ouvert dans un nouvel onglet.
Dans le nouvel onglet du notebook, en haut, une barre d’outils se charge contenant trois actions supplémentaires : Entraîner, Score et Créer une recette. Ces icônes n’apparaissent que dans le notebook Créateur de recettes. Vous trouverez plus d’informations sur ces actions dans la section Formation et notation après avoir créé votre recette dans le notebook.
Prise en main du notebook Créateur de recettes
Le dossier de ressources fourni contient un propensity_model.ipynb de modèle de propension Luma . À l’aide de l’option de chargement de notebook dans JupyterLab, chargez le modèle fourni et ouvrez le notebook.
Le reste de ce tutoriel couvre les fichiers suivants qui sont prédéfinis dans le notebook de modèle de propension :
Le tutoriel vidéo suivant explique le notebook de modèle de propension Luma :
Fichier des exigences requirements-file
Le fichier d’exigences est utilisé pour déclarer les bibliothèques supplémentaires que vous souhaitez utiliser dans le modèle. En cas de dépendance, vous pouvez spécifier le numéro de version. Pour rechercher des bibliothèques supplémentaires, visitez anaconda.org. Pour savoir comment formater le fichier d’exigences, consultez Conda. Voici une liste non exhaustive des principales bibliothèques déjà utilisées :
python=3.6.7
scikit-learn
pandas
numpy
data_access_sdk_python
name ne peut pas être remplacé.Pour le notebook de modèle de propension Luma , les exigences n’ont pas besoin d’être mises à jour.
Fichiers de configuration configuration-files
Les fichiers de configuration, training.conf et scoring.conf, servent à spécifier les jeux de données que vous souhaitez utiliser pour la formation et la notation, et à ajouter des hyperparamètres. Les configurations pour la formation et la notation sont distinctes.
Pour qu’un modèle exécute une formation, vous devez fournir les trainingDataSetId, ACP_DSW_TRAINING_XDM_SCHEMA et tenantId. En outre, pour la notation, vous devez fournir les scoringDataSetId, tenantId et scoringResultsDataSetId .
Pour trouver les identifiants du jeu de données et du schéma, accédez à l’onglet Données
scoringResultsDataSetId est utilisé pour stocker les résultats de notation du modèle et doit être un jeu de données vide. Ces jeux de données ont été créés précédemment dans l’étape Ressources requises.
Vous trouverez les mêmes informations sur Adobe Experience Platform sous les onglets Schéma et Jeu de données.
Une fois l’opération terminée, votre configuration de formation et de notation doit ressembler à la capture d’écran suivante :
Par défaut, les paramètres de configuration suivants sont définis pour vous lorsque vous entraînez et notez des données :
ML_FRAMEWORK_IMS_USER_CLIENT_IDML_FRAMEWORK_IMS_TOKENML_FRAMEWORK_IMS_ML_TOKENML_FRAMEWORK_IMS_TENANT_ID
Présentation du chargeur de données d’apprentissage training-data-loader
Le chargeur de données d’apprentissage est destiné à instancier les données utilisées pour créer le modèle de machine learning. En règle générale, le chargeur de données d’entraînement effectue deux tâches :
- Chargement des données depuis Experience Platform
- Préparation des données et ingénierie des fonctionnalités
Les deux prochaines sections traiteront du chargement et de la préparation des données.
Chargement des données loading-data
Cette étape utilise le cadre de données pandas. Les données peuvent être chargées à partir de fichiers dans Adobe Experience Platform à l’aide de Experience Platform SDK (platform_sdk) ou à partir de sources externes à l’aide des fonctions read_csv() ou read_json() de pandas.
platform_sdk.SDK Experience Platform platform-sdk
Pour un tutoriel détaillé sur l’utilisation du chargeur de données platform_sdk, consultez le guide Experience Platform SDK. Ce tutoriel fournit des informations sur l’authentification de création, la lecture et l’écriture basiques de données.
Sources externes external-sources
Cette section vous explique comment importer un fichier JSON ou CSV dans un objet pandas. La documentation officielle de la bibliothèque pandas se trouve ici :
Tout d’abord, voici un exemple d’importation d’un fichier CSV. L’argument data est le chemin d’accès au fichier CSV. Cette variable a été importée à partir de configProperties de la section précédente.
df = pd.read_csv(data)
Vous pouvez également réaliser l’importation à partir d’un fichier JSON. L’argument data est le chemin d’accès au fichier CSV. Cette variable a été importée à partir de configProperties de la section précédente.
df = pd.read_json(data)
Vos données se trouvent maintenant dans l’objet « cadre de données » et peuvent être analysées et manipulées dans la section suivante.
Fichier de chargement des données de formation
Dans cet exemple, les données sont chargées à l’aide du SDK Experience Platform. La bibliothèque peut être importée en haut de la page en incluant la ligne :
from platform_sdk.dataset_reader import DatasetReader
Vous pouvez ensuite utiliser la méthode load() pour récupérer le jeu de données d’entraînement du trainingDataSetId comme défini dans le fichier de configuration (recipe.conf).
def load(config_properties):
print("Training Data Load Start")
#########################################
# Load Data
#########################################
client_context = get_client_context(config_properties)
dataset_reader = DatasetReader(client_context, dataset_id=config_properties['trainingDataSetId'])
client_context = get_client_context(config_properties) :ML_FRAMEWORK_IMS_USER_CLIENT_IDML_FRAMEWORK_IMS_TOKENML_FRAMEWORK_IMS_ML_TOKENML_FRAMEWORK_IMS_TENANT_ID
Maintenant que vous disposez de vos données, vous pouvez commencer leur préparation ainsi que la conception des fonctionnalités.
Préparation des données et ingénierie des fonctionnalités data-preparation-and-feature-engineering
Une fois les données chargées, elles doivent être nettoyées et subir une préparation des données. Dans cet exemple, l’objectif du modèle est de prédire si un client va commander un produit ou non. Étant donné que le modèle ne s’intéresse pas à des produits spécifiques, vous n’avez pas besoin de productListItems et la colonne est donc supprimée. Ensuite, d’autres colonnes ne contenant qu’une ou deux valeurs dans une seule colonne sont ignorées. Lors de l’entraînement d’un modèle, il est important de ne conserver que les données utiles qui aideront à prédire votre objectif.
Une fois que vous avez supprimé toutes les données inutiles, vous pouvez commencer l’ingénierie des fonctionnalités. Les données de démonstration utilisées pour cet exemple ne contiennent aucune information de session. En règle générale, vous souhaiteriez disposer de données sur les sessions en cours et antérieures pour un client spécifique. En raison du manque d’informations sur la session, cet exemple imite plutôt les sessions actuelles et passées via la délimitation du parcours.
Une fois la délimitation terminée, les données sont étiquetées et un parcours est créé.
Ensuite, les fonctionnalités sont créées et divisées en passé et présent. Ensuite, toutes les colonnes inutiles sont supprimées, ce qui vous laisse avec les parcours passés et actuels pour les clients Luma. Ces parcours contiennent des informations telles que si un client a acheté un article et le parcours qu’il a effectué avant l’achat.
Chargeur de données de notation scoring-data-loader
La procédure de chargement des données pour la notation est similaire au chargement des données d’identification. En regardant attentivement le code, vous pouvez voir que tout est identique, à l’exception des scoringDataSetId dans le dataset_reader. Cela est dû au fait que la même source de données Luma est utilisée à la fois pour la formation et la notation.
Si vous souhaitez utiliser différents fichiers de données pour l’entraînement et la notation, le chargeur de données d’entraînement et de notation sont distincts. Vous pouvez ainsi effectuer un prétraitement supplémentaire, comme mapper les données de formation à vos données de notation, si nécessaire.
Fichier Pipeline pipeline-file
Le fichier pipeline.py comprend une logique de formation et de notation.
L’objectif de l’entraînement est de créer un modèle à l’aide des fonctionnalités et des libellés de votre jeu de données d’entraînement. Après avoir choisi votre modèle d’entraînement, vous devez adapter vos jeux de données d’entraînement x et y au modèle et la fonction renvoie le modèle entraîné.
La fonction score() doit contenir l’algorithme de notation et renvoyer une mesure pour indiquer le degré de réussite du modèle. La fonction score() utilise les étiquettes des jeux de données de notation et le modèle formé pour générer un ensemble de fonctionnalités prédites. Ces valeurs prédites sont ensuite comparées aux fonctionnalités réelles du jeu de données de notation. Dans cet exemple, la fonction score() utilise le modèle formé pour prédire les fonctionnalités à l’aide des étiquettes du jeu de données de notation. Les fonctionnalités prédites sont renvoyées.
Fichier Evaluator evaluator-file
Le fichier evaluator.py contient une logique sur la manière dont vous souhaitez évaluer votre recette entraînée et sur la manière dont vos données d’entraînement doivent être fractionnées.
Fractionnement du jeu de données split-the-dataset
La phase de préparation des données pour la formation nécessite de fractionner le jeu de données à utiliser pour la formation et les tests. Ces données val sont utilisées implicitement pour évaluer le modèle après son entraînement. Il s’agit d’un processus distinct de celui de notation.
Cette section présente la fonction split() qui charge les données dans le notebook, puis nettoie les données en supprimant les colonnes non liées dans le jeu de données. À partir de là, vous pouvez effectuer l’ingénierie des fonctionnalités qui est le processus de création de fonctionnalités pertinentes supplémentaires à partir des fonctionnalités brutes existantes dans les données.
Évaluation du modèle formé evaluate-the-trained-model
La fonction evaluate() est exécutée après l’entraînement du modèle et renvoie une mesure pour indiquer la réussite des performances du modèle. La fonction evaluate() utilise les libellés du jeu de données de test et le modèle entraîné pour prédire un ensemble de fonctionnalités. Ces valeurs prédites sont ensuite comparées aux fonctionnalités réelles du jeu de données de test. Dans cet exemple, les mesures utilisées sont precision, recall, f1 et accuracy. Vous remarquerez que la fonction renvoie un objet metric contenant un tableau de mesures d’évaluation. Ces mesures sont utilisées pour évaluer les performances du modèle formé.
L’ajout de print(metric) vous permet d’afficher les résultats de la mesure.
Fichier Data Saver data-saver-file
Le fichier datasaver.py contient la fonction save() et est utilisé pour enregistrer votre prédiction lors du test de la notation. La fonction save() récupère votre prédiction et écrit les données dans le scoringResultsDataSetId spécifié dans votre fichier scoring.conf à l’aide des API Experience Platform Catalog. Vous pouvez
Formation et notation training-and-scoring
Lorsque vous avez terminé d’apporter des modifications à votre notebook et que vous souhaitez entraîner votre recette, vous pouvez sélectionner les boutons associés dans la partie supérieure de la barre pour créer une exécution d’entraînement dans la cellule. Lorsque vous sélectionnez le bouton, un journal des commandes et des sorties du script d’entraînement s’affiche dans le notebook (sous la cellule evaluator.py). Conda installe d’abord toutes les dépendances, puis la formation commence.
Remarque : vous devez exécuter la formation au moins une fois avant de pouvoir exécuter la notation. Cliquer sur le bouton Exécuter le score attribuera un score au modèle formé généré pendant l’entraînement. Le script de notation apparaît sous datasaver.py.
À des fins de débogage, si vous souhaitez afficher la sortie masquée, ajoutez debug à la fin de la cellule de sortie et exécutez-la de nouveau.
Créer une recette create-recipe
Une fois la modification de la recette terminée et le résultat de la formation/du score satisfait, vous pouvez créer une recette à partir du notebook en sélectionnant Créer une recette dans le coin supérieur droit.
Après avoir sélectionné Créer une recette, vous êtes invité à saisir un nom de recette. Ce nom représente la recette réelle créée le Experience Platform.
Une fois que vous avez sélectionné Ok, le processus de création de recette commence. Cela peut prendre un certain temps et une barre de progression s’affiche à la place du bouton Créer une recette . Une fois l’opération terminée, cliquez sur le bouton Afficher les recettes pour accéder à l’onglet Recettes sous Modèles ML
- Ne supprimer aucune cellule de fichier
- Ne pas modifier la ligne
%%writefileen haut des cellules de fichier - Ne pas créer plusieurs recettes dans différents cahiers simultanément
Étapes suivantes next-steps
En suivant ce tutoriel, vous avez appris à créer un modèle de machine learning dans le notebook Créateur de recettes. Vous avez également appris à faire fonctionner le workflow notebook vers recette.
Pour continuer à apprendre à utiliser les ressources dans Data Science Workspace, consultez le menu déroulant Data Science Workspace des recettes et des modèles .