Machine Learning Tool Integrationen #2: DVC für Ihre Datenversionierung

Data Version Control (DVC) ist ein leistungsstarkes Tool zur Verwaltung und Versionierung großer Datensätze und Modelle in Machine Learning-Projekten.

DVC ist ein Open-Source-Tool, das mit einer Vielzahl von Speicheroptionen funktioniert, darunter lokale Festplatten, Netzwerkdateisysteme, Amazon S3, Google Cloud Storage und viele andere. DVC kann in Kombination mit beliebten Machine Learning-Frameworks wie TensorFlow, PyTorch und scikit-learn verwendet werden.

Zusätzlich zur Nachverfolgung von Änderungen an Daten und Modellen hilft DVC Benutzern auch bei der Verwaltung von Abhängigkeiten zwischen verschiedenen Komponenten eines Machine Learning-Projekts wie Code, Daten und Modellen. Durch die Nachverfolgung dieser Abhängigkeiten erleichtert DVC die Reproduktion von Machine Learning-Experimenten und das Teilen von Projekten mit anderen.

Herausforderungen der Versionskontrolle im Machine Learning

Die Versionskontrolle im Machine Learning ist im Vergleich zur Softwareentwicklung aus folgenden Gründen eine schwierigere Aufgabe:

1. Große und komplexe Datensätze: Im Machine Learning können die zum Trainieren und Testen von Modellen verwendeten Datensätze riesig sein, was ihre Verwaltung und Versionierung herausfordernd macht. Darüber hinaus können die Daten unstrukturiert sein, was das Nachverfolgen von Datenänderungen im Laufe der Zeit erschwert.
2. Mehrere Komponenten: Machine Learning-Projekte umfassen oft mehrere Komponenten, einschließlich Daten, Code und Modelle. Dadurch wird es schwierig, den Überblick über Änderungen an jeder Komponente und deren Interaktionen untereinander zu behalten.
3. Iterativer Entwicklungsprozess: Im Machine Learning ist der Entwicklungsprozess oft iterativ. Entwickler aktualisieren Modelle häufig auf der Grundlage neuer Daten oder zur Verbesserung der Modellgenauigkeit. Die Verwaltung dieser Änderungen und Versionen kann komplex und zeitaufwendig sein.

DVC löst diese Probleme, indem es eine einfache und effiziente Möglichkeit bietet, sowohl Daten als auch Modelle in Machine Learning-Projekten zu versionieren. Mit DVC können Sie nicht nur den Code, sondern auch die Daten und Modelle versionieren und die Beziehungen zwischen ihnen nachverfolgen. Mit DVC können Sie frühere Experimente problemlos reproduzieren, mit Teammitgliedern zusammenarbeiten und Workflows automatisieren, um den Entwicklungsprozess zu optimieren.

Installation und Einrichtung von Versionskontrollsystemen

Um mit DVC zu beginnen, müssen Sie es auf Ihrem lokalen Rechner installieren und einrichten. In diesem Abschnitt bieten wir eine Schritt-für-Schritt-Anleitung dazu, einschließlich der Konfiguration von DVC für die Arbeit mit verschiedenen Cloud-Speicherdiensten und der Erstellung eines neuen DVC-Projekts.

1. DVC installieren: Der erste Schritt besteht darin, DVC auf Ihrem lokalen Rechner zu installieren. Sie können dies tun, indem Sie den Installationsanweisungen für Ihr Betriebssystem auf der DVC-Website folgen.
2. Ein neues DVC-Projekt erstellen: Sobald DVC installiert ist, können Sie ein neues DVC-Projekt erstellen, indem Sie den folgenden Befehl in Ihrem Terminal ausführen:

dvc init


Dadurch wird ein neues DVC-Projekt in Ihrem aktuellen Verzeichnis erstellt.

3. DVC für die Arbeit mit Cloud-Speicher konfigurieren: Wenn Sie DVC mit Cloud-Speicherdiensten wie Amazon S3 oder Google Cloud Storage verwenden möchten, müssen Sie DVC entsprechend konfigurieren. Sie können dies tun, indem Sie ein neues Remote mit dem folgenden Befehl hinzufügen:

dvc remote add -d <remote-name> <storage-url>


Wenn Sie beispielsweise ein Amazon S3-Remote mit dem Namen "my-s3-remote" hinzufügen möchten, können Sie den folgenden Befehl ausführen:

dvc remote add -d my-s3-remote s3://my-bucket-name


Dadurch wird Ihrem DVC-Projekt ein neues Remote hinzugefügt, das für die Arbeit mit Amazon S3 konfiguriert ist.

4. Daten zu Ihrem DVC-Projekt hinzufügen: Sobald Sie Ihr DVC-Projekt eingerichtet und für die Arbeit mit Cloud-Speicher konfiguriert haben, können Sie mit dem Hinzufügen von Daten beginnen. Dies tun Sie mit folgendem Befehl:

dvc add <path-to-data-file>


Dadurch wird die Datendatei zu Ihrem DVC-Projekt hinzugefügt und eine entsprechende DVC-Datei erstellt, die Änderungen an den Daten nachverfolgt.

5. Änderungen an den Remote-Speicher übertragen: Wenn Sie Ihr DVC-Projekt für die Arbeit mit Remote-Speicher konfiguriert haben, können Sie Änderungen mit dem folgenden Befehl an diesen Speicher übertragen:

dvc push


Dadurch werden alle Änderungen, die Sie an Ihren Daten oder Modellen vorgenommen haben, an den Remote-Speicher übertragen.

Ausführen von DVC-Befehlen für erweiterte Versionskontrolle

DVC bietet eine Reihe nützlicher Befehle zur Verwaltung und Versionierung von Machine Learning-Projekten. Hier ist eine Liste der am häufigsten verwendeten DVC-Befehle:

1. dvc init: Initialisiert ein neues DVC-Projekt im aktuellen Verzeichnis.
2. dvc add <path-to-file>: Fügt eine Datei zu DVC hinzu und erstellt eine entsprechende DVC-Datei, um Änderungen an der Datei nachzuverfolgen.
3. dvc run: Führt einen Befehl oder ein Skript mit aktivierter DVC-Nachverfolgung aus, sodass alle Eingaben und Ausgaben von DVC nachverfolgt werden.
4. dvc repro: Reproduziert einen von DVC nachverfolgten Befehl oder ein Skript und stellt sicher, dass alle Abhängigkeiten aktuell sind.
5. dvc push: Überträgt alle Datendateien und Modelldateien an den Remote-Speicher wie AWS S3 oder Google Cloud Storage.
6. dvc pull: Lädt alle Datendateien und Modelldateien vom Remote-Speicher auf den lokalen Rechner herunter.
7. dvc status: Zeigt den Status nachverfolgter Dateien an, einschließlich der Information, ob sie geändert, hinzugefügt oder gelöscht wurden.
8. dvc log: Zeigt eine Liste aller Versionen einer Datei zusammen mit ihren entsprechenden Commit-Nachrichten und anderen Metadaten an.

Reproduzieren von ML-Experimenten mit DVC

Einer der bedeutendsten Vorteile der Verwendung von DVC ist die Fähigkeit, Machine Learning-Experimente zu reproduzieren. Mit DVC können Sie die Abhängigkeiten zwischen Ihrem Code, Ihren Daten und Ihren Modellen definieren und nachverfolgen und den Befehl dvc repro verwenden, um frühere Experimente zu reproduzieren.

Beispiel-Workflow:
Hier ist ein Beispiel-Workflow für einen sklearn Iris-Datensatz unter Verwendung einer .yaml-Datei:

1. Initialisieren Sie zuerst ein neues DVC-Projekt durch Ausführen des Befehls dvc init.
2. Erstellen Sie ein Verzeichnis data in Ihrem Projektordner, um den Datensatz zu speichern, und laden Sie den sklearn Iris-Datensatz in dieses Verzeichnis herunter.
3. Fügen Sie die Datendateien mit dem Befehl dvc add zu DVC hinzu. Zum Beispiel: dvc add data/iris.csv.
4. Erstellen Sie eine Datei .yaml, um die Pipeline zu definieren. Zum Beispiel iris.yaml. Diese Datei enthält die Befehle für die Vorverarbeitung, das Training und die Evaluierung des Modells.
5. Definieren Sie die Schritte in der Datei .yaml mithilfe der DVC-Befehle. Zum Beispiel:

stages:
 preprocess:
   cmd: python preprocess.py data/iris.csv data/preprocessed.csv
   deps:
     - data/iris.csv
   outs:
     - data/preprocessed.csv

 train:
   cmd: python train.py data/preprocessed.csv models/model.pkl
   deps:
     - data/preprocessed.csv
   outs:
     - models/model.pkl

 evaluate:
   cmd: python evaluate.py models/model.pkl data/iris.csv
   deps:
     - models/model.pkl
     - data/iris.csv


6. Führen Sie die Pipeline mit dem Befehl dvc repro aus. Dieser Befehl führt die in der .yaml-Datei definierten Schritte in der richtigen Reihenfolge aus und stellt sicher, dass alle Abhängigkeiten auf dem neuesten Stand sind. Zum Beispiel: dvc repro iris.yaml.

Indem Sie Ihre Pipeline in einer .yaml-Datei definieren und den Befehl dvc repro verwenden, können Sie Ihre Experimente problemlos reproduzieren, die Versionen Ihrer Daten und Modelle nachverfolgen und mit Teammitgliedern an Ihrem Machine Learning-Projekt zusammenarbeiten.

Hier ist ein Beispiel-Workflow:

1. Richten Sie die entsprechenden Anmeldeinformationen und Endpunktinformationen für den S3-Server ein:

dvc remote add -d s3remote s3://your-s3-bucket-name/path/to/models


2. Laden Sie die erforderlichen Modelldateien vom S3-Server auf den lokalen Rechner herunter:

dvc pull -r s3remote path/to/models/model.pkl


3. Kopieren Sie die heruntergeladenen Modelldateien auf den Ziel-Remote-Server:

scp path/to/models/model.pkl user@target-remote-server:/path/to/models/


4. Verwenden Sie die kopierten Dateien für die Inferenz auf dem Ziel-Remote-Server:

# Load the model
import pickle
with open('/path/to/models/model.pkl', 'rb') as f:
   model = pickle.load(f)

# Make predictions
X_test = [[5.1, 3.5, 1.4, 0.2], [7.7, 3.0, 6.1, 2.3], [6.0, 3.0, 4.8, 1.8]]
y_pred = model.predict(X_test)
print(y_pred)


Dieser Workflow setzt voraus, dass Sie die erforderlichen Anmeldeinformationen und Endpunktinformationen für den S3-Server eingerichtet haben und dass Sie Zugriff sowohl auf den lokalen als auch auf den Ziel-Remote-Server haben. Sie können den Workflow basierend auf Ihren spezifischen Anforderungen und Ihrer Einrichtung anpassen.

Wie TrueFoundry mit DVC integriert wird:

TrueFoundry lässt sich nahtlos in die DVC Model Registry integrieren, sodass Sie in DVC protokollierte Modelle mithilfe von TrueFoundry in Ihrem Kubernetes-Cluster bereitstellen können.

📌

Neben der Verwendung von DVC für Modellverwaltung und Experiment-Tracking können Sie auch das Experiment-Tracking MLFoundry von TrueFoundry nutzen.

Schritt 1 – Installation und Einrichtung:

• DVC einrichten

# Install DVC and S3 support
pip install dvc dvc-s3

# Initialize Git in the local directory
git init

# Initilize DVC in the local directory
dvc init

# Set DVC remote storage as your bucket
dvc remote add s3://<your_bucket_name>

Hinweis: Sie müssen Ihre s3 cli konfigurieren, damit dies funktioniert

• dvc importieren

import dvc

x

• servicefoundry installieren

pip install -U "servicefoundry"

• Bei TrueFoundry anmelden

sfy login

Schritt 2 – Modell trainieren und protokollieren:

Wir werden unser ML-Modell trainieren und es als joblib-Datei speichern
Anschließend fügen wir das Modell und die Evaluierungsmetriken mit **`dvc add`** hinzu
Danach übertragen wir unsere joblib-Datei via **`dvc push`** an DVC

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
import os

# 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)

# Save the model using joblib and DVC
joblib.dump(clf, "model.joblib")
os.system("dvc add model.joblib")

# Log the evaluation metrics
report = classification_report(y_test, preds, output_dict=True)
with open("classification_report.txt", "w") as f:
   f.write(str(report))

# Push the model and evaluation metrics to the remote storage
os.system("dvc push")

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

Wir müssen zwei Dateien für die Bereitstellung auf TrueFoundry erstellen: 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


• app.py:

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

# Retrieve the model from S3 using DVC
os.system("dvc pull model.joblib.dvc")

# Load the model
model = joblib.load("model.joblib")

# Load the model
app = FastAPI()

@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
pandas
joblib
dvc

Schritt 4 – Das Python SDK von TrueFoundry verwenden und die Bereitstellung 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)
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,
   ),
)
service.deploy(workspace_fqn=args.workspace_fqn)

Schritt 5 – Ihren Service über TrueFoundry bereitstellen

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

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

python deploy.py --workspace_fqn your_workspace_fqn

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 gleichzeitig volle Flexibilität beim Testen und Bereitstellen von Modellen zu bieten – bei vollständiger Sicherheit und Kontrolle für das Infra-Team. Über unsere Plattform ermöglichen wir Machine Learning-Teams, Modelle in 15 Minuten mit 100 % Zuverlässigkeit, Skalierbarkeit und der Möglichkeit zu deployen und zu überwachen, in Sekundenschnelle Rollbacks durchzuführen – was Kosten spart, Modelle schneller in die Produktion bringt und echten Geschäftswert realisiert.