MLflow Tracking : Une façon efficace de suivre les essais de modélisation

Par : Mihir Gajjar, Statistique Canada
Collaborateurs : Reginald Maltais, Allie Maclsaac, Claudia Mokbel et Jeremy Solomon, Statistique Canada

MLflow (le contenu de cette page est en anglais) est une plateforme en source ouverte qui permet de gérer le cycle de vie d'apprentissage automatique, notamment l'expérimentation, la reproductibilité, le déploiement et un registre de modèles central. MLflow propose quatre composantes :

• MLflow Tracking : enregistrement et interrogation d'essais : code, données, paramètres de configuration et résultats.
• MLflow Projects : assemblage de code de science des données en un format permettant de reproduire les passages sur n'importe quelle plateforme.
• MLflow Models : déploiement de modèles d'apprentissage automatique dans divers environnements d'utilisation.
• Model Registry : stockage, annotation, découverte et gestion de modèles au sein d'un répertoire central.

Cet article se concentre sur MLflow Tracking. Le site Web de MLflow détaille les trois autres composantes.

Avantages de MLFlow

MLflow Tracking offre une solution pouvant être adaptée de votre machine locale à l'entreprise entière. Cela permet aux scientifiques des données de commencer sur leur machine locale, alors que les organisations peuvent mettre en œuvre une solution veillant à la maintenabilité à long terme et à la transparence au sein d'un répertoire central.

MLflow Tracking fournit des capacités de suivi cohérentes et transparentes en :

• effectuant le suivi programmatique des paramètres et des résultats correspondants pour les essais de modélisation et en les comparant à l'aide d'une interface utilisateur;
• récupérant le modèle présentant les meilleurs résultats ainsi que son code correspondant, pour diverses mesures d'intérêt pour tous les essais de différents projets;
• regardant temporellement en arrière, afin de relever des essais effectués avec certaines valeurs de paramètres;
• permettant aux membres de l'équipe de procéder à des essais et de faire part des résultats en collaboration;
• exposant à l'intention de la direction l'état d'avancement de plusieurs projets au sein d'une seule interface ainsi que tous les détails (paramètres, tracé des résultats, mesures, etc.);
• permettant le suivi pour tous les passages et paramètres au moyen d'un simple carnet; ce qui réduit le temps passé à gérer du code et diverses versions de carnet;
• fournissant une interface permettant le suivi d'essais basés sur Python et R.

Comment passer d'un essai à un autre avec MLflow?

Cet article se concentre sur l'utilisation de MLflow avec Python. Le document QuickStart (le contenu de cette page est en anglais) relatif à MLflow présente des exemples de son utilisation avec R pour une installation locale sur une seule machine. Les organisations souhaitant déployer MLflow entre des équipes peuvent également se reporter à ce document QuickStart.

Le présent article explore un exemple d'utilisation de MLflow avec Python; toutefois, pour bien comprendre le fonctionnement de MLFlow, il est utile d'effectuer chaque étape sur votre machine.

Installation de MLflow

MLflow peut s'installer comme progiciel Python standard en entrant la commande suivante dans une fenêtre de terminal :

$ pip install mlflow

Une fois l'exécution de la commande terminée, vous pouvez entrer mlflow sur votre terminal et explorer les options disponibles. Vous pouvez essayer, par exemple : mlflow –version , pour vérifier la version installée.

Lancement du serveur MLflow

Il est recommandé de disposer d'un serveur MLflow centralisé pour une personne, une équipe ou une organisation, afin que les passages pour différents projets puissent être journalisés à un emplacement central, en les isolant par essai (différents essais pour différents projets). Nous discutons plus en détail de ces questions plus loin dans le présent article. Pour commencer rapidement à utiliser l'outil, vous pouvez ignorer le lancement du serveur et journaliser tout de même les passages. Ce faisant, les passages sont enregistrés dans un répertoire intitulé « MLruns », dans le même répertoire que le code. Vous pouvez plus tard ouvrir l'interface utilisateur de MLflow en suivant le même chemin d'accès et visualiser les passages journalisés.

Les passages peuvent être journalisés sur un serveur MLflow exécuté localement ou à distance en configurant l'adresse URI (identifiant uniforme de ressource) adéquate de suivi. La configuration de l'emplacement de journalisation adéquat est expliquée plus bas.

Si vous préférez toutefois lancer le serveur immédiatement, vous pouvez le faire en entrant la commande suivante :

$ mlflow server

Le terminal affichera des renseignements similaires à ceux présentés ci-dessous, qui montrent que le serveur écoute au port de serveur local 5000. Cette adresse est utile pour accéder à l'interface utilisateur (IU) de MLflow. N'hésitez pas à explorer la différence subtile entre l'IU de MLflow et le serveur de MLflow dans les documents relatifs à MLflow Tracking (le contenu de cette page est en anglais).

[2021-07-09 16:17:11 –0400] [58373] [INFO] Starting gunicorn 20.1.0
[2021-07-09 16:17:11 –0400] [58373] [INFO] Listening at: http://127.0.0.1:5000 (58373)
[2021-07-09 16:17:11 –0400] [58373] [INFO] Using worker: sync
[2021-07-09 16:17:11 –0400] [58374] [INFO] Booting worker with pid: 58374
[2021-07-09 16:17:11 –0400] [58375] [INFO] Booting worker with pid: 58375
[2021-07-09 16:17:11 –0400] [58376] [INFO] Booting worker with pid: 58376
[2021-07-09 16:17:11 –0400] [58377] [INFO] Booting worker with pid: 58377

Journalisation des données dans MLflow

Deux principaux concepts sous-tendent le suivi avec MLflow : les essais et les passages. Les données journalisées au cours d'un essai sont enregistrées sous forme de passage dans MLflow. Ces passages peuvent être organisés en essai; ce qui regroupe les passages pour une tâche particulière. On peut alors visualiser, rechercher, comparer et télécharger les artéfacts et métadonnées de passages pour les passages journalisés dans le cadre d'un essai MLflow.

Les données d'un essai peuvent être journalisées comme passage dans MLflow à l'aide de progiciels MLflow Python, R ou Java ou au moyen de l'IPA (interface de programmation d'applications) REST.

Le présent article fait la démonstration de la modélisation d'un des concours de mise en route de TLN (traitement du langage naturel) sur Kaggle intitulé « Natural Language Processing with Disaster Tweets (le contenu de cette page est en anglais) ». On utilise un carnet Jupyter et l'IPA Python de MLflow pour journaliser des données dans MLflow. Nous mettrons l'accent sur la démonstration de la façon de journaliser des données dans MLflow au cours de la modélisation, plutôt que sur l'obtention des meilleurs résultats de modélisation.

Tout d'abord, commençons par le processus de modélisation habituel, qui inclut des importations, la lecture de données, le prétraitement de texte, les caractéristiques de pondération rtf-idf (term frequency-inverse document frequency) et le modèle de machine à vecteurs de support (SVM). À la fin, une section sera intitulée « Journalisation dans MLflow ».

Importation des bibliothèques

Commencez par importer toutes les bibliothèques requises par l'exemple :

# To create unique run name.
import time
# To load data in pandas dataframe.
import pandas as pd

# NLP libraries

# To perform lemmatization
from nltk import WordNetLemmatizer
# To split text into words
from nltk. tokenize import word_tokenize
# To remove the stopwords
from nltk.corpus import stopwords

# Scikit-learn libraries

# To use the SVC model
from sklearn.svm import SVC
# To evaluate model performance
from sklearn.model_selection import cross_validate, StratifiedkFold
# To perform Tf-idf vectorization
from sklearn.feature_extraction.text import TfidfVectorizer
# To get the performance metrics
from sklearn.metrics import f1_score, make_scorer
# For logging and tracking experiments
import mlflow

Création d'un nom de passage unique

MLflow permet de suivre plusieurs passages d'un essai grâce à un paramètre de nom de passage. Le nom du passage peut être défini comme toute valeur, mais devrait être unique, afin de pouvoir être identifié ensuite parmi les différents passages. Ci-dessous, un horodatage est utilisé comme nom unique.

run_name = str(int(time.time()))
print('Run name: ', run_name)

On obtient :

Nom de passage : 1625604741 

Lecture des données

Chargez la formation et les données de test à partir des fichiers CSV fournis pour l'exemple.

# Kaggle competition data download link: https://www.kaggle.com/c/nlp-getting-started/data
train_data = pd.read_csv("./data/train.csv")
test_data = pd.read_csv("./data/test.csv")

En exécutant la portion de code suivant dans une cellule :

train_data

La figure 1 présente un exemple de données de formation venant d'être chargées.

Figure 1 : Aperçu des données de formation chargées

Les données de formation représentent environ 70 % des données totales.

print('The length of the training data is %d' % len(train_data))
print('The length of the test data is %d' % len(test_data))

Produit :

The length of the training data is 7613
The length of the test data is 3263

Prétraitement de texte

Selon la tâche à réaliser, différents types d'étapes de prétraitement peuvent être nécessaires pour que le modèle d'apprentissage automatique apprenne de meilleures caractéristiques. Le prétraitement peut normaliser les intrants, supprimer certains mots courants, le cas échéant, de sorte que le modèle ne les apprenne pas comme des caractéristiques, et apporter des modifications logiques et utiles pouvant mener à une amélioration du rendement et de la généralisation du modèle. La section suivante montre comment des étapes de prétraitement peuvent aider le modèle à capturer les caractéristiques pertinentes au cours de l'apprentissage.

def clean_text(text):
    # split into words
    tokens = word_tokenize(text)
    # remove all tokens that are not alphanumeric. Can also use .isalpha() here if do not want to keep numbers.
    words = [word for word in tokens if word.isalnum()]
    # remove stopwords
    stop_words = stopwords.words('english')
    words = [word for word in words if word not in stop_words]
    # performing lemmatization
    wordnet_lemmatizer = WordNetLemmatizer()
    words = [wordnet_lemmatizer.lemmatize(word) for word in words]
    # Converting list of words to string
    words = ' '.join(words)
    return words

train_data['cleaned_text'] = train_data['text'].apply(clean_text) 

Lors de la comparaison du texte d'origine et du texte nettoyé, les pseudo-mots ont été supprimés :

train_data['text'].iloc[100]

'.@NorwayMFA #Bahrain police had previously died in a road accident they were not killed by explosion https://t.co/gFJfgTodad (en anglais seulement)'

train_data['cleaned_text'].iloc[100]rain_data['text'].iloc[100]

'NorwayMFA Bahrain police previously died road accident killed explosion http'

À la lecture du texte ci-dessus, on peut dire qu'il contient des renseignements sur une catastrophe et devrait donc être classé comme tel. Pour confirmer cela avec les données, imprimez l'étiquette présente dans le fichier CSV relatif à ce tweet :

train_data['target'].iloc[100]

Produit :

1

Caractéristiques Tf-idf

Ensuite, nous convertissons une collection de documents bruts vers une matrice de caractéristiques TF-IDF en vue d'alimenter le modèle. Pour de plus amples détails sur tf-idf, reportez-vous aux documents TF–IDF - Wikipédia and scikit-learn sklearn.feature_extraction.text (le contenu de cette page est en anglais).

ngram_range=(1,1)
max_features=100
norm='l2'

tfidf_vectorizer = TfidfVectorizer(ngram_range=ngram_range, max_features=max_features, norm=norm)

train_data_tfidf = tfidf_vectorizer.fit_transform(train_data['cleaned_text'])
train_data_tfidf

Produit :

<7613x100 sparse matrix of type '<class 'numpy.float64'>'
with 15838 stored elements in Compressed Sparse Row format>

tfidf_vectorizer.get_feature_names()[:10]

Produit :

['accident',
'amp',
'and',
'as',
'attack',
'back',
'best',
'body',
'bomb',
'building']

Modèle SVC

L'étape suivante de la modélisation est d'ajuster un modèle et d'évaluer son rendement.

On utilise un programme de validation croisée K-Folds stratifié pour évaluer le modèle. Voir scikit learn sklearn.model_selection (le contenu de cette page est en anglais) pour de plus amples détails.

strat_k_fold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

Faire fonctionner un programme de calcul de résultat à l'aide de la mesure f1-score pour l'utiliser comme paramètre dans le modèle SVC.

scoring_function_f1 = make_scorer(f1_score, pos_label=1, average='binary')

Vient ensuite une étape importante pour adapter le modèle aux données. Dans cet exemple, le classificateur SVC est utilisé. Voir scikit learn sklearn.svm.svc (le contenu de cette page est en anglais) pour de plus amples détails.

C = 1.0
kernel='poly'
max_iter=-1
random_state=42

svc = SVC(C=C, kernel=kernel, max_iter=max_iter, random_state=random_state) 
cv_results = cross_validate(estimator=svc, X=train_data_tfidf, y=train_data['target'], scoring=scoring_function_f1, cv=strat_k_fold, n_jobs=-1, return_train_score=True)
cv_results

Produit :

{'fit_time': array([0.99043322, 0.99829006, 0.94024873, 0.97373009, 0.96771407]),
'score_time': array([0.13656974, 0.1343472 , 0.13345313, 0.13198996, 0.13271189]),
'test_score': array([0.60486891, 0.65035517, 0.5557656 , 0.5426945 , 0.63071895]),
'train_score': array([0.71281362, 0.76168757, 0.71334394, 0.7291713 , 0.75554698])}

def mean_sd_cv_results(cv_results, metric='F1'):
    print(f"{metric} Train CV results: {cv_results['train_score'].mean().round(3)} +- {cv_results['train_score'].std().round(3)}")
    print(f"{metric} Val CV results: {cv_results['test_score'].mean().round(3)} +- {cv_results['test_score'].std().round(3)}")

mean_sd_cv_results(cv_results)

F1 Train CV results: 0.735 +- 0.021
F1 Val CV results: 0.597 +- 0.042

! Jupyter nbconvert --to html mlflow-example-real-or-not-disaster-tweets-modeling-SVC.ipynb

[NbConvertApp] Converting notebook mlflow-example-real-or-not-disaster-tweets-modeling-SVC.ipynb to html
[NbConvertApp] Writing 610630 bytes to mlflow-example-real-or-not-disaster-tweets-modeling-SVC.html

Journalisation dans MLflow

Tout d'abord, configurez le serveur URI. Le serveur s'exécutant localement, définissez l'URI de suivi comme port de serveur local 5000. L'URI de suivi peut être configurée pour un serveur distant également (voir : Where Runs are Recorded [le contenu de cette page est en anglais]).

server_uri = 'http://127.0.0.1:5000'
mlflow.set_tracking_uri(server_uri)

Pour organiser les passages, un essai a été créé et défini à l'emplacement où les passages seront journalisés. La méthode « set_experiment » créera un nouveau passage avec le nom de chaîne fourni et le définira comme l'essai en cours pour lequel les passages seront journalisés.

mlflow.set_experiment('nlp_with_disaster_tweets')

Enfin, lancez un passage et journalisez les données dans MLflow.

# MLflow logging.
with mlflow.start_run(run_name=run_name) as run:

    # Logging tags
    # run_name.
    mlflow.set_tag(key='Run name', value=run_name)
    # Goal.
    mlflow.set_tag(key='Goal', value='Check model performance and decide whether we require further pre-processing/hyper-parameter tuning.')
    # Modeling exp.
    mlflow.set_tag(key='Modeling technique', value='SVC')

    # Logging parameters
    mlflow.log_param(key='ngram_range', value=ngram_range)
    mlflow.log_param(key='max_features', value=max_features)
    mlflow.log_param(key='norm', value=norm)
    mlflow.log_param(key='C', value=C)
    mlflow.log_param(key='kernel', value=kernel)
    mlflow.log_param(key='max_iter', value=max_iter)
    mlflow.log_param(key='random_state', value=random_state)

    # Logging the SVC model.
    mlflow.sklearn.log_model(sk_model=svc, artifact_path='svc_model')
   
    # Logging metrics.
    # mean F1-score - train.
    mlflow.log_metric(key='mean F1-score - train', value=cv_results['train_score'].mean().round(3))
    # mean F1-score - val.
    mlflow.log_metric(key='mean F1-score - val', value=cv_results['test_score'].mean().round(3))
    # std F1-score - train.
    mlflow.log_metric(key='std F1-score - train', value=cv_results['train_score'].std().round(3))
    # std F1-score - val.
    mlflow.log_metric(key='std F1-score - val', value=cv_results['test_score'].std().round(3))
   
    # Logging the notebook.
    # Nb.
    mlflow.log_artifact(local_path='real-or-not-disaster-tweets-modeling-SVC.ipynb', artifact_path='Notebook')
    # Nb in HTML.
    mlflow.log_artifact(local_path='real-or-not-disaster-tweets-modeling-SVC.html', artifact_path='Notebook')

Selon le code ci-dessus, vous commencez un passage avec un nom de passage (run_name), puis journalisez ce qui suit :

1. Balises : paire clé-valeur. La clé et la valeur sont toutes deux des chaînes; par exemple, cela peut servir à journaliser l'objectif du passage pour lequel la clé serait « Goal: » et la valeur peut être « To try out the performance of Random Forest Classifier with default parameters » (mettre à l'essai le rendement d'un classificateur de forêt aléatoire avec des paramètres par défaut).
2. Paramètres : également une paire clé-valeur pouvant servir à journaliser les paramètres du modèle.
3. Modèle : peut servir à journaliser le modèle. Vous journalisez ici un modèle scikit-learn comme artéfact MLflow, mais nous pouvons également journaliser un modèle pour d'autres bibliothèques d'apprentissage automatique pris en charge à l'aide du module MLflow correspondant.
4. Mesures : paire clé-valeur. Le type de données de clé est « string » (chaîne) et peut avoir le nom de la mesure. Le paramètre de valeur est de type de données « float ». Le troisième paramètre facultatif est « step » qui est un nombre entier représentant toute mesure de progression de la formation : nombre d'itération de formation, nombre d'époques, etc.
5. Artéfacts : un fichier ou répertoire local peut être journalisé comme artéfact pour le passage en cours. Dans cet exemple, nous journalisons à l'aide du carnet, de sorte que ces informations sont accessibles pour des passages futurs. Ce faisant, il est possible d'enregistrer un tracé comme « courbe de perte » ou « courbe de précision » dans le code et le journaliser comme artéfact dans MLflow.

Voilà, vous avez journalisé avec succès les données pour un passage dans MLflow! L'étape suivante est de visualiser les données journalisées.

IU de MLflow

Si vous retournez à la figure 1, vous vous souviendrez que vous avez lancé le serveur et qu'il écoutait au port de serveur local 5000. Ouvrez cette adresse dans votre navigateur préféré pour accéder à l'IU de MLflow. Une fois l'IU de Mlflow visible, vous pouvez utiliser l'interface pour consulter les données d'essai journalisées. Les essais créés s'affichent dans la barre latérale de l'IU et les balises, paramètres, modèle et mesures journalisés figurent dans les colonnes.

Figure 2 : IU de MLflow

Pour explorer un passage particulier plus en détail, cliquez sur le passage pertinent dans la colonne Heure de début. Cela permet d'explorer un passage journalisé en détail. Le nom du passage s'affiche et vous pouvez ajouter des notes relatives au passage, comme les paramètres, mesures, balises et artéfacts journalisés. Les données journalisées à l'aide de l'API Python pour ce passage figurent ici.

Les fichiers journalisés comme artéfacts peuvent être téléchargés; ce qui peut être utile si vous souhaitez extraire le code ultérieurement. Puisque le code ayant généré des résultats pour chaque passage est enregistré, vous n'avez pas à créer plusieurs copies du même code et pouvez expérimenter avec un seul carnet-cadre en changeant le code entre les passages.

Le modèle formé journalisé peut être chargé dans un essai futur à l'aide de l'IPA Python pour le passage journalisé.

Figure 3: Exploration des artéfacts journalisés dans un passage

Pour démontrer la fonctionnalité de comparaison de passages, d'autres essais de modélisation ont été effectués et journalisés dans MLflow en changeant quelques paramètres dans le même carnet jupyter. N'hésitez pas à modifier certains paramètres et à journaliser davantage de passages dans MLflow.

La figure 4 présente les différents passages journalisés. Vous pouvez appliquer un filtre, conserver les colonnes souhaitées et comparer les paramètres ou les mesures entre les différents passages. Pour procéder à une comparaison détaillée, vous pouvez sélectionner les passages que vous souhaitez comparer et cliquer sur le bouton « Comparer » encerclé dans la figure ci-dessous.

Figure 4 : Personnalisation et comparaison de différents passages à l'aide de l'IU de MLflow

Après avoir cliqué sur le bouton « Comparer », une comparaison sous forme de tableau entre différents passages est générée (comme le présente la figure 5), permettant de facilement comparer les données journalisées pour différents passages. Les paramètres qui diffèrent entre les passages sont surlignés en jaune. Cela fournit à l'utilisateur une idée de la façon dont le rendement du modèle a varié au fil du temps en fonction des paramètres modifiés.

Figure 5 : Comparaison détaillée de passages journalisés dans l'IU de MLflow

Des changements dans les paramètres et dans les mesures pour différents passages peuvent également être présentés dans un diagramme de dispersion. Les valeurs des axes des x et des y peuvent être définies comme tout paramètre ou toute mesure permettant à l'utilisateur d'analyser les changements. Dans la figure 6, le lecteur peut analyser la variation de la validation; dans ce cas, le F1-score moyen pour différentes valeurs du paramètre « max_features ». Si vous passez le curseur sur un point de donnée, les détails relatifs à ce passage s'affichent.

Figure 6 : Configuration du diagramme de dispersion pour visualiser les effets des différentes configurations de paramètres dans les passages journalisés

Le diagramme à coordonnées parallèles est également utile, car il présente à l'utilisateur d'un seul coup d'œil l'effet de certains paramètres sur les mesures souhaitées.

Figure 7 : Configuration du diagramme à coordonnées parallèles pour visualiser les effets de différents paramètres sur les mesures d'intérêt

Autres aspects intéressants du suivi avec MLflow Tracking

Autres éléments importants à noter relativement à MLflow Tracking :

• Les passages peuvent être directement exportés dans un fichier CSV à l'aide de l'IU de MLflow.
• Il est possible d'accéder à l'aide d'un programme à toutes les fonctions de l'IU de suivi; vous pouvez interroger et comparer les passages avec du code, charger des artéfacts de passages journalisés ou exécuter une recherche automatisée de paramètre en appliquant une requête sur les mesures de passages journalisés pour décider des nouveaux paramètres. Vous pouvez également journaliser de nouvelles données sur un passage déjà journalisé dans un essai après l'avoir chargé à l'aide d'un programme (consultez Querying Runs Programmatically pour de plus amples détails - le contenu de cette page est en anglais).
• En utilisant l'IU de MLflow, les utilisateurs peuvent rechercher des passages présentant des valeurs de données particulières à partir de la barre de recherche. Un exemple de cela serait d'utiliser metrics.rmse < 1 et params.model='tree'. Cela est très utile lorsque vous avez besoin de trouver un passage à paramètres particuliers exécuté par le passé.
• Le carnet Jupyter utilisé comme exemple dans ce billet de blogue est accessible sur GitHub (le contenu de cette page est en anglais).

N'hésitez pas à communiquer avec nous à l'adresse statcan.dsnfps-rsdfpf.statcan@statcan.gc.ca pour nous faire part d'autres fonctionnalités intéressantes ou cas d'utilisation que vous aimez utiliser qui auraient pu être mentionnés selon vous. Nous vous offrirons également l'occasion de rencontrer le scientifique des données pour discuter de MLFlow plus en détail. Trouvez de plus amples détails ci-dessous.