Trainieren und Deployen eines Iris-Blumen-Klassifikationsmodells mit TrueFoundry

In diesem Beispiel trainieren wir ein Modell, das eine Blume der Gattung Iris basierend auf Größenmessungen ihrer Kron- und Kelchblätter in eine von drei Arten klassifizieren kann.

Sie können diesem Beispiel auch in einem Google Colaboratory Notebook folgen.

Der Iris-Datensatz enthält drei verschiedene Arten:

• Iris Setosa
• Iris Versicolor
• Iris Virginica

Wir müssen einen Klassifikator bauen, der die Art der Blume anhand der folgenden Parameter identifizieren kann:

• Sepal Length (Kelchblattlänge)
• Sepal Width (Kelchblattbreite)
• Petal Length (Kronblattlänge)
• Petal Width (Kronblattbreite)

Über TrueFoundry

TrueFoundry bietet zwei Bibliotheken zur Vereinfachung Ihrer ML-Workflows:

MLFoundry

Die mlfoundry-Bibliothek wird verwendet, um ML-Trainings-Experimente zu tracken.

Warum benötigen Sie Experiment-Tracking? Wenn Sie mehrere ML-Modelle trainieren, um ein Problem zu lösen, werden Sie wahrscheinlich mehrere Modelle mit mehreren Frameworks, Hyperparametern und mehreren Datensätzen trainieren. Das Tracking Ihres Experiments mit einer Bibliothek wie mlfoundry kann Ihnen helfen, Ihre ML-Experimente zu organisieren.

Sie können MLFoundry verwenden, um Hyperparameter, Metriken, Datensätze und Modelle zu loggen. Sie können dann verschiedene Experimente auf dem TrueFoundry Dashboard vergleichen und ein Modell für das Deployment in der Produktion auswählen oder sich für ein erneutes Training des Modells entscheiden.

Wir werden in diesem Beispiel 5 verschiedene APIs von MLFoundry verwenden. Diese sind:

1. log_params – verwenden Sie dies, um Hyperparameter des aktuellen Experiments zu loggen
2. log_dataset – wird verwendet, um den gesamten Datensatz zu loggen
3. log_metrics – loggen Sie Metriken wie Accuracy Scores, F1 Scores
4. set_tags – fügen Sie Ihrem Experiment Tags für ein einfaches späteres Filtern hinzu
5. log_model – um ein Modell einschließlich der trainierten Gewichte zu speichern

ServiceFoundry

Mit der servicefoundry-Bibliothek können Sie ein Modell einfach verpacken, containerisieren und in einem Kubernetes-Cluster deployen.

Lassen Sie uns ein Modell trainieren und mit MLFoundry loggen

Öffnen Sie ein IPython Notebook – Sie können entweder Jupyter lokal auf Ihrem Rechner oder ein Google Colab Notebook in der Cloud verwenden.

Installieren Sie die erforderlichen Bibliotheken.

 
!pip install mlfoundry
!pip install pandas
!pip install sklearn

Melden Sie sich bei TrueFoundry an. Erstellen und kopieren Sie einen API-Schlüssel von der Einstellungsseite. Verwenden Sie diesen API-Schlüssel, um den MLFoundry-Client zu initialisieren und einen Run zu erstellen. Ein Run ist eine Entität, die ein einzelnes Experiment repräsentiert.

 
import mlfoundry as mlf
client = mlf.get_client(api_key='')
run = client.create_run('iris-classifier'))

Rufen Sie den Iris-Datensatz mit dem sklearn.datasets-Modul ab. Wir teilen ihn dann in Test- und Trainings-Datensätze auf.

 
from sklearn import datasets
from sklearn.model_selection import train_test_split

data = datasets.load_iris()

X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, stratify=y, random_state=42)

Lassen Sie uns einen Blick auf die Target-Namen werfen. Wir werden diese verwenden, um die Ganzzahl-Ausgabe des Modells den tatsächlichen Namen der Arten zuzuordnen.

 
print(data.target_names)

# Output
# ['setosa' 'versicolor' 'virginica']

Initialisieren Sie ein Modell. Verwenden Sie dann MLFoundry, um die Parameter des Modells zu loggen und einige Tags für diesen aktuellen Experiment-Run zu erstellen.

 
from sklearn.svm import SVC

clf = SVC(gamma='scale', kernel='rbf', probability=True, C=1.2)

run.set_tags({
	'framework': 'sklearn',
  'task': 'classification'
})

run.log_params(clf.get_params())

Als Nächstes trainieren wir das Modell auf unserem Trainings-Datensatz. Sobald das Training abgeschlossen ist, berechnen wir die verschiedenen Metriken und loggen sie mit log_metrics in MLFoundry.

 
from sklearn.svm import SVC

clf = SVC(gamma='scale', kernel='rbf', probability=True, C=1.2)

run.set_tags({
	'framework': 'sklearn',
  'task': 'classification'
})

run.log_params(clf.get_params())

 
clf.fit(X_train, y_train)

y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)

metrics = {
  'train/accuracy_score': accuracy_score(y_train, y_pred_train),
  'train/f1_weighted': f1_score(y_train, y_pred_train, average='weighted'),
  'train/f1_micro': f1_score(y_train, y_pred_train, average='micro'),
  'train/f1_macro': f1_score(y_train, y_pred_train, average='macro'),
  'test/accuracy_score': accuracy_score(y_test, y_pred_test),
  'test/f1_weighted': f1_score(y_test, y_pred_test, average='weighted'),
  'test/f1_micro': f1_score(y_test, y_pred_test, average='micro'),
  'test/f1_macro': f1_score(y_test, y_pred_test, average='macro'),
}

run.log_metrics(metrics)

Wenn wir mit den Accuracy Scores und anderen Metriken zufrieden sind, können wir uns dafür entscheiden, das aktuelle Modell zu deployen. Dafür müssen wir das Modell speichern und die aktuelle Run-ID kopieren.

 
run.log_model(clf, framework=mlf.ModelFramework.SKLEARN)
print(run.run_id)
run.end()

Sie können alle Ihre Runs sehen und Metriken über das TrueFoundry Experiment-Tracking-Dashboard vergleichen.

Deployen unseres Modells als API-Service

Um das Modell mit ServiceFoundry zu deployen, müssen wir eine Python-Datei erstellen, die die Funktion enthält, die wir als Endpunkt bereitstellen möchten.

In dieser Python-Datei rufen wir das Modell ab, das wir gerade trainiert und gespeichert haben, unter Verwendung der Run-ID mit mlfoundry. Beachten Sie, dass der von mlfoundry benötigte API-Schlüssel als Umgebungsvariable TFY_API_KEY verfügbar sein wird.

Erstellen Sie in Ihrem IPython Notebook einen Block mit den folgenden Inhalten und führen Sie ihn aus, um eine Python-Datei namens predict.py zu erstellen. Wir verwenden den Jupyter-Magic-Befehl %%writefile, um die Datei in der Notebook-Umgebung zu erstellen.

 
%%writefile predict.py
import os
import json
import pandas as pd
import mlfoundry as mlf

client = mlf.get_client(api_key=os.environ.get('TFY_API_KEY'))
run = client.get_run('79e71482643f46dfa5bfef256dba5dc5') # replace with your run id
model = run.get_model()

def species(features):
 features = json.loads(features)
 df = pd.DataFrame.from_dict([features])
 prediction = model.predict(df)[0]
 return ['setosa', 'versicolor', 'virginica'][prediction]

Innerhalb der species-Funktion laden wir die Features in einen pandas DataFrame und führen die Vorhersage mit dem Modell durch. Wir übersetzen von der Ganzzahl-Klasse in Artnamen unter Verwendung von target_names, die wir während des Trainings ausgegeben haben.

Das ist im Wesentlichen die gesamte Arbeit, die Sie erledigen müssen. Lassen Sie uns dieses Modell nun als API-Service deployen. Installieren und importieren Sie zuerst servicefoundry in Ihrem Notebook. Melden Sie sich bei servicefoundry an.

 
!pip install servicefoundry
import servicefoundry.core as sfy
sfy.login()

Gehen Sie zum TrueFoundry Dashboard und erstellen Sie einen Workspace, um den Service zu deployen. Workspaces sind eine Möglichkeit, zusammengehörige Projekte innerhalb von TrueFoundry zu gruppieren. Sobald der Workspace erstellt ist, kopieren Sie den FQN, damit wir servicefoundry mitteilen können, wo das Modell deployt werden soll.

‍Die servicefoundry-Bibliothek ermöglicht es Ihnen, alle Abhängigkeiten der gerade erstellten Datei mit der Funktion gather_requirements zu erfassen.

 
requirements = sfy.gather_requirements("predict.py")

Erstellen Sie nun ein sfy.Service-Objekt, geben Sie den Workspace-FQN an und deployen Sie es durch Aufruf von .deploy()

 
auto_service = sfy.Service("predict.py", requirements, sfy.Parameters( name="iris-service", workspace="" )) auto_service.deploy()

Sie können den Fortschritt dieses Deployments auf dem Dashboard verfolgen. Sobald das Deployment abgeschlossen ist, können Sie von dort auf den deployten Service zugreifen und ihn ausprobieren.

Das TrueFoundry Dashboard verlinkt auch auf Metriken und Logs, die bei TrueFoundry Deployments direkt in Form von Grafana Dashboards enthalten sind. Sie können hier mehr darüber lesen.

Weitere Features

Sie können auch interaktive UI-Anwendungen und Gradio-Anwendungen einfach aus einem IPython Notebook heraus mit servicefoundry deployen. Lesen Sie dieser Anleitung, um zu sehen, wie.

Wir arbeiten daran, die Integration zwischen Experiment-Tracking und Deployment noch enger und das Erlebnis noch angenehmer zu gestalten. Sie können über andere Dinge, die Sie mit TrueFoundry tun können, in unserer Dokumentation nachlesen. Wenn Sie Machine-Learning-Modelle trainieren, um ein Problem zu lösen, hilft Ihnen TrueFoundry dabei, verschiedene Experimente zu tracken, und macht es einfach und intuitiv, Modelle mit Best Practices zu deployen und sie innerhalb von Minuten für die öffentliche Nutzung verfügbar zu machen.