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 Verbindung mit gängigen Frameworks für maschinelles Lernen wie TensorFlow, PyTorch und Scikit-Learn verwendet werden.

DVC verfolgt nicht nur Änderungen an Daten und Modellen, sondern kann Benutzern auch dabei helfen, Abhängigkeiten zwischen verschiedenen Komponenten eines Machine-Learning-Projekts wie Code, Daten und Modellen zu verwalten. DVC behält den Überblick über diese Abhängigkeiten und erleichtert es so, Experimente mit maschinellem Lernen zu reproduzieren und Projekte mit anderen zu teilen.

Herausforderungen der Versionskontrolle beim maschinellen Lernen

Die Versionskontrolle beim maschinellen Lernen ist im Vergleich zur Softwareentwicklung aus den folgenden Gründen eine schwierigere Aufgabe:

1. Große und komplexe Datensätze: Beim maschinellen Lernen können die Datensätze, die für das Training und Testen von Modellen verwendet werden, sehr umfangreich sein, sodass es schwierig ist, sie zu verwalten und zu versionieren. Darüber hinaus können die Daten unstrukturiert sein, was es schwierig macht, Änderungen an den Daten im Laufe der Zeit nachzuverfolgen.
2. Mehrere Komponenten: Machine-Learning-Projekte umfassen oft mehrere Komponenten, darunter Daten, Code und Modelle, was es schwierig macht, Änderungen an den einzelnen Komponenten und deren Interaktion miteinander im Auge zu behalten.
3. Iterativer Entwicklungsprozess: Beim maschinellen Lernen ist der Entwicklungsprozess oft iterativ, wobei Entwickler häufig Modelle auf der Grundlage neuer Daten aktualisieren oder die Genauigkeit des Modells verbessern. Die Verwaltung dieser Änderungen und Versionen kann komplex und zeitaufwändig sein.

DVC löst diese Probleme, indem es eine einfache und effiziente Möglichkeit zur Versionskontrolle von Daten und Modellen in Projekten für maschinelles Lernen bietet. DVC ermöglicht es Ihnen, nicht nur den Code, sondern auch die Daten und Modelle zu versionieren und die Beziehungen zwischen ihnen nachzuverfolgen. Mit DVC können Sie frühere Experimente problemlos reproduzieren, mit Teammitgliedern zusammenarbeiten und Arbeitsabläufe automatisieren, um den Entwicklungsprozess zu optimieren.

Installation und Einrichtung von Versionskontrollsystemen

Um mit DVC zu beginnen, müssen Sie es auf Ihrem lokalen Computer installieren und einrichten. In diesem Abschnitt finden Sie schrittweise Anleitungen dazu, einschließlich der Konfiguration von DVC für die Verwendung mit verschiedenen Cloud-Speicherdiensten und der Erstellung eines neuen DVC-Projekts.

1. DVC installieren: Der erste Schritt besteht darin, DVC auf Ihrem lokalen Computer zu installieren. Sie können dies tun, indem Sie den Installationsanweisungen für Ihr Betriebssystem auf der DVC-Website folgen.
2. 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-initiieren


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

3. DVC so konfigurieren, dass es mit Cloud-Speicher funktioniert: Wenn Sie DVC mit Cloud-Speicherdiensten wie Amazon S3 oder Google Cloud Storage verwenden möchten, müssen Sie DVC so konfigurieren, dass es mit diesen Diensten funktioniert. Sie können dies tun, indem Sie mit dem folgenden Befehl eine neue Fernbedienung hinzufügen:

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


Wenn Sie beispielsweise eine Amazon S3-Fernbedienung 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 eine neue Fernbedienung hinzugefügt, die für die Verwendung mit Amazon S3 konfiguriert ist.

4. Daten zu Ihrem DVC-Projekt hinzufügen: Sobald Sie Ihr DVC-Projekt eingerichtet und für die Verwendung mit Cloud-Speicher konfiguriert haben, können Sie damit beginnen, Daten hinzuzufügen. Sie können dies tun, indem Sie den folgenden Befehl ausführen:

dvc hinzufügen <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 verfolgt.

5. Änderungen an den Remotespeicher übertragen: Wenn Sie Ihr DVC-Projekt so konfiguriert haben, dass es mit dem Remotespeicher funktioniert, können Sie Änderungen an diesen Speicher übertragen, indem Sie den folgenden Befehl ausführen:

dvc-Push


Dadurch werden alle Änderungen, die Sie an Ihren Daten oder Modellen vorgenommen haben, auf den Remotespeicher übertragen.

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

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

1. dvc-initiieren: Initialisiert ein neues DVC-Projekt im aktuellen Verzeichnis.
2. dvc hinzufügen <path-to-file>: Fügt eine Datei zu DVC hinzu und erstellt eine entsprechende DVC-Datei, um Änderungen an der Datei zu verfolgen.
3. dvc run: Führt einen Befehl oder ein Skript mit aktiviertem DVC-Tracking aus, sodass alle Ein- und Ausgänge von DVC verfolgt werden.
4. dvc-Repro: Reproduziert einen Befehl oder ein Skript mit DVC-Tracking und stellt so sicher, dass alle Abhängigkeiten aktuell sind.
5. dvc-Push: Verschiebt alle Daten- und Modelldateien in den Remotespeicher wie AWS S3 oder Google Cloud Storage.
6. DVC-Pull: Ruft alle Daten- und Modelldateien vom Remotespeicher auf den lokalen Computer ab.
7. dvc-Status: Zeigt den Status der verfolgten Dateien an, einschließlich ob sie geändert, hinzugefügt oder gelöscht wurden.
8. dvc-Protokoll: Zeigt eine Liste aller Versionen einer Datei zusammen mit den entsprechenden Commit-Nachrichten und anderen Metadaten an.

Reproduktion von ML-Experimenten mit DVC

Einer der wichtigsten Vorteile der Verwendung von DVC ist die Fähigkeit, Experimente mit maschinellem Lernen zu reproduzieren. Mit DVC können Sie die Abhängigkeiten zwischen Ihrem Code, Ihren Daten und Modellen definieren und verfolgen und die dvc-Repro Befehl, um frühere Experimente zu reproduzieren.

Beispiel für einen Arbeitsablauf:
Sicher, hier ist ein Beispiel-Workflow für einen Sklearn-Iris-Datensatz mit einer.yaml-Datei:

1. Initialisieren Sie zunächst ein neues DVC-Projekt, indem Sie den Befehl ausführen dvc-initiieren.
2. Erstellen Sie eine Daten Verzeichnis 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 füge data/iris.csv hinzu.
4. Erstellen Sie eine .yaml Datei zur Definition der Pipeline. Zum Beispiel iris.yaml. Diese Datei wird die Befehle für die Vorverarbeitung, das Training und die Bewertung des Modells enthalten.
5. Definieren Sie die Schritte in der .yaml Datei mit den DVC-Befehlen. Zum Beispiel:

Etappen:
vorverarbeiten:
Befehl: python preprocess.py data/iris.csv data/preprocessed.csv
Deps:
- data/iris.csv
Ausgänge:
- data/preprocessed.csv

Zug:
cmd: python train.py data/preprocessed.csv models/model.pkl
Deps:
- data/preprocessed.csv
Ausgänge:
- models/model.pkl

bewerten:
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 so sicher, dass alle Abhängigkeiten auf dem neuesten Stand sind. Zum Beispiel: dvc repro iris.yaml.

Indem Sie Ihre Pipeline in einem definieren .yaml Datei und unter Verwendung der dvc-Repro Mit diesem Befehl können Sie Ihre Experimente einfach reproduzieren, die Versionen Ihrer Daten und Modelle verfolgen und mit Teammitgliedern an Ihrem Machine-Learning-Projekt zusammenarbeiten.

Hier ist ein Beispiel für einen Arbeitsablauf:

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. Ziehen Sie die erforderlichen Modelldateien vom S3-Server auf den lokalen Computer:

dvc pull -r s3Remotepfad/zum/models/model.pkl


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

scp pfad/zum/models/model.pkl Benutzer @target -remote-server: /pfad/zum/models/


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

# Laden Sie das Modell
Gurke importieren
mit open ('/path/to/models/model.pkl', 'rb') als f:
modell = pickle.load (f)

# Vorhersagen treffen
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)
drucken (y_pred)


Bei diesem Workflow wird davon ausgegangen, 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 an Ihre spezifischen Anforderungen und Einstellungen anpassen.

So lässt sich TrueFoundry in DVC integrieren:

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

📌

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

Schritt 1 — Installation und Einrichtung:

• DVC einrichten

# Installieren Sie DVC- und S3-Unterstützung
pip installiere dvc dvc-s3

# Initialisiere Git im lokalen Verzeichnis
git init

# Initialisieren Sie DVC im lokalen Verzeichnis
dvc-initiieren

# Stellen Sie den DVC-Remote-Speicher als Ihren Bucket ein
dvc remote add s3://<your_bucket_name>

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

• DVC importieren

dvc importieren

x

• Installieren Sie servicefoundry

pip install -U „Servicefoundry“

• Loggen Sie sich bei truefoundry ein

sfy einloggen

Schritt 2 — Trainiere und protokolliere das Modell:

Wir werden unser ML-Modell trainieren und es als Joblib-Datei speichern
Dann fügen wir das Modell und die Bewertungsmetriken hinzu mit **`dvc hinzufügen`**
Dann werden wir unsere Joblib-Datei per Push auf dvc übertragen **`dvc push`**

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
Betriebssystem importieren

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

# Speichern Sie das Modell mit Joblib und DVC
joblib.dump (clf, „model.joblib“)
os.system („dvc füge model.joblib hinzu“)

# Protokollieren Sie die Bewertungsmetriken
report = classification_report (y_test, preds, output_dict=Wahr)
mit open (“ classification_report.txt „, „w“) als f:
f.write (str (bericht))

# Das Modell und die Bewertungsmetriken auf den Remote-Speicher übertragen
os.system („dvc push“)

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


• app.py:

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

# Rufen Sie das Modell mit DVC aus S3 ab
os.system („dvc pull model.joblib.dvc“)

# Laden Sie das Modell
modell = joblib.load („model.joblib“)

# Laden Sie das Modell
app = fastAPI ()

@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
Pandas
Joblib
dvc

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

python deploy.py --workspace_fqn dein_workspace_fqn

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.