Création d’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 de notebooks JupyterLab.

Concepts présentés :

• Recettes : Une recette est le terme utilisé par l’Adobe pour désigner une spécification de modèle. Il s’agit d’un conteneur de niveau supérieur qui représente un apprentissage automatique spécifique, un algorithme d’intelligence artificielle ou un ensemble d’algorithmes, une logique de traitement et la configuration nécessaires 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 de connaissances à 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

Avant de poursuivre ce tutoriel, vous devez créer les schémas et les jeux de données requis. Consultez le tutoriel pour création de schémas et de jeux de données de modèle de propension Luma pour télécharger les ressources requises et configurer les conditions préalables requises.

Prise en main de la fonction JupyterLab environnement de notebook

La création d’une recette à partir de zéro peut être effectuée dans Data Science Workspace. Pour commencer, accédez à Adobe Experience Platform et sélectionnez la variable Notebooks de gauche. Pour créer un nouveau notebook, sélectionnez le modèle Recipe Builder dans le JupyterLab Launcher.

Le Créateur de recettes notebook 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 outre en tant que modèle à l’aide de la fonctionnalité de modèle de la recette.

Lorsque vous sélectionnez la variable Créateur de recettes depuis le lanceur, le notebook est ouvert dans un nouvel onglet.

Dans le nouvel onglet du notebook situé en haut, une barre d’outils se charge et contient trois actions supplémentaires : Train, Score, et Créer une recette. Ces icônes s’affichent uniquement dans la Créateur de recettes notebook. Des informations supplémentaires sur ces actions sont fournies dans la section formation et notation après avoir créé votre recette dans le notebook.

Prise en main de la fonction Créateur de recettes notebook

Dans le dossier des ressources fournies, il existe un modèle de propension Luma. propensity_model.ipynb. À 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 prédéfinis dans le notebook du modèle de propension :

• Fichier des exigences
• Fichiers de configuration
• Chargeur de données d’apprentissage
• Chargeur de données de notation
• Fichier Pipeline
• Fichier Evaluator
• Fichier Data Saver

Le tutoriel vidéo suivant explique le notebook du modèle de propension Luma :

Fichier des exigences

Le fichier des 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 d’autres bibliothèques, rendez-vous sur la page anaconda.org. Pour savoir comment formater le fichier des exigences, consultez la page 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

Pour le notebook de modèle de propension Luma, les exigences n’ont pas besoin d’être mises à jour.

Fichiers de configuration

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 puisse exécuter une formation, vous devez fournir la variable trainingDataSetId, ACP_DSW_TRAINING_XDM_SCHEMA, et tenantId. En outre, pour la notation, vous devez fournir la variable scoringDataSetId, tenantId, et scoringResultsDataSetId .

Pour trouver le jeu de données et les identifiants de schéma, accédez à l’onglet données . dans les notebooks sur la barre de navigation de gauche (sous l’icône de dossier). Trois identifiants de jeu de données différents doivent être fournis. Le 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 la variable Ressources requises étape .

Vous trouverez les mêmes informations sur Adobe Experience Platform sous les onglets Schéma et Jeu de données.

Une fois que vous êtes en compétition, 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_ID
• ML_FRAMEWORK_IMS_TOKEN
• ML_FRAMEWORK_IMS_ML_TOKEN
• ML_FRAMEWORK_IMS_TENANT_ID

Présentation du chargeur de données d’apprentissage

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’apprentissage exécute deux tâches :

• Charger des données depuis 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

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 la fonction Platform SDK (platform_sdk), ou provenant de sources externes utilisant pandas' read_csv() ou read_json() fonctions.

• Platform SDK
• Sources externes

SDK Platform

Pour un tutoriel détaillé sur l’utilisation du chargeur de données platform_sdk, consultez le guide SDK Platform. Ce tutoriel fournit des informations sur l’authentification de création, la lecture et l’écriture basiques de données.

Sources externes

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 :

• read_csv
• read_json

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 chargeur de données d’apprentissage

Dans cet exemple, les données sont chargées à l’aide du SDK 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 variable load() pour récupérer le jeu de données d’apprentissage à partir de la méthode trainingDataSetId comme défini dans la 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'])

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

Une fois les données chargées, elles doivent être nettoyées et préparé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 tient pas compte de produits spécifiques, vous n’avez pas besoin de productListItems et, par conséquent, la colonne est supprimée. Ensuite, des colonnes supplémentaires sont ignorées, qui ne contiennent qu’une ou deux valeurs dans une seule colonne. Lors de la formation d’un modèle, il est important de ne conserver que des données utiles qui aideront à prédire votre objectif.

Une fois que vous avez supprimé les données inutiles, vous pouvez commencer la conception des fonctionnalités. Les données de démonstration utilisées pour cet exemple ne contiennent aucune information de session. Normalement, vous souhaitez obtenir des données sur les sessions en cours et passées pour un client particulier. En raison de l’absence d’informations sur les sessions, cet exemple reproduit les sessions en cours et passées par le biais de la démarcation des parcours.

Une fois la démarcation terminée, les données sont étiquetées et un parcours est créé.

Ensuite, les fonctionnalités sont créées et divisées entre le passé et le présent. Ensuite, toutes les colonnes inutiles sont ignoré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 pris avant l’achat.

Chargeur de données de notation

La procédure de chargement des données pour la notation est similaire au chargement des données de formation. En regardant attentivement le code, vous pouvez voir que tout est identique, à l’exception de la fonction scoringDataSetId dans le dataset_reader. En effet, la même source de données Luma est utilisée pour la formation et la notation.

Si vous souhaitez utiliser différents fichiers de données pour la formation et la notation, le chargeur de données de formation et de notation est distinct. Cela vous permet d’effectuer un pré-traitement supplémentaire, par exemple de mapper vos données de formation à vos données de notation si nécessaire.

Fichier Pipeline

Le fichier pipeline.py inclut la logique de formation et de notation.

L’objectif de la formation est de créer un modèle à l’aide des fonctionnalités et des étiquettes présentes dans votre jeu de données d’apprentissage. Après avoir choisi votre modèle de formation, vous devez adapter votre jeu de données de formation x et y au modèle, et la fonction renvoie le modèle formé.

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

Le fichier evaluator.py contient la logique de la manière dont vous souhaitez évaluer votre recette formée ainsi que la manière dont vos données d’apprentissage doivent être fractionnées.

Fractionnement du jeu de données

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. Ceci val Les données sont utilisées implicitement pour évaluer le modèle après sa formation. Il s’agit d’un processus distinct de celui de notation.

Cette section présente les split() qui charge des données dans le notebook, puis nettoie les données en supprimant les colonnes non liées dans le jeu de données. De là, vous pouvez concevoir des fonctionnalités, ce 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é

Le evaluate() est exécutée après la formation du modèle et renvoie une mesure pour indiquer le degré de réussite du modèle. Le evaluate() utilise les étiquettes des jeux de données de test et le modèle formé 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 les suivantes : 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é.

Ajouter print(metric) vous permet d’afficher les résultats de la mesure.

Fichier Data Saver

Le datasaver.py contient le fichier save() et est utilisée pour enregistrer votre prédiction lors du test de notation. Le save() utilise votre prédiction et Experience Platform Catalog Les API écrivent les données dans la variable scoringResultsDataSetId que vous avez spécifié dans votre scoring.conf fichier . Vous pouvez

Formation et notation

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 en haut de la barre pour créer une session d’entraînement dans la cellule. Lorsque vous cliquez sur le bouton, un journal des commandes et des sorties issues du script de formation s’affiche dans le notebook (sous 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. En sélectionnant le Exécuter la notation noter le modèle formé généré pendant la formation. 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éation d’une recette

Lorsque vous avez terminé de modifier la recette et que vous êtes satisfait du résultat de formation/notation, vous pouvez créer une recette à partir du notebook en sélectionnant Créer une recette en haut à droite.

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 sur Platform.

Une fois que vous avez sélectionné Ok, le processus de création de la recette commence. Cela peut prendre du temps et une barre de progression s’affiche à la place du bouton Créer une recette . Une fois l’opération terminée, vous pouvez sélectionner la variable Afficher les recettes pour accéder au Recettes sous Modèles ML

Étapes suivantes

En suivant ce tutoriel, vous avez appris à créer un modèle d’apprentissage automatique dans le Créateur de recettes notebook. Vous avez également appris à utiliser le notebook pour le workflow de recette.

Pour continuer à apprendre à utiliser les ressources dans Data Science Workspace, rendez-vous sur la page Data Science Workspace menu déroulant recettes et modèles.

Ressources Business.Adobe.com