Machine Learning Tool Integrations #2: DVC voor je Data Versioning

Data version control (DVC) is een krachtige tool voor het beheren en versiebeheer van grote datasets en modellen in machine learning-projecten.

DVC is een open-source tool die werkt met een breed scala aan opslagopties, waaronder lokale schijven, netwerkbestandssystemen, Amazon S3, Google Cloud Storage en vele andere. DVC kan worden gebruikt in combinatie met populaire machine learning-frameworks zoals TensorFlow, PyTorch en scikit-learn.

Naast het bijhouden van wijzigingen in data en modellen, kan DVC gebruikers ook helpen bij het beheren van afhankelijkheden tussen verschillende componenten van een machine learning-project, zoals code, data en modellen. Door deze afhankelijkheden bij te houden, maakt DVC het eenvoudiger om machine learning-experimenten te reproduceren en projecten met anderen te delen.

Uitdagingen van versiebeheer in Machine Learning

Versiebeheer in Machine Learning is een lastigere taak vergeleken met Software Engineering vanwege de volgende redenen:

1. Grote en complexe datasets: In machine learning kunnen de datasets die worden gebruikt voor het trainen en testen van modellen enorm zijn, wat het uitdagend maakt om ze te beheren en van versies te voorzien. Bovendien kan de data ongestructureerd zijn, waardoor het moeilijk is om wijzigingen in de data in de loop van de tijd te volgen.
2. Meerdere componenten: Machine learning-projecten omvatten vaak meerdere componenten, waaronder data, code en modellen, wat het uitdagend maakt om wijzigingen in elke component en hun onderlinge interactie bij te houden.
3. Iteratief ontwikkelproces: In Machine Learning is het ontwikkelproces vaak iteratief, waarbij ontwikkelaars modellen frequent bijwerken op basis van nieuwe data of om de nauwkeurigheid van het model te verbeteren. Het beheren van deze wijzigingen en versies kan complex en tijdrovend zijn.

DVC lost deze problemen op door een eenvoudige en efficiënte manier te bieden voor versiebeheer van zowel data als modellen in machine learning-projecten. DVC stelt je in staat om niet alleen de code, maar ook de data en modellen van versiebeheer te voorzien, en de relaties daartussen te volgen. Met DVC kun je eenvoudig eerdere experimenten reproduceren, samenwerken met teamleden en workflows automatiseren om het ontwikkelproces te stroomlijnen.

Installatie en instelling van versiebeheersystemen

Om aan de slag te gaan met DVC, moet je het installeren en instellen op je lokale machine. In deze sectie bieden we stapsgewijze instructies over hoe je dit doet, inclusief hoe je DVC configureert om te werken met verschillende cloudopslagdiensten en hoe je een nieuw DVC-project aanmaakt.

1. Installeer DVC: De eerste stap is het installeren van DVC op je lokale machine. Je kunt dit doen door de installatie-instructies voor jouw besturingssysteem op de DVC-website te volgen.
2. Maak een nieuw DVC-project aan: Zodra DVC is geïnstalleerd, kun je een nieuw DVC-project aanmaken door de volgende opdracht uit te voeren in je terminal:

dvc init


Dit maakt een nieuw DVC-project aan in je huidige map.

3. Configureer DVC om te werken met cloudopslag: Als je DVC wilt gebruiken met cloudopslagdiensten zoals Amazon S3 of Google Cloud Storage, moet je DVC configureren om met deze diensten te werken. Je kunt dit doen door een nieuwe remote toe te voegen met behulp van de volgende opdracht:

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


Als je bijvoorbeeld een Amazon S3-remote genaamd "my-s3-remote" wilt toevoegen, kun je de volgende opdracht uitvoeren:

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


Dit voegt een nieuwe remote toe aan je DVC-project die is geconfigureerd om te werken met Amazon S3.

4. Voeg data toe aan je DVC-project: Zodra je je DVC-project hebt ingesteld en geconfigureerd om te werken met cloudopslag, kun je beginnen met het toevoegen van data. Je kunt dit doen door de volgende opdracht uit te voeren:

dvc add <path-to-data-file>


Dit voegt het databestand toe aan je DVC-project en maakt een bijbehorend DVC-bestand aan dat wijzigingen in de data bijhoudt.

5. Push wijzigingen naar remote opslag: Als je je DVC-project hebt geconfigureerd om te werken met remote opslag, kun je wijzigingen naar deze opslag pushen door de volgende opdracht uit te voeren:

dvc push


Dit pusht alle wijzigingen die je in je data of modellen hebt aangebracht naar de remote opslag.

DVC-opdrachten uitvoeren voor verbeterd versiebeheer

DVC biedt een aantal nuttige opdrachten voor het beheren en van versies voorzien van machine learning-projecten. Hier is een lijst van enkele van de meest gebruikte DVC-opdrachten:

1. dvc init: Initialiseert een nieuw DVC-project in de huidige map.
2. dvc add <path-to-file>: Voegt een bestand toe aan DVC en maakt een bijbehorend DVC-bestand aan om wijzigingen in het bestand bij te houden.
3. dvc run: Voert een opdracht of script uit met DVC-tracking ingeschakeld, zodat alle invoer en uitvoer door DVC worden bijgehouden.
4. dvc repro: Reproduceert een door DVC bijgehouden opdracht of script, waarbij wordt gezorgd dat alle afhankelijkheden up-to-date zijn.
5. dvc push: Pusht alle databestanden en modelbestanden naar remote opslag, zoals AWS S3 of Google Cloud Storage.
6. dvc pull: Haalt alle databestanden en modelbestanden op (pull) van remote opslag naar de lokale machine.
7. dvc status: Toont de status van bijgehouden bestanden, inclusief of ze zijn gewijzigd, toegevoegd of verwijderd.
8. dvc log: Toont een lijst van alle versies van een bestand, samen met hun bijbehorende commit-berichten en andere metadata.

ML-experimenten reproduceren met DVC

Een van de belangrijkste voordelen van het gebruik van DVC is de mogelijkheid om machine learning-experimenten te reproduceren. Met DVC kun je de afhankelijkheden tussen je code, data en modellen definiëren en bijhouden, en de dvc repro opdracht gebruiken om eerdere experimenten te reproduceren.

Voorbeeld Workflow:
Hier is een voorbeeldworkflow voor een sklearn iris dataset met behulp van een .yaml-bestand:

1. Initialiseer eerst een nieuw DVC-project door het commando dvc init uit te voeren.
2. Maak een data map aan in je projectmap om de dataset op te slaan, en download de sklearn iris dataset naar deze map.
3. Voeg de databestanden toe aan DVC met het dvc add commando. Bijvoorbeeld: dvc add data/iris.csv.
4. Maak een .yaml bestand aan om de pipeline te definiëren. Bijvoorbeeld iris.yaml. Dit bestand bevat de opdrachten voor voorverwerking, training en evaluatie van het model.
5. Definieer de stappen in het .yaml bestand met behulp van de DVC-opdrachten. Bijvoorbeeld:

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. Voer de pipeline uit met het dvc repro commando. Dit commando voert de stappen uit die in het .yaml-bestand zijn gedefinieerd in de juiste volgorde, waarbij ervoor wordt gezorgd dat alle afhankelijkheden up-to-date zijn. Bijvoorbeeld: dvc repro iris.yaml.

Door je pipeline te definiëren in een .yaml bestand en het dvc repro commando te gebruiken, kun je eenvoudig je experimenten reproduceren, de versies van je data en modellen bijhouden en samenwerken met teamleden aan je machine learning-project.

Hier is een voorbeeldworkflow:

1. Stel de juiste inloggegevens en endpoint-informatie in voor de S3-server:

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


2. Haal de benodigde modelbestanden op van de S3-server naar de lokale machine:

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


3. Kopieer de gedownloade modelbestanden naar de doel-remote server:

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


4. Gebruik de gekopieerde bestanden voor inference op de doel-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)


Deze workflow gaat ervan uit dat je de benodigde inloggegevens en endpoint-informatie voor de S3-server hebt ingesteld, en dat je toegang hebt tot zowel de lokale als de doel-remote servers. Je kunt de workflow aanpassen op basis van je specifieke behoeften en configuratie.

Hoe TrueFoundry integreert met DVC:

TrueFoundry integreert naadloos met DVC Model Registry om je in staat te stellen modellen die in DVC zijn gelogd te deployen naar je Kubernetes Cluster met behulp van TrueFoundry.

📌

Naast het gebruik van DVC voor Modelbeheer en Experimentation tracking, kun je ook TrueFoundry's Experimentation Tracking MLFoundry gebruiken.

Stap 1 - Installatie en instelling:

• Stel DVC in

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

Opmerking: Je moet je s3 cli configureren om dit te laten werken

• Importeer dvc

import dvc

x

• Installeer servicefoundry

pip install -U "servicefoundry"

• Log in op TrueFoundry

sfy login

Stap 2 - Train en log het model:

We trainen ons ML-model en slaan het op als een joblib-bestand
Vervolgens voegen we het model en de evaluatiemetrieken toe met **`dvc add`**
Daarna pushen we ons joblib-bestand naar dvc via **`dvc push`**

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

Stap 3 - Maak een inference-applicatie en afhankelijkheidsbestand aan:

We moeten twee bestanden aanmaken om te deployen op TrueFoundry: een app.py bestand dat onze applicatiecode bevat, en een requirements.txt bestand dat onze afhankelijkheden bevat.

.
├── 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

Stap 4 - Gebruik de Python SDK van TrueFoundry en configureer de deployment

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

Stap 5 - Deploy je Service via TrueFoundry

Voer de volgende opdracht uit en geef je

• Workspace FQN: door die je kunt vinden in het dashboard

python deploy.py --workspace_fqn your_workspace_fqn

En voila!!! In de logs kun je het dashboard van je gedeplyde service vinden. En vervolgens vind je in de rechterbovenhoek het endpoint van je gedeplyde applicatie.

TrueFoundry is een ML Deployment PaaS over Kubernetes om ontwikkelaarsworkflows te versnellen, terwijl ze volledige flexibiliteit behouden bij het testen en deployen van modellen met gegarandeerde veiligheid en controle voor het Infra-team. Via ons platform stellen we Machine Learning-teams in staat om modellen in 15 minuten te deployen en te monitoren met 100% betrouwbaarheid, schaalbaarheid en de mogelijkheid om binnen seconden terug te draaien - waardoor ze kosten besparen en Modellen sneller naar productie brengen voor het realiseren van echte bedrijfswaarde.