Plattformintegrationen für maschinelles Lernen #1: Gewichte und Vorurteile

Die Nachverfolgung von Experimenten ist ein wichtiger Aspekt der Entwicklung des maschinellen Lernens und ermöglicht es Praktikern, den Fortschritt ihrer Experimente effizient zu verwalten und zu verfolgen. Bei der Versuchsverfolgung werden verschiedene Faktoren wie Modellleistung, Hyperparameter und Trainingsdaten aufgezeichnet und überwacht, um Einblicke in die Leistung des Modells für maschinelles Lernen zu gewinnen.

Herausforderungen bei der Verwaltung von Experimenten

Die Verwaltung von Experimenten und die Verfolgung von Ergebnissen können für Praktiker des maschinellen Lernens aufgrund der Komplexität der Modelle, der großen Datenmengen und der Vielzahl der Tools und Frameworks, die bei der Entwicklung des maschinellen Lernens verwendet werden, eine herausfordernde Aufgabe sein. Hier sind einige der wichtigsten Herausforderungen, mit denen Praktiker bei der Verwaltung von Experimenten und der Verfolgung von Ergebnissen konfrontiert sind:

1. Reproduzierbarkeit: Die Reproduktion von Experimenten ist unerlässlich, um Ergebnisse zu verifizieren und sicherzustellen, dass Modelle in realen Szenarien gut funktionieren. Die Reproduktion von Experimenten kann jedoch eine Herausforderung sein, insbesondere wenn es sich um komplexe Modelle, mehrere Frameworks und unterschiedliche Computerumgebungen handelt.
2. Skalierbarkeit: Praktiker des maschinellen Lernens arbeiten oft mit großen Datensätzen, und daher kann das Training von Modellen ein zeitaufwändiger Prozess sein, der eine erhebliche Menge an Rechenleistung erfordert. Für die Verwaltung von Experimenten und die Verfolgung von Ergebnissen in großem Maßstab sind Tools und Infrastrukturen erforderlich, die große Datenmengen und Berechnungen verarbeiten können.
3. Zusammenarbeit: Zusammenarbeit ist bei der Entwicklung von maschinellem Lernen unerlässlich, aber die Verwaltung von Experimenten und die Verfolgung der Ergebnisse mehrerer Teammitglieder kann eine Herausforderung sein. Dazu ist eine robuste Infrastruktur erforderlich, um Daten, Code und Versuchsergebnisse gemeinsam zu nutzen und sicherzustellen, dass jeder Zugriff auf dieselben Ressourcen hat.
4. Datenmanagement: Modelle für maschinelles Lernen sind stark von Daten abhängig, und die effektive Verwaltung von Daten ist entscheidend für den Erfolg des Modells. Die Verwaltung von Daten ist jedoch mit verschiedenen Herausforderungen verbunden, wie z. B. Datenbereinigung, Datenkennzeichnung und Datenversionierung, was zeitaufwändig und komplex sein kann.
5. Hyperparameter-Optimierung: Das Finden der besten Hyperparameter für ein Modell kann ein schwieriger und iterativer Prozess sein, bei dem mehrere Experimente mit unterschiedlichen Hyperparametern durchgeführt werden müssen. Die Verwaltung dieser Experimente und die Nachverfolgung der Ergebnisse können zeitaufwändig und komplex sein.

Untersuchung der Merkmale von Gewichtungen und Verzerrungen

Gewichte und Vorurteile (W&B) ist eine Plattform, die Praktikern des maschinellen Lernens dabei helfen soll, ihre Experimente effektiv zu verwalten und zu verfolgen. Sie bietet eine Reihe von Tools für die Nachverfolgung, Visualisierung und Zusammenarbeit von Experimenten und erleichtert es Praktikern, robuste und skalierbare Modelle für maschinelles Lernen zu entwickeln.

Die wichtigsten Funktionen und Vorteile der W&B-Plattform sind:

1. Versuchsverfolgung: W&B ermöglicht es Benutzern, ihre Experimente zu verfolgen, indem Modellhyperparameter, Metriken und Ausgabeartefakte automatisch protokolliert werden. Auf diese Weise können Praktiker ihre Experimente verfolgen und verschiedene Modelle und Hyperparameter einfach vergleichen.
2. Visualisierungen: W&B bietet eine Reihe von Visualisierungstools, mit denen Benutzer ihre Experimente und Ergebnisse visualisieren können. Dazu gehören unter anderem 3D-Visualisierungen, Konfusionsmatrizen und Streudiagramme. Dies hilft Praktikern, ihre Daten besser zu verstehen und Muster und Trends in den Versuchsergebnissen zu erkennen.
3. Zusammenarbeit: W&B erleichtert die Zusammenarbeit mit Teammitgliedern, indem es Funktionen für den Austausch von Experimenten, Daten und Ergebnissen bereitstellt. Es bietet auch Versionskontrolle für Code und Daten und stellt so sicher, dass alle mit den gleichen Ressourcen arbeiten.
4. Integration: W&B kann problemlos in eine Vielzahl von Frameworks für maschinelles Lernen integriert werden, darunter TensorFlow, PyTorch, Keras und Scikit-Learn. Dadurch können Praktiker W&B mit ihren bestehenden Workflows und Frameworks verwenden, ohne dass wesentliche Änderungen an ihrem Entwicklungsprozess erforderlich sind.
5. Organisation: W&B bietet Funktionen zur Organisation von Experimenten wie Projekten, Durchläufen und Tags. Dies macht es einfach, Experimente über mehrere Teammitglieder und Projekte hinweg zu verwalten und nachzuverfolgen.

Schrittweise Anleitung: Das Einrichten von Gewichten und Verzerrungen leicht gemacht

Die Einrichtung von W&B für das Tracking von Experimenten umfasst mehrere Schritte:

1. Eröffnen Sie ein W&B-Konto: Der erste Schritt besteht darin, ein kostenloses Konto auf der W&B-Website zu eröffnen. Dies kann geschehen, indem Sie die Website besuchen und dem Anmeldevorgang folgen.
2. Installieren Sie die W&B-Bibliothek: Nachdem Sie sich für ein Konto angemeldet haben, müssen Sie im nächsten Schritt die W&B-Bibliothek in der Entwicklungsumgebung installieren. Die W&B-Bibliothek kann je nach Präferenz und Entwicklungsumgebung des Benutzers mit Pip oder Conda installiert werden.
3. W&B initialisieren: Sobald die Bibliothek installiert ist, muss der Benutzer W&B im Code initialisieren, indem er den und b.init () Funktion. Diese Funktion initialisiert die W&B-Bibliothek und richtet einen neuen Lauf ein.
4. Messwerte protokollieren: Der Benutzer kann Messwerte wie Verlust und Genauigkeit während des Trainings protokollieren, indem er den wandb.log () Funktion. Diese Funktion verwendet ein Wörterbuch mit Metriken als Eingabe und protokolliert sie im W&B-Dashboard.
5. Hyperparameter protokollieren: Der Benutzer kann auch Hyperparameter wie Lernrate und Batchgröße protokollieren, indem er den w und b.config Funktion. Diese Funktion verwendet ein Wörterbuch mit Hyperparametern als Eingabe und protokolliert sie im W&B-Dashboard.
6. Visualisierungen protokollieren: Schließlich kann der Benutzer Visualisierungen wie Bilder und Plots protokollieren, indem er den wandb.log () Funktion mit den entsprechenden Visualisierungsdaten. W&B bietet eine breite Palette von Visualisierungstools, darunter unter anderem 3D-Visualisierungen, Konfusionsmatrizen und Streudiagramme.

Beispiel:

Hier ist ein Beispiel für die Protokollierung von Metriken, Modellen, Hyperparametern und Visualisierungen mit W&B:

wandb importieren
importiere numpy als np
importiere matplotlib.pyplot als plt
importiere Tensorflow als tf

# Schritt 1: W&B initialisieren
wandb.init (project="mein-projekt“)

# Schritt 2: Hyperparameter protokollieren
Konfiguration = {
„learning_rate“: 0,001,
„Batchgröße“: 32,
„Epochen“: 10
}
wandb.config.update (Konfiguration)

# Schritt 3: Modell trainieren und Metriken protokollieren
modell = tf.keras.Models.Sequential ([
tf.keras.layers.Dense (10, Aktivierung = '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 ()])
für Epoche im Bereich (config ['epochs']):
#... Eisenbahnmodell...
history = model.fit (x_train, y_train, batch_size=config ['batch_size'])
verlust = history.history ['Verlust'] [-1]
mae = history.history ['mean_absolute_error'] [-1]
wandb.log ({"Epoche“: Epoche, „Verlust“: Verlust, „mae“: mae})

# Schritt 4: Visualisierungen und Modell protokollieren
x = np.linspace (0, 10, 100)
y = np.sin (x)
fig, ax = plt.subplots ()
ax.plot (x, y)
wandb.log ({"mein_plot“: Wandb.Image (Bild)})
wandb.save ('mein_model.h5')

# Schritt 5: Lauf beenden
und b.finish ()

c

Nahtlose Integration: TrueFoundrys Ansatz für Gewichtungen und Verzerrungen

TrueFoundry lässt sich nahtlos in Weights & Biases Model Registry integrieren, sodass Sie in Weights & Biases angemeldete Modelle mithilfe von TrueFoundry in Ihrem Kubernetes-Cluster bereitstellen können.

📌

Neben der Verwendung von Weights & Biases für die Modellverwaltung und das Experimentations-Tracking können Sie auch Truefoundrys Experimentation Tracking MLFoundy verwenden.

📌

Sie können dem folgenden Code auch über das folgende Colab-Notizbuch folgen:
Colab Notizbuch

Schritt 1 — Installation und Einrichtung:

• Installieren Sie wandb

pip install wandb -qU

• Loggen Sie sich in Ihr W&B-Konto ein

wandb importieren
und b.login ()

• Installieren Sie servicefoundry

pip install -U „Servicefoundry“

• Loggen Sie sich bei Truefoundry ein

sfy einloggen

Schritt 2 — Trainiere und protokolliere das Modell:

Wir werden zuerst verwenden und b.init () um das Projekt zu initialisieren
Dann trainieren wir unser ML-Modell und speichern es als Joblib-Datei
Dann speichern wir unsere Joblib-Datei auf wandb über und b.save ()

wandb importieren
importiere load_iris aus sklearn.datasets
aus sklearn.model_selection importiere train_test_split
aus sklearn.linear_model importiere LogisticRegression
aus sklearn.metrics importiere classification_report
joblib importieren

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

# Daten laden und vorverarbeiten
X, y = load_iris (as_frame=Wahr, return_X_Y=Wahr)
X = x.Umbenennen (Spalten= {
„sepal length (cm)“: „sepal_length“,
„sepal width (cm)“: „sepal_width“,
„petal length (cm)“: „petal_length“,
„petal width (cm)“: „petal_width“,
})

X_Zug, X_Test, y_Zug, y_test = Zugtest_split (
X, y, test_size=0,2, random_state=42, stratify=y
)

# Initialisieren Sie das Modell
clf = logisticRegression (solver="liblinear“)

# Passen Sie das Modell an
clf.fit (X_Zug, y_Zug)

# Evaluiere das Modell
drücken = clf.predict (X_Test)

# Loggen Sie das Modell und die Bewertungsmetriken in W&B ein
joblib.dump (clf, „model.joblib“)
wandb.save („model.joblib“)

# Beende den Lauf
und b.finish ()

Schritt 3 — Erstellen Sie eine Inferenzanwendung und eine Abhängigkeitsdatei:

Wir müssen zwei Dateien erstellen, um sie auf Truefoundry bereitzustellen, 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 das folgende Argument in der undb.restore () : <name_of_saved_file> und „Benutzername/Projekt/Run_ID“
  ZB: wandb.restore („model.joblib“, „adityajha-tfy/iris-logistic-regression/00r5xvyv“)

Betriebssystem importieren
wandb importieren
joblib importieren
importiere Pandas als PDF
von Fastapi importiere FastAPI

wandb.login (schlüssel=os.environ ["WANDB_API_KEY"])

# Rufen Sie das Modell von W&B ab
model_joblib = wandb.restore (
„model.joblib“,
run_path="adityajha-tfy/iris-logistic-regression/00r5xvyy“,
)

modell = joblib.load (model_joblib.name)

# Laden Sie das Modell
app = FastAPI (root_path=os.getenv („TFY_SERVICE_WURZELPFAD“))

@app .post („/predict“)
auf jeden Fall vorhersagen (
Kelchblattlänge: Float, Kelchblattbreite: Float, Blütenblattlänge: Float, Blütenblattbreite: Float
):
Daten = Diktat (
Kelchblattlänge=Kelchblattlänge,
sepal_width=Kelchblattbreite,
blütenblattlänge=Blütenblattlänge,
petal_width=Blütenblattbreite,
)
Prognose = int (model.predict (pd.DataFrame ([Daten])) [0])
return {"Prognose“: Vorhersage}

• requirements.txt:

schnelle API
Joblib
Numpy
Pandas
Scikit-Learn
Uvicorn
Wandb

Schritt 4 — Verwenden Sie das Python-SDK von Truefoundry und konfigurieren Sie die Bereitstellung

• deploy.py:

argparse importieren
Protokollierung importieren
von Servicefoundry importieren Build, PythonBuild, Service, Ressourcen, Port

# Den Logger einrichten
logging.basicConfig (Level=logging.info)

# Den Argumentparser einrichten
Parser = argParse.ArgumentParser ()
parser.add_argument („--workspace_fqn“, erforderlich=wahr, typ=str)
parser.add_argument („--wandb_api_key“, erforderlich=wahr, typ=str)
Argumente = parser.parse_args ()

Dienst = Dienst (
name= „Fastapi“,
image=BUILD (
build_spec=PythonBuild (
command="uvicorn app:app --port 8000 --host 0.0.0.0",
Anforderungen_Pfad=“ requirements.txt „,
)
),
Anschlüsse= [
Hafen (
Anschluss = 8000,
host="ml-deploy-aditya-ws-8000.demo.truefoundry.com“,
)
],
Resources=Ressourcen (
cpu_request=0,25,
CPU-Limit = 0,5,
Speicheranforderung = 200,
Speicherlimit = 400,
ephemerale_storage_request=200,
kurzlebiges Speicherlimit = 400,
),
env= {
„WANDB_API_KEY“: args.wandb_api_key
}
)
service.deploy (workspace_fqn=args.workspace_fqn)

Schritt 5 — Stellen Sie Ihren Service über Truefoundry bereit

Führen Sie den folgenden Befehl aus und geben Sie Ihre ein

• Workspace-FQN: die du im Dashboard findest
• Wandb API-Schlüssel

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

Und voila!!! In den Protokollen finden Sie das Dashboard Ihres bereitgestellten Dienstes. Und dann finden Sie in der oberen rechten Ecke den Endpunkt Ihrer bereitgestellten Anwendungen.

Wahre Gießerei ist ein ML Deployment PaaS über Kubernetes, um die Workflows von Entwicklern zu beschleunigen und ihnen gleichzeitig volle Flexibilität beim Testen und Bereitstellen von Modellen zu bieten und gleichzeitig die volle Sicherheit und Kontrolle für das Infra-Team zu gewährleisten. Über unsere Plattform ermöglichen wir Teams für maschinelles Lernen bereitstellen und überwachen Modelle innerhalb von 15 Minuten mit 100% iger Zuverlässigkeit, Skalierbarkeit und der Möglichkeit, innerhalb von Sekunden rückgängig zu machen. So können sie Kosten sparen und Modelle schneller für die Produktion freigeben, wodurch ein echter Geschäftswert erzielt wird.