Utilisation de MLflow avec Databricks ① - Suivi expérimental sur notebook -

introduction

Dans cet article, j'écrirai sur la façon de suivre MLflow, une plate-forme open source qui gère le cycle de vie des modèles d'apprentissage automatique, dans l'environnement de Databricks. (En supposant Python3)

MLflow géré par Databricks

Le MLflow open source est conçu pour fonctionner avec n'importe quelle bibliothèque, langage ou outil de déploiement ML, mais vous devrez fournir votre propre serveur pour suivre vos expériences.

Dans l'environnement Databricks, MLflow peut être utilisé en tant que service géré, il n'est donc pas nécessaire de préparer un serveur de suivi distinct. Vous pouvez également intégrer et gérer les informations de suivi des expériences dans votre bloc-notes.

Cette fois, j'écrirai sur la façon d'intégrer des informations expérimentales dans un cahier et de les suivre.

Comment utiliser MLflow

Si le cluster que vous utilisez sur Databricks est Runtime ML, il est inclus depuis le début, mais dans d'autres cas, vous devez installer MLflow.

dbutils.library.installPyPI("mlflow")
dbutils.library.restartPython()

Vous pouvez l'installer avec la commande ci-dessus. Puis importez.

import mlflow

Dans MLflow, le module de démarrage du suivi est appelé pour démarrer le suivi, le module qui enregistre les paramètres d'expérience et les journaux les enregistre, et le module de fin de suivi met fin à un suivi d'expérience.

Je pense que c'est une bonne idée d'utiliser with pour éviter d'oublier de quitter. L'image du code de la partie implémentation est la suivante.

  with mlflow.start_run():    #Démarrer le suivi des expériences

    #Traitement expérimental

    #Enregistrement des logs et des paramètres, etc.
    mlflow.log_param("a", a)
    mlflow.log_metric("rmse", rmse)

    #Enregistrement du modèle
    mlflow.sklearn.save_model(b, modelpath)
   
    #Sauvegarde des images produites pendant l'expérience
    mlflow.log_artifact("sample.png ")

En plus des paramètres, les enregistrements du modèle et les images produites pendant les expériences peuvent également être enregistrés dans la destination de suivi. Une installation séparée de la bibliothèque appropriée est nécessaire pour enregistrer le modèle. Exemple) modèle scikit-learn → mlflow.sklearn

la mise en oeuvre

Implémentons-le et suivons-le sur un cahier.

Exemple de jeu de données et modèle utilisé

Utilisez l'ensemble de données sur le diabète scikit-learn. Vous pouvez trouver l'explication des colonnes ici. https://scikit-learn.org/stable/datasets/index.html#diabetes-dataset

Nous utiliserons le modèle de régression linéaire ElasticNet pour créer ce modèle. Il y a ʻalpha et l1_ratio` comme paramètres de réglage.

L'explication ici sur ElasticNet était facile à comprendre. https://aizine.ai/ridge-lasso-elasticnet/

installer

Importez diverses bibliothèques, chargez des exemples de jeux de données et créez des blocs de données.

#Chargement des bibliothèques requises
import os
import warnings
import sys

import pandas as pd
import numpy as np
from itertools import cycle
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.linear_model import ElasticNet
from sklearn.linear_model import lasso_path, enet_path
from sklearn import datasets

#Importer mlflow
import mlflow
import mlflow.sklearn

#Chargement de l'ensemble de données sur le diabète
diabetes = datasets.load_diabetes()
X = diabetes.data
y = diabetes.target

#Créer un bloc de données
Y = np.array([y]).transpose()
d = np.concatenate((X, Y), axis=1)
cols = ['age', 'sex', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6', 'progression']
data = pd.DataFrame(d, columns=cols)

Implémentation de la partie traitement des résultats

Il définit le processus de traçage de chaque coefficient des variables explicatives lors de la création d'un modèle de régression avec ElasticNet et de son enregistrement en tant qu'image dans le nœud pilote.

def plot_enet_descent_path(X, y, l1_ratio):
    #Longueur du trajet(alpha_min / alpha_max)paramètres de
    eps = 5e-3 

    #Déclaration globale d'image
    global image
    
    print("Computing regularization path using ElasticNet.")
    alphas_enet, coefs_enet, _ = enet_path(X, y, eps=eps, l1_ratio=l1_ratio, fit_intercept=False)

    #Voir les résultats
    fig = plt.figure(1)
    ax = plt.gca()

    colors = cycle(['b', 'r', 'g', 'c', 'k'])
    neg_log_alphas_enet = -np.log10(alphas_enet)
    for coef_e, c in zip(coefs_enet, colors):
        l1 = plt.plot(neg_log_alphas_enet, coef_e, linestyle='--', c=c)

    plt.xlabel('-Log(alpha)')
    plt.ylabel('coefficients')
    title = 'ElasticNet Path by alpha for l1_ratio = ' + str(l1_ratio)
    plt.title(title)
    plt.axis('tight')

    image = fig
    
    #Enregistrer l'image
    fig.savefig("ElasticNet-paths.png ")

    #fermer l'intrigue
    plt.close(fig)

    # Return images
    return image    

Mise en œuvre de la partie traitement expérimental

Entraînez le modèle en spécifiant ʻalpha et l1_ratio. Appelez le plot_enet_descent_path` défini ci-dessus pour enregistrer le journal ou l'image dans la destination de suivi.

def train_diabetes(data, in_alpha, in_l1_ratio):
  #Évaluation des métriques
  def eval_metrics(actual, pred):
      rmse = np.sqrt(mean_squared_error(actual, pred))
      mae = mean_absolute_error(actual, pred)
      r2 = r2_score(actual, pred)
      return rmse, mae, r2

  warnings.filterwarnings("ignore")
  np.random.seed(40)

  #Division de l'ensemble de données
  train, test = train_test_split(data)

  #Diviser l'étiquette correcte
  train_x = train.drop(["progression"], axis=1)
  test_x = test.drop(["progression"], axis=1)
  train_y = train[["progression"]]
  test_y = test[["progression"]]

  if float(in_alpha) is None:
    alpha = 0.05
  else:
    alpha = float(in_alpha)
    
  if float(in_l1_ratio) is None:
    l1_ratio = 0.05
  else:
    l1_ratio = float(in_l1_ratio)
  
  #Pièce de montage de mlflow
  # mlflow.start_run()Il sera intégré au notebook en vidant la valeur de l'argument de
  with mlflow.start_run():
    lr = ElasticNet(alpha=alpha, l1_ratio=l1_ratio, random_state=42)
    lr.fit(train_x, train_y)

    predicted_qualities = lr.predict(test_x)

    (rmse, mae, r2) = eval_metrics(test_y, predicted_qualities)

    #Affichage des métriques du modèle ElasticNet
    print("Elasticnet model (alpha=%f, l1_ratio=%f):" % (alpha, l1_ratio))
    print("  RMSE: %s" % rmse)
    print("  MAE: %s" % mae)
    print("  R2: %s" % r2)

    #Enregistrer le journal
    mlflow.log_param("alpha", alpha)
    mlflow.log_param("l1_ratio", l1_ratio)
    mlflow.log_metric("rmse", rmse)
    mlflow.log_metric("r2", r2)
    mlflow.log_metric("mae", mae)
    mlflow.sklearn.log_model(lr, "model")
    modelpath = "/dbfs/mlflow/test_diabetes/model-%f-%f" % (alpha, l1_ratio)
    mlflow.sklearn.save_model(lr, modelpath)
    
    # plot_enet_descent_chemin d'appel
    image = plot_enet_descent_path(X, y, l1_ratio)
    
    #Enregistrer l'image de sortie
    mlflow.log_artifact("ElasticNet-paths.png ")

Expérience

Expérimentez en donnant des paramètres de réglage.

# alpha = 0.01, l1_ratio = 0.Expérimentez comme 01
train_diabetes(data, 0.01, 0.01)

Le résultat de sortie est le suivant.

Je vais sortir l'image.

Essayons de changer certains paramètres. (J'ai essayé environ 4 modèles au total)

Une fois l'expérience terminée, appuyez sur la partie intitulée [Runs] en haut à droite.

Vous pouvez voir que les valeurs des paramètres définis et les métriques de sortie sont enregistrées pour chaque expérience.

en conclusion

Cette fois, j'ai écrit sur la façon d'intégrer et de suivre les résultats de la formation du modèle sur un ordinateur portable. Databricks vous permet de comparer ces données expérimentales sur l'interface utilisateur. En tant que suite, j'aimerais écrire sur la gestion des modèles sur l'interface utilisateur.