Integrationen von Machine Learning Plattformen #1: Weights & Biases

Experimentation Tracking ist ein kritischer Aspekt der Entwicklungsarbeit im Machine Learning, der es Entwicklern ermöglicht, den Fortschritt ihrer Experimente effizient zu verwalten und zu verfolgen. Experimentation Tracking umfasst das Aufzeichnen und Überwachen verschiedener Faktoren wie Modellleistung, Hyperparameter und Trainingsdaten, um Einblicke in die Performance des Machine Learning Modells zu gewinnen.

Herausforderungen beim Verwalten von Experimenten

Das Verwalten von Experimenten und Verfolgen von Ergebnissen kann für Machine Learning Spezialisten aufgrund der Komplexität der Modelle, der großen Datenmengen und der Vielfalt der verwendeten Tools und Frameworks eine anspruchsvolle Aufgabe sein. Hier sind einige der zentralen Herausforderungen bei der Verwaltung von Experimenten und der Nachverfolgung von Ergebnissen:

1. Reproduzierbarkeit: Das Reproduzieren von Experimenten ist essenziell, um Ergebnisse zu verifizieren und sicherzustellen, dass Modelle in realen Szenarien gut funktionieren. Die Reproduktion von Experimenten kann jedoch herausfordernd sein, insbesondere beim Umgang mit komplexen Modellen, mehreren Frameworks und unterschiedlichen Rechenumgebungen.
2. Skalierbarkeit: Machine Learning Entwickler arbeiten häufig mit großen Datensätzen, weshalb das Trainieren von Modellen ein zeitaufwendiger Prozess sein kann, der erhebliche Rechenleistung erfordert. Das Verwalten von Experimenten und Nachverfolgen von Ergebnissen im großen Maßstab erfordert Tools und Infrastruktur, die große Mengen an Daten und Berechnungen verarbeiten können.
3. Kollaboration: Zusammenarbeit ist in der Machine Learning Entwicklung unerlässlich, aber das Verwalten von Experimenten und Nachverfolgen von Ergebnissen über mehrere Teammitglieder hinweg kann schwierig sein. Es erfordert eine robuste Infrastruktur zum Teilen von Daten, Code und Experimentergebnissen sowie zur Sicherstellung, dass jeder Zugriff auf dieselben Ressourcen hat.
4. Datenmanagement: Machine Learning Modelle hängen stark von Daten ab, und ein effektives Datenmanagement ist entscheidend für den Erfolg des Modells. Die Datenverwaltung bringt jedoch verschiedene Herausforderungen mit sich, wie Datenbereinigung, Datenlabeling und Datenversionierung, die zeitaufwendig und komplex sein können.
5. Hyperparameter-Optimierung: Das Finden der besten Hyperparameter für ein Modell kann ein schwieriger und iterativer Prozess sein, der die Durchführung mehrerer Experimente mit unterschiedlichen Hyperparametern umfasst. Das Verwalten dieser Experimente und Nachverfolgen der Ergebnisse kann zeitaufwendig und komplex sein.

Die Funktionen von Weights & Biases im Überblick

Weights & Biases (W&B) ist eine Plattform, die Entwicklern im Bereich Machine Learning dabei hilft, ihre Experimente effektiv zu verwalten und zu verfolgen. Sie bietet eine Suite von Tools für Experiment-Tracking, Visualisierung und Kollaboration, was die Entwicklung robuster und skalierbarer Machine Learning Modelle erleichtert.

Die Hauptfunktionen und Vorteile der W&B-Plattform sind:

1. Experiment Tracking: W&B ermöglicht Nutzern das Verfolgen ihrer Experimente durch automatische Protokollierung von Modell-Hyperparametern, Metriken und Output-Artefakten. So können Entwickler den Überblick über ihre Experimente behalten und verschiedene Modelle sowie Hyperparameter problemlos vergleichen.
2. Visualisierungen: W&B bietet eine Reihe von Visualisierungs-Tools, mit denen Benutzer ihre Experimente und Ergebnisse visualisieren können. Dazu gehören unter anderem 3D-Visualisierungen, Konfusionsmatrizen und Streudiagramme. Dies hilft Entwicklern, ihre Daten besser zu verstehen sowie Muster und Trends in den Experimentergebnissen zu erkennen.
3. Kollaboration: W&B erleichtert die Zusammenarbeit mit Teammitgliedern durch Funktionen zum Teilen von Experimenten, Daten und Ergebnissen. Es bietet auch eine Versionskontrolle für Code und Daten, um sicherzustellen, dass alle mit denselben Ressourcen arbeiten.
4. Integration: W&B lässt sich problemlos in eine Vielzahl von Machine Learning Frameworks integrieren, darunter TensorFlow, PyTorch, Keras und Scikit-learn. Dadurch können Entwickler W&B mit ihren bestehenden Workflows und Frameworks nutzen, ohne wesentliche Änderungen an ihrem Entwicklungsprozess vornehmen zu müssen.
5. Organisation: W&B bietet Funktionen zur Organisation von Experimenten, wie Projekte, Runs und Tags. Dies macht es einfach, Experimente über mehrere Teammitglieder und Projekte hinweg zu verwalten und zu verfolgen.

Schritt-für-Schritt-Anleitung: Einrichten von Weights & Biases leicht gemacht

Das Einrichten von W&B zum Nachverfolgen von Experimenten umfasst mehrere Schritte:

1. Für ein W&B-Konto registrieren: Der erste Schritt ist die Registrierung für ein kostenloses Konto auf der W&B-Website. Dies geschieht durch Aufrufen der Website und Befolgen des Registrierungsprozesses.
2. Die W&B-Bibliothek installieren: Nach der Registrierung eines Kontos besteht der nächste Schritt darin, die W&B-Bibliothek in der Entwicklungsumgebung zu installieren. Die W&B-Bibliothek kann je nach Präferenz des Benutzers und Entwicklungsumgebung mit pip oder conda installiert werden.
3. W&B initialisieren: Sobald die Bibliothek installiert ist, muss der Benutzer W&B im Code durch Aufruf der Funktion wandb.init() initialisieren. Diese Funktion initialisiert die W&B-Bibliothek und richtet einen neuen Run ein.
4. Metriken protokollieren: Der Benutzer kann Metriken wie Loss und Accuracy während des Trainings protokollieren, indem er die Funktion wandb.log() aufruft. Diese Funktion nimmt ein Dictionary von Metriken als Eingabe entgegen und protokolliert sie im W&B-Dashboard.
5. Hyperparameter protokollieren: Der Benutzer kann auch Hyperparameter wie Learning Rate und Batch Size protokollieren, indem er die Funktion wandb.config aufruft. Diese Funktion nimmt ein Dictionary von Hyperparametern als Eingabe entgegen und protokolliert sie im W&B-Dashboard.
6. Visualisierungen protokollieren: Schließlich kann der Benutzer Visualisierungen wie Bilder und Plots protokollieren, indem er die Funktion wandb.log() mit den entsprechenden Visualisierungsdaten aufruft. W&B bietet eine breite Palette an Visualisierungswerkzeugen, darunter 3D-Visualisierungen, Konfusionsmatrizen, Streudiagramme und mehr.

Beispiel:

Hier ist ein Beispiel dafür, wie Sie Metriken, Modelle, Hyperparameter und Visualisierungen mit W&B protokollieren:

import wandb
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

# Step 1: Initialize W&B
wandb.init(project="my-project")

# Step 2: Log hyperparameters
config = {
   "learning_rate": 0.001,
   "batch_size": 32,
   "epochs": 10
}
wandb.config.update(config)

# Step 3: Train model and log metrics
model = tf.keras.models.Sequential([
   tf.keras.layers.Dense(10, activation='relu', input_shape=(10,)),
   tf.keras.layers.Dense(1)
])
model.compile(optimizer=tf.keras.optimizers.Adam(config['learning_rate']),
             loss=tf.keras.losses.MeanSquaredError(),
             metrics=[tf.keras.metrics.MeanAbsoluteError()])
for epoch in range(config['epochs']):
   # ... train model ...
   history = model.fit(x_train, y_train, batch_size=config['batch_size'])
   loss = history.history['loss'][-1]
   mae = history.history['mean_absolute_error'][-1]
   wandb.log({"epoch": epoch, "loss": loss, "mae": mae})

# Step 4: Log visualizations and model
x = np.linspace(0, 10, 100)
y = np.sin(x)
fig, ax = plt.subplots()
ax.plot(x, y)
wandb.log({"my_plot": wandb.Image(fig)})
wandb.save('my_model.h5')

# Step 5: Finish run
wandb.finish()

c

Nahtlose Integration: TrueFoundrys Ansatz für Weights & Biases

TrueFoundry integriert nahtlos mit der Weights & Biases Model Registry, damit Sie in Weights & Biases protokollierte Modelle mithilfe von TrueFoundry in Ihrem Kubernetes Cluster bereitstellen können.

📌

Neben der Nutzung von Weights & Biases für Modellmanagement und Experimentation Tracking können Sie auch das Experimentation Tracking MLFoundry von TrueFoundry verwenden.

📌

Sie können dem folgenden Code auch über dieses Colab Notebook folgen:
Colab Notebook

Schritt 1 – Installation und Einrichtung:

• wandb installieren

pip install wandb -qU

• In Ihrem W&B-Konto anmelden

import wandb
wandb.login()

• servicefoundry installieren

pip install -U "servicefoundry"

• Bei Truefoundry anmelden

sfy login

Schritt 2 – Modell trainieren und protokollieren:

Wir werden zuerst wandb.init() verwenden, um das Projekt zu initialisieren
Dann trainieren wir unser ML-Modell und speichern es als joblib-Datei
Anschließend speichern wir unsere joblib-Datei über wandb.save() in wandb

import wandb
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
import joblib

# Initialize W&B
wandb.init(project="iris-logistic-regression")

# Load and preprocess the data
X, y = load_iris(as_frame=True, return_X_y=True)
X = X.rename(columns={
       "sepal length (cm)": "sepal_length",
       "sepal width (cm)": "sepal_width",
       "petal length (cm)": "petal_length",
       "petal width (cm)": "petal_width",
})

X_train, X_test, y_train, y_test = train_test_split(
   X, y, test_size=0.2, random_state=42, stratify=y
)

# Initialize the model
clf = LogisticRegression(solver="liblinear")

# Fit the model
clf.fit(X_train, y_train)

# Evaluate the model
preds = clf.predict(X_test)

# Log the model and the evaluation metrics to W&B
joblib.dump(clf, "model.joblib")
wandb.save("model.joblib")

# Finish the run
wandb.finish()

Schritt 3 – Inferenz-Anwendung und Abhängigkeitsdatei erstellen:

Wir müssen zwei Dateien erstellen, um auf TrueFoundry zu deployen: eine app.py-Datei, die unseren Anwendungscode enthält, und eine requirements.txt-Datei, die unsere Abhängigkeiten enthält.

.
├── app.py
├── deploy.py
└── requirements.txt


c

• app.py:
  Hier müssen Sie die folgenden Argumente in wandb.restore() übergeben: <name_of_saved_file> und "username/project/run_id"
  Z. B.: wandb.restore("model.joblib", "adityajha-tfy/iris-logistic-regression/00r5xvyv")

import os
import wandb
import joblib
import pandas as pd
from fastapi import FastAPI

wandb.login(key=os.environ["WANDB_API_KEY"])

# Retrieve the model from W&B
model_joblib = wandb.restore(
   'model.joblib',
   run_path="adityajha-tfy/iris-logistic-regression/00r5xvyy",
 )

model = joblib.load(model_joblib.name)

# Load the model
app = FastAPI(root_path=os.getenv("TFY_SERVICE_ROOT_PATH"))

@app.post("/predict")
def predict(
   sepal_length: float, sepal_width: float, petal_length: float, petal_width: float
):
   data = dict(
       sepal_length=sepal_length,
       sepal_width=sepal_width,
       petal_length=petal_length,
       petal_width=petal_width,
   )
   prediction = int(model.predict(pd.DataFrame([data]))[0])
   return {"prediction": prediction}

• requirements.txt:

fastapi
joblib
numpy
pandas
scikit-learn
uvicorn
wandb

Schritt 4 – Python-SDK von TrueFoundry nutzen und das Deployment konfigurieren

• deploy.py:

import argparse
import logging
from servicefoundry import Build, PythonBuild, Service, Resources, Port

# Setup the logger
logging.basicConfig(level=logging.INFO)

# Setup the argument parser
parser = argparse.ArgumentParser()
parser.add_argument("--workspace_fqn", required=True, type=str)
parser.add_argument("--wandb_api_key", required=True, type=str)
args = parser.parse_args()

service = Service(
   name="fastapi",
   image=Build(
       build_spec=PythonBuild(
           command="uvicorn app:app --port 8000 --host 0.0.0.0",
           requirements_path="requirements.txt",
       )
   ),
   ports=[
       Port(
           port=8000,
           host="ml-deploy-aditya-ws-8000.demo.truefoundry.com",
       )
   ],
   resources=Resources(
       cpu_request=0.25,
       cpu_limit=0.5,
       memory_request=200,
       memory_limit=400,
       ephemeral_storage_request=200,
       ephemeral_storage_limit=400,
   ),
   env={
       "WANDB_API_KEY": args.wandb_api_key
   }
)
service.deploy(workspace_fqn=args.workspace_fqn)

Schritt 5 – Service über Truefoundry deployen

Führen Sie den folgenden Befehl aus und übergeben Sie Ihre

• Workspace FQN: die Sie im Dashboard finden können
• Wandb API Key

python deploy.py --workspace_fqn "<Your Workspace FQN>" --wandb_api_key "<Your Wandb API Key>"

Und voila!!! In den Logs finden Sie das Dashboard Ihres bereitgestellten Service. Oben rechts finden Sie dann den Endpunkt Ihrer bereitgestellten Anwendung.

TrueFoundry ist eine ML Deployment PaaS auf Kubernetes, um Entwickler-Workflows zu beschleunigen und ihnen volle Flexibilität beim Testen und Deployen von Modellen zu bieten, während gleichzeitig volle Sicherheit und Kontrolle für das Infra-Team gewährleistet werden. Über unsere Plattform ermöglichen wir Machine Learning Teams, Modelle in 15 Minuten mit 100 % Zuverlässigkeit, Skalierbarkeit und der Möglichkeit zum Rollback in Sekunden zu deployen und zu überwachen – so können sie Kosten sparen und Modelle schneller in Produktion bringen, was echten Geschäftswert schafft.