[PYTHON] Verwenden von MLflow mit Databricks ① - Experimentelles Tracking auf Notebooks -
Einführung
In diesem Artikel werde ich darüber schreiben, wie MLflow, eine Open-Source-Plattform, die den Lebenszyklus von Modellen für maschinelles Lernen verwaltet, in der Umgebung von Databricks verfolgt werden kann. (Angenommen, Python3)
Databricks verwaltete MLflow
Der Open-Source-MLflow funktioniert mit jeder ML-Bibliothek, Sprache oder jedem Bereitstellungstool. Sie müssen jedoch einen eigenen Server bereitstellen, um Ihre Experimente verfolgen zu können.
In der Databricks-Umgebung kann MLflow als verwalteter Dienst verwendet werden, sodass kein separater Tracking-Server vorbereitet werden muss. Sie können auch Informationen zur Versuchsverfolgung in Ihr Notizbuch integrieren und verwalten.
Dieses Mal werde ich darüber schreiben, wie man experimentelle Informationen in ein Notizbuch integriert und nachverfolgt.
Verwendung von MLflow
Wenn der Cluster, den Sie in Databricks verwenden, Runtime ML ist, ist er von Anfang an enthalten, in anderen Fällen müssen Sie MLflow installieren.
dbutils.library.installPyPI("mlflow")
dbutils.library.restartPython()
Sie können es mit dem obigen Befehl installieren. Dann importieren.
import mlflow
In MLflow wird das Tracking-Startmodul aufgerufen, um das Tracking zu starten, das Modul, das Experimentparameter aufzeichnet und protokolliert, zeichnet es auf, und das Tracking-Endmodul beendet ein Experiment-Tracking.
Ich denke, es ist eine gute Idee, "with" zu verwenden, um zu verhindern, dass das Verlassen vergessen wird. Das Bild des Codes des Implementierungsteils ist wie folgt.
with mlflow.start_run(): #Starten Sie die Experimentverfolgung
#Experimentelle Verarbeitung
#Aufzeichnung von Protokollen und Parametern usw.
mlflow.log_param("a", a)
mlflow.log_metric("rmse", rmse)
#Modellaufzeichnung
mlflow.sklearn.save_model(b, modelpath)
#Speichern der während des Experiments ausgegebenen Bilder
mlflow.log_artifact("sample.png ")
Neben Parametern können auch Modellaufzeichnungen und Bilder, die während der Experimente ausgegeben werden, im Verfolgungsziel gespeichert werden.
Eine separate Installation der entsprechenden Bibliothek ist erforderlich, um das Modell aufzuzeichnen.
Beispiel) Scikit-Learn-Modell → mlflow.sklearn
Implementierung
Lassen Sie es uns tatsächlich implementieren und auf einem Notizbuch verfolgen.
Beispieldatensatz und verwendetes Modell
Verwenden Sie den Scikit-Learn-Diabetes-Datensatz. Die Erklärung der Spalten finden Sie hier. https://scikit-learn.org/stable/datasets/index.html#diabetes-dataset
Wir werden das lineare ElasticNet-Regressionsmodell verwenden, um dieses Modell zu erstellen.
Es gibt alpha und l1_ratio als Einstellparameter.
Die Erklärung hier zu ElasticNet war leicht zu verstehen. https://aizine.ai/ridge-lasso-elasticnet/
installieren
Importieren Sie verschiedene Bibliotheken, laden Sie Beispieldatensätze und erstellen Sie Datenrahmen.
#Laden der erforderlichen Bibliotheken
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
#Mlflow importieren
import mlflow
import mlflow.sklearn
#Laden des Diabetes-Datensatzes
diabetes = datasets.load_diabetes()
X = diabetes.data
y = diabetes.target
#Erstellen eines Datenrahmens
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)
Implementierung des Ergebnisverarbeitungsteils
Es definiert den Prozess des Zeichnens jedes Koeffizienten der erklärenden Variablen beim Erstellen eines Regressionsmodells mit ElasticNet und Speichern als Bild im Treiberknoten.
def plot_enet_descent_path(X, y, l1_ratio):
#Pfadlänge(alpha_min / alpha_max)Einstellungen von
eps = 5e-3
#Globale Imageerklärung
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)
#Ergebnisse anzeigen
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
#Bild speichern
fig.savefig("ElasticNet-paths.png ")
#Grundstück schließen
plt.close(fig)
# Return images
return image
Implementierung des experimentellen Verarbeitungsteils
Trainieren Sie das Modell, indem Sie "alpha" und "l1_ratio" angeben. Rufen Sie den oben definierten plot_enet_descent_path auf, um das Protokoll oder Bild am Verfolgungsziel zu speichern.
def train_diabetes(data, in_alpha, in_l1_ratio):
#Auswertung von Metriken
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)
#Datensatzaufteilung
train, test = train_test_split(data)
#Richtiges Etikett teilen
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)
#Montageteil von mlflow
# mlflow.start_run()Es wird in das Notizbuch integriert, indem der Wert des Arguments von geleert wird
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)
#Anzeigen von ElasticNet-Modellmetriken
print("Elasticnet model (alpha=%f, l1_ratio=%f):" % (alpha, l1_ratio))
print(" RMSE: %s" % rmse)
print(" MAE: %s" % mae)
print(" R2: %s" % r2)
#Protokoll speichern
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_Anrufpfad
image = plot_enet_descent_path(X, y, l1_ratio)
#Ausgabebild speichern
mlflow.log_artifact("ElasticNet-paths.png ")
Experiment
Experimentieren Sie mit Anpassungsparametern.
# alpha = 0.01, l1_ratio = 0.Experimentieren Sie als 01
train_diabetes(data, 0.01, 0.01)
Das Ausgabeergebnis ist wie folgt.
Ich werde das Bild ausgeben.
Experimentieren wir mit der Änderung einiger Parameter. (Ich habe insgesamt 4 Muster ausprobiert)
Wenn das Experiment beendet ist, drücken Sie auf den Teil mit der Bezeichnung [Läufe] oben rechts.
Sie können sehen, dass die Werte der eingestellten Parameter und der Ausgabemetriken für jedes Experiment aufgezeichnet werden.
abschließend
Dieses Mal schrieb ich darüber, wie man die Ergebnisse des Modelltrainings auf einem Notebook integriert und verfolgt. Mit Databricks können Sie diese experimentellen Daten auf der Benutzeroberfläche vergleichen. Als Fortsetzung möchte ich über die Modellverwaltung auf der Benutzeroberfläche schreiben.
Recommended Posts