Vos expériences de ML sont-elles un gâchis ? Voici le correctif

un nouveau modèle. Vous obtenez des résultats de base décents avec un modèle simple, mais essayez d’améliorer les performances avec des modèles plus avancés. Au cours du développement, votre PM acquiert des données supplémentaires qui pourraient s’avérer utiles et peut désormais revenir à un modèle plus simple. Après un réglage approfondi des hyperparamètres, vous consultez votre équipe et elle vous conseille d’optimiser pour une mesure de performance différente. Une fois que vous avez finalement livré un modèle, votre partie prenante change l’orientation du projet, nécessitant une refonte complète.

Il s’agit d’une situation courante pour les data scientists, en particulier ceux qui travaillent avec des équipes collaboratives, des parties prenantes et des priorités changeantes. Le développement de modèles peut rapidement devenir une course folle pour déterminer les exigences, les sources de données, les mesures de performances, etc. Dans tout ce chaos, il est essentiel que les équipes soient capables non seulement de suivre toutes les phases de développement du modèle, mais également de reproduire rapidement les résultats. Vous devez modéliser la gouvernance.

Modèle de gouvernance

La gouvernance des modèles fait référence au cadre par lequel une équipe maintient des contrôles sur son utilisation des modèles, y compris le suivi des expériences, le contrôle des versions, la reproductibilité, etc. Il s’agit d’une capacité critique que de nombreuses équipes ne prennent pas en compte tant que leurs modèles ne sont pas déjà en production. Il est important de disposer d’un processus permettant de suivre efficacement les efforts de développement, les modèles en production et les données exploitées afin que les organisations puissent garantir la qualité, la conformité et surveiller l’intégration de l’apprentissage automatique.

Pour garantir que les bons modèles sont en production, nous avons besoin d’un moyen de gérer différents modèles et versions, de suivre les mesures de performances et de reproduire les résultats. C’est là qu’intervient ML Flow. ML Flow est une plateforme ML Ops open source qui permet un développement, un déploiement et une gestion flexibles de modèles en rationalisant la journalisation et le suivi des modèles, des métriques, etc.

Cet article explique comment installer ML Flow, créer des expériences, des modèles de journalisation et bien plus encore.

---

Tutoriel ML Flow

Développement de modèles

Pour notre modèle, nous construirons un modèle de régression linéaire de base. Il s’agit d’un modèle permettant de prédire le salaire annuel des professionnels des données à l’aide d’entrées telles que l’intitulé du poste, la taille de l’entreprise, etc.

Voir les données ici : https://www.kaggle.com/datasets/ruchi798/data-science-job-salaries (CC0 : domaine public). J’ai légèrement modifié les données pour réduire le nombre d’options pour certaines fonctionnalités. Veuillez noter qu’il s’agit d’un très mauvais modèle. Nous l’utilisons uniquement pour démontrer ML Flow.

#define independent and dependent features
X = salary_data.drop(columns = 'salary_in_usd')
y = salary_data['salary_in_usd']

#split between training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
  X, y, random_state = 104, test_size = 0.2, shuffle = True)

#define parameters separately to log
params = {"fit_intercept": True,
         "positive": False}

#fit linear regression model
regr = linear_model.LinearRegression(**params)
regr.fit(X_train, y_train)

#make predictions
y_pred = regr.predict(X_test)

Notez que nous définissons les paramètres du modèle séparément. Cela sera important lorsque nous intégrerons ML Flow.

Modèle de journalisation avec ML Flow

Pour commencer à utiliser ML Flow, vous pouvez accéder au terminal et l’installer en tant que module. Ensuite, exécutez la commande server pour héberger un serveur local sur votre machine et exploiter l’interface utilisateur ML Flow.

pip install mlflow

mlflow server --host 127.0.0.1 --port 8080

Maintenant que ML Flow est installé et que notre serveur local est en cours d’exécution, nous pouvons enregistrer notre modèle. Avant d’enregistrer un modèle, nous devons démarrer une nouvelle « expérience ». Considérez cela comme un projet, une corbeille dans laquelle nous enregistrerons et stockerons tous les modèles, métriques et données associés. etc. Dans le code ci-dessous, nous démarrons une nouvelle expérience intitulée « Exemple de journalisation ».

Une expérience se compose d’exécutions contenant le modèle utilisé, ses paramètres, ses métriques, ses artefacts et tout ce que vous choisissez d’enregistrer. Au fur et à mesure que vous enregistrez davantage de courses, nous pouvons suivre nos progrès et comparer les performances des différents modèles développés.

En utilisant le code ci-dessous, nous :

1. Commencer l’expérience
2. Démarrez une exécution intitulée « salary_baseline_regression »
3. Enregistrez le R2 ajusté en tant que métrique
4. Enregistrez les paramètres du modèle
5. Définir une balise pour le modèle
6. Enregistrez le modèle réel

import mlflow
from mlflow.models import infer_signature

#set tracking uri
mlflow.set_tracking_uri(uri = "http://127.0.0.1:8080")

#create a new MLflow Experiment
mlflow.set_experiment("Logging Example")

#start an MLflow run
with mlflow.start_run(run_name = "salary_baseline_regression") as run:

    # Log the loss metric
    mlflow.log_metric("Adjusted R2", r2_score(y_test, y_pred))
    
    #log the hyperparameters
    mlflow.log_params(params)

    #set a tag that we can use to remind ourselves what this run was for
    mlflow.set_tag("Model Type", "Baseline")

    #log the model
    model_info = mlflow.sklearn.log_model(
        sk_model = regr,
        artifact_path = 'model',
        signature = infer_signature(X_train, regr.predict(X_train)),
        input_example = X_train,
        registered_model_name = "salary_baseline_regression")

Après l’exécution, vous pouvez accéder à l’interface utilisateur de ML Flow à l’aide du lien suivant : http://localhost:8080/

Navigation dans l’interface utilisateur de ML Flow

L’interface utilisateur de ML Flow s’ouvrira dans l’onglet « Expériences ». Ici, nous pouvons voir l’expérience que nous avons créée, l’exécution de notre modèle de base, le modèle utilisé, ainsi que les métriques et paramètres que nous avons enregistrés.

Notez que les métriques et les paramètres peuvent ne pas être affichés au début. Vous pouvez les ajouter au tableau en utilisant le menu déroulant « Colonnes ».

Ensuite, cliquez sur le nom de l’exécution pour accéder à la vue de l’exécution. Cela nous amène à l’onglet de présentation où nous pouvons voir clairement tout ce que nous avons enregistré (modèle, métrique R2, paramètres du modèle).

Ensuite, cliquez sur le nom du modèle ou accédez à la vue du modèle. Ici, nous pouvons visualiser notre modèle, ajouter des descriptions et/ou des balises et suivre ses versions. Le numéro de version augmentera chaque fois que nous créerons une exécution à l’aide de ce modèle.

Les balises et les descriptions sont utiles pour la documentation globale et pour baliser les modèles en développement, en cours de révision ou en production.

Jusqu’à présent, nous avons vu comment créer des expériences et des exécutions, ainsi que des modèles de journaux, des métriques, des paramètres, etc. Ce sont les bases mêmes de ML Flow. Explorons maintenant d’autres options pour automatiser une partie du processus et tirer le meilleur parti de ML Flow.

Options de journalisation avancées

Il existe probablement de nombreuses mesures que nous aimerions suivre, qui varieront en fonction du modèle et de l’approche. Ajouter et supprimer des métriques à chaque fois que nous modifions notre approche peut être laborieux. Cependant, nous pouvons alimenter ML Flow avec nos données et résultats de tests pour automatiser la journalisation des métriques et rationaliser notre processus.

Tout d’abord, sauvegardons une copie de nos données de test et des résultats de notre modèle.

#merge salaries and predictions for mlfow
eval_data = X_test.copy()
eval_data["salary"] = y_test

Ensuite, nous donnons nos données à ML Flow et lui disons quelle est notre variable cible (salaire). Nous pouvons maintenant ajouter quelques éléments à notre processus ML Flow :

1. Enregistrez nos données pour garder une trace des entrées du modèle
2. Utilisez mlflow.evaluate() pour automatiser la journalisation des métriques du modèle

Nous pouvons également enregistrer des « artefacts », qui peuvent être de nombreuses choses. Pendant le développement et l’évaluation, il peut être utile de développer des visualisations qui reflètent les performances du modèle. Nous pouvons également les enregistrer en utilisant mlflow.log_artifact().

#set tracking uri
mlflow.set_tracking_uri(uri = "http://127.0.0.1:8080")

#create an instance of a PandasDataset
dataset = mlflow.data.from_pandas(
    eval_data, source = 'kaggle', name = "ds_salaries", targets = "salary")

#create a new MLflow Experiment
mlflow.set_experiment("Salary Prediction")

#start an MLflow run
with mlflow.start_run(run_name = "salary_baseline_regression") as run:

    #log the dataset
    mlflow.log_input(dataset, context = "training")
    
    #log the hyperparameters
    mlflow.log_params(params)

    #log pngs
    mlflow.log_artifact('Result.png')

    #set a tag that we can use to remind ourselves what this run was for
    mlflow.set_tag("Model Type", "Baseline")

    #log the model
    model_info = mlflow.sklearn.log_model(
        sk_model = regr,
        artifact_path = 'model',
        signature = infer_signature(X_train, regr.predict(X_train)),
        input_example = X_train,
        registered_model_name = "salary_baseline_regression")
    model_uri = mlflow.get_artifact_uri("model")

    #create the model uri and evalute the model
    result = mlflow.evaluate(model = model_uri, data = dataset, model_type = "regressor", evaluators=["default"])

Maintenant, si nous revenons à l’interface utilisateur de ML Flow et cliquons sur l’exécution, nous pouvons voir que nous suivons plusieurs métriques.

Et si nous souhaitons évaluer plusieurs modèles au cours d’une exécution, nous pouvons comparer leurs performances côte à côte à l’aide des visualisations automatisées ci-dessous.

Pour afficher les visualisations que vous avez enregistrées, accédez à la vue des artefacts.

Enfin, nous pouvons désormais visualiser nos entrées de données et leurs types. Il est préférable d’enregistrer les ensembles de données au fur et à mesure que nous supprimons ou ajoutons de nouvelles fonctionnalités, sources, etc.

Rappel de modèles de flux ML

Pour reproduire un modèle que nous avons enregistré, nous pouvons facilement rappeler des modèles de ML Flow en utilisant le nom et la version du modèle. Cela peut également être utilisé pour recycler les modèles actuellement en production.

model_name = "salary_baseline_regression"
model_version = "latest"

# Load the model from the Model Registry
model_uri = f"models:/{model_name}/{model_version}"
model = mlflow.sklearn.load_model(model_uri)

Intégration des Databricks

Si vous êtes (comme moi) fan de Databricks, ML Flow est entièrement intégré au sein de la plateforme. Pas besoin d’exécuter ML Flow localement, car Databricks intègre l’interface utilisateur ML Flow dans sa vue « Expériences ». Il comprend également des fonctionnalités supplémentaires telles que le suivi des applications et des agents d’IA générative et intègre AutoML pour l’optimisation des modèles. Voir la documentation complète ici : https://docs.databricks.com/aws/en/mlflow/

---

Conclusion

En conclusion, la gouvernance modèle est une capacité indispensable pour toute organisation afin de garantir la qualité et la conformité. Les outils de suivi et de surveillance tels que ML Flow offrent des solutions pour rationaliser les processus de gouvernance des modèles et gérer entièrement le développement et le déploiement des modèles.

---

J’espère que vous avez apprécié mon article ! N’hésitez pas à commenter, poser des questions ou demander d’autres sujets.

Connectez-vous avec moi sur LinkedIn : https://www.linkedin.com/in/alexdavis2020/