Intégrations d'outils d'apprentissage automatique #2 DVC pour le versionnage de vos données

Le contrôle de version des données (DVC) est un outil puissant permettant de gérer et de versionner de grands ensembles de données et de modèles dans le cadre de projets d'apprentissage automatique.

DVC est un outil open source qui fonctionne avec un large éventail d'options de stockage, notamment le disque local, les systèmes de fichiers réseau, Amazon S3, Google Cloud Storage et bien d'autres. DVC peut être utilisé conjointement avec des frameworks d'apprentissage automatique populaires tels que TensorFlow, PyTorch et scikit-learn.

Outre le suivi des modifications apportées aux données et aux modèles, DVC peut également aider les utilisateurs à gérer les dépendances entre les différents composants d'un projet d'apprentissage automatique, tels que le code, les données et les modèles. En surveillant ces dépendances, DVC facilite la reproduction des expériences d'apprentissage automatique et le partage de projets avec d'autres.

Les défis du contrôle de version dans l'apprentissage automatique

Le contrôle de version dans l'apprentissage automatique est une tâche plus difficile que dans le génie logiciel pour les raisons suivantes :

1. Ensembles de données volumineux et complexes: Dans le domaine de l'apprentissage automatique, les ensembles de données utilisés pour la formation et le test des modèles peuvent être volumineux, ce qui complique leur gestion et leur version. En outre, les données peuvent être déstructurées, ce qui rend difficile le suivi de leur évolution au fil du temps.
2. Composantes multiples: Les projets d'apprentissage automatique impliquent souvent de multiples composants, notamment des données, du code et des modèles, ce qui rend difficile le suivi des modifications apportées à chaque composant et de la manière dont ils interagissent les uns avec les autres.
3. Processus de développement itératif: Dans l'apprentissage automatique, le processus de développement est souvent itératif, les développeurs mettant fréquemment à jour les modèles en fonction de nouvelles données ou améliorant la précision du modèle. La gestion de ces modifications et de ces versions peut être complexe et prendre beaucoup de temps.

DVC résout ces problèmes en fournissant un moyen simple et efficace de contrôler les versions des données et des modèles dans les projets d'apprentissage automatique. DVC vous permet de contrôler les versions non seulement du code, mais également des données et des modèles, et de suivre les relations entre eux. Avec DVC, vous pouvez facilement reproduire les expériences précédentes, collaborer avec les membres de l'équipe et automatiser les flux de travail afin de rationaliser le processus de développement.

Installation et configuration de systèmes de contrôle de version

Pour commencer à utiliser DVC, vous devez l'installer et le configurer sur votre machine locale. Dans cette section, nous vous expliquerons étape par étape comment procéder, notamment comment configurer DVC pour qu'il fonctionne avec différents services de stockage dans le cloud et comment créer un nouveau projet DVC.

1. Installation du DVC : La première étape consiste à installer le DVC sur votre machine locale. Vous pouvez le faire en suivant les instructions d'installation de votre système d'exploitation sur le site Web de DVC.
2. Créer un nouveau projet DVC : Une fois DVC installé, vous pouvez créer un nouveau projet DVC en exécutant la commande suivante dans votre terminal :

entrée DVC


Cela créera un nouveau projet DVC dans votre répertoire actuel.

3. Configurer DVC pour qu'il fonctionne avec le stockage dans le cloud : si vous souhaitez utiliser DVC avec des services de stockage dans le cloud tels qu'Amazon S3 ou Google Cloud Storage, vous devez configurer DVC pour qu'il fonctionne avec ces services. Vous pouvez le faire en ajoutant une nouvelle télécommande à l'aide de la commande suivante :

télécommande DVC add -d <remote-name><storage-url>


Par exemple, si vous souhaitez ajouter une télécommande Amazon S3 nommée « my-s3-remote », vous pouvez exécuter la commande suivante :

télécommande DVC add -d my-s3-remote s3://my-bucket-name


Cela ajoutera à votre projet DVC une nouvelle télécommande configurée pour fonctionner avec Amazon S3.

4. Ajoutez des données à votre projet DVC : une fois que vous avez configuré votre projet DVC et l'avez configuré pour qu'il fonctionne avec le stockage dans le cloud, vous pouvez commencer à y ajouter des données. Vous pouvez le faire en exécutant la commande suivante :

ajouter un dvc <path-to-data-file>


Cela ajoutera le fichier de données à votre projet DVC et créera un fichier DVC correspondant qui suit les modifications apportées aux données.

5. Transférer les modifications au stockage distant : si vous avez configuré votre projet DVC pour qu'il fonctionne avec le stockage distant, vous pouvez transférer les modifications à ce stockage en exécutant la commande suivante :

poussoir DVC


Toutes les modifications que vous avez apportées à vos données ou à vos modèles seront alors transférées vers le stockage distant.

Exécution de commandes DVC pour un contrôle de version amélioré

DVC fournit un certain nombre de commandes utiles pour gérer et gérer les versions de projets de machine learning. Voici une liste des commandes DVC les plus couramment utilisées :

1. entrée DVC: initialise un nouveau projet DVC dans le répertoire actuel.
2. ajouter un dvc <path-to-file>: ajoute un fichier au DVC et crée un fichier DVC correspondant pour suivre les modifications apportées au fichier.
3. Exécuter un DVD: Exécute une commande ou un script avec le suivi DVC activé, de sorte que toutes les entrées et sorties soient suivies par DVC.
4. reproduction sur DVD: Reproduit une commande ou un script suivi par DVD, en veillant à ce que toutes les dépendances soient à jour.
5. poussoir DVC: envoie tous les fichiers de données et de modèles vers un stockage distant, tel qu'AWS S3 ou Google Cloud Storage.
6. sortie DVC: extrait tous les fichiers de données et les fichiers de modèle du stockage distant vers la machine locale.
7. état du DVC: affiche l'état des fichiers suivis, y compris s'ils ont été modifiés, ajoutés ou supprimés.
8. journal DVC: affiche la liste de toutes les versions d'un fichier, ainsi que les messages de validation correspondants et d'autres métadonnées.

Reproduire des expériences ML à l'aide de DVC

L'un des avantages les plus importants de l'utilisation du DVC est sa capacité à reproduire des expériences d'apprentissage automatique. Avec DVC, vous pouvez définir et suivre les dépendances entre votre code, vos données et vos modèles, et utiliser le reproduction sur DVD commande pour reproduire les expériences précédentes.

Exemple de flux de travail :
Bien sûr, voici un exemple de flux de travail pour un ensemble de données sklearn iris utilisant un fichier .yaml :

1. Tout d'abord, initialisez un nouveau projet DVC en exécutant la commande entrée DVC.
2. Créez un données répertoire dans le dossier de votre projet pour stocker l'ensemble de données et télécharger le jeu de données sklearn iris dans ce répertoire.
3. Ajoutez les fichiers de données à DVC à l'aide de la commande dvc add. Par exemple : dvc ajoutez data/iris.csv.
4. Créez un .yaml fichier pour définir le pipeline. Par exemple, iris.yaml. Ce fichier contiendra les commandes pour le prétraitement, la formation et l'évaluation du modèle.
5. Définissez les étapes dans .yaml fichier à l'aide des commandes DVC. Par exemple :

étapes :
prétraitement :
cmd : python preprocess.py data/iris.csv data/preprocessed.csv
deps :
- data/iris.csv
Sorties :
- data/preprocessed.csv

train :
cmd : python train.py data/preprocessed.csv models/model.pkl
deps :
- data/preprocessed.csv
Sorties :
- modèles/model.pkl

évaluer :
cmd : python evaluate.py models/model.pkl data/iris.csv
deps :
- modèles/model.pkl
- data/iris.csv


6. Exécutez le pipeline à l'aide de la commande dvc repro. Cette commande exécutera les étapes définies dans le fichier .yaml dans le bon ordre, en s'assurant que toutes les dépendances sont à jour. Par exemple : repro dvc iris.yaml.

En définissant votre pipeline dans un .yaml fichier et à l'aide du reproduction sur DVD commande, vous pouvez facilement reproduire vos expériences, suivre les versions de vos données et modèles et collaborer avec les membres de l'équipe sur votre projet d'apprentissage automatique.

Voici un exemple de flux de travail :

1. Configurez les informations d'identification et les informations de point de terminaison appropriées pour le serveur S3 :

télécommande DVC add -d s3remote s3://your-s3-bucket-name/path/to/models


2. Extrayez les fichiers de modèle nécessaires du serveur S3 vers la machine locale :

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


3. Copiez les fichiers de modèle téléchargés sur le serveur distant cible :

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


4. Utilisez les fichiers copiés à des fins d'inférence sur le serveur distant cible :

# Chargez le modèle
cornichon d'importation
avec open ('/path/to/models/model.pkl', 'rb') comme f :
modèle = pickle.load (f)

# Faites des prédictions
X_test = [[5,1, 3,5, 1,4, 0,2], [7,3, 6,1, 2,3], [6,0, 3,0, 4,8, 1,8]]
y_pred = modèle.predict (X_test)
imprimer (y_pred)


Ce flux de travail suppose que vous avez configuré les informations d'identification et les informations de point de terminaison nécessaires pour le serveur S3, et que vous avez accès aux serveurs distants locaux et cibles. Vous pouvez modifier le flux de travail en fonction de vos besoins et de votre configuration spécifiques.

Comment TrueFoundry s'intègre à DVC :

TrueFoundry s'intègre parfaitement au registre des modèles DVC pour vous permettre de déployer des modèles connectés à DVC sur votre cluster Kubernetes à l'aide de TrueFoundry.

📌

Outre l'utilisation de DVC pour la gestion des modèles et le suivi des expériences, vous pouvez également utiliser le suivi des expériences MLFoundy de Truefoundry.

Étape 1 - Installation et configuration :

• Configuration DVC

# Installer le support DVC et S3
pip install dvc dvc-s3

# Initialisez Git dans le répertoire local
git init

# Initialisez DVC dans le répertoire local
entrée DVC

# Définissez le stockage à distance DVC comme compartiment
télécommande DVC Ajouter S3 ://<your_bucket_name>

Remarque : Vous devrez configurer votre cli s3 pour que cela fonctionne

• Importer un DVD

importer un DVD

x

• Installez Servicefoundry

pip install -U « servicefoundry »

• Connectez-vous à truefoundry

connexion sfy

Étape 2 - Entraînez et enregistrez le modèle :

Nous allons entraîner notre modèle de machine learning et l'enregistrer sous forme de fichier joblib
Ensuite, nous ajouterons le modèle et les métriques d'évaluation en utilisant **`Ajouter un dvc`**
Ensuite, nous allons envoyer notre fichier joblib vers dvc via **`DVC Push`**

depuis sklearn.datasets, importez load_iris
depuis sklearn.model_selection, importez train_test_split
depuis sklearn.linear_model import LogisticRegression
depuis sklearn.metrics import classification_report
importer joblib
système d'importation

# Chargez et prétraitez les données
X, y = load_iris (AS_FRAME=True, Return_X_Y=True)
X = x.Renommer (colonnes= {
« longueur du sépale (cm) » : « sepal_length »,
« largeur du sépale (cm) » : « sepal_width »,
« longueur du pétale (cm) » : « longueur du pétale »,
« largeur du pétale (cm) » : « largeur_du pétale »,
})

X_train, X_test, y_train, y_test = train_test_split (
X, y, test_size=0,2, état_aléatoire=42, stratifié=y
)

# Initialiser le modèle
clf = LogisticRegression (solveur = « liblinear »)

# Ajuster le modèle
clf.fit (X_train, y_train)

# Evaluer le modèle
pression = clf.predict (X_test)

# Enregistrez le modèle en utilisant joblib et DVC
joblib.dump (clf, « modèle.joblib »)
os.system (« dvc add model.joblib »)

# Enregistrez les métriques d'évaluation
rapport = classification_report (y_test, preds, output_dict=True)
avec open (» classification_report.txt «, « w ») comme f :
f.write (str (rapport))

# Transférez le modèle et les métriques d'évaluation vers le stockage distant
système d'exploitation (« DVC Push »)

Étape 3 - Créez une application d'inférence et un fichier de dépendances :

Nous allons devoir créer deux fichiers à déployer sur truefoundry, un app.py un fichier contenant le code de notre application, et un requirements.txt fichier qui contient nos dépendances.

.
─ app.py
─ deploy.py
・─ requirements.txt


• app.py :

système d'importation
importer joblib
importer des pandas au format pdf
depuis fastapi import FastAPI

# Récupérez le modèle depuis S3 à l'aide de DVC
os.system (« dvc pull model.joblib.dvc »)

# Chargez le modèle
modèle = joblib.load (« model.joblib »)

# Chargez le modèle
app = FastAPI ()

@app .post (« /predict »)
def predict (
sepal_length : flottant, sepal_width : flottant, petal_length : flottant, petal_width : flottant
) :
données = dict (
longueur_sépal=longueur_sépalaise,
largeur_sépal=largeur_sépal,
longueur_pétale=longueur_pétale,
largeur_pétale=largeur_pétale,
)
prédiction = int (model.predict (PD.DataFrame ([données])) [0])
return {« prédiction » : prédiction}

• requirements.txt :

fastapi
pandas
joblib
dvc

Étape 4 - Utilisez le SDK Python de Truefoundry et configurez le déploiement

• deploy.py :

importer argparse
journalisation des importations
depuis servicefoundry import Build, PythonBuild, Service, Resources, Port

# Configurer l'enregistreur
Logging.basicConfig (niveau = Logging.info)

# Configurer l'analyseur d'arguments
analyseur = ArgParse.ArgumentParser ()
parser.add_argument (« --workspace_fqn », obligatoire = vrai, type = str)
arguments = analyseur.parse_args ()

service = Service (
nom = « fastapi »,
image=Construire (
build_spec=PythonBuild (
command="application uvicorn : 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=Ressources (
requête_processeur = 0,25,
limite_processeur = 0,5,
demande_mémoire=200,
limite_mémoire = 400,
demande de stockage_éphémère = 200,
limite_de_stockage_éphémère = 400,
),
)
service.deploy (workspace_fqn=args.workspace_fqn)

Étape 5 - Déployez votre service via Truefoundry

Exécutez la commande suivante et transmettez votre

• FAQ de l'espace de travail : que vous pouvez trouver dans le tableau de bord

python deploy.py --workspace_fqn your_workspace_fan

Et voilà ! ! ! Dans les journaux, vous trouverez le tableau de bord de votre service déployé. Ensuite, dans le coin supérieur droit, vous trouverez le point de terminaison de vos applications déployées.

True Foundry est un PaaS de déploiement de machine learning sur Kubernetes destiné à accélérer les flux de travail des développeurs tout en leur offrant une flexibilité totale dans les tests et le déploiement de modèles, tout en garantissant une sécurité et un contrôle complets à l'équipe Infra. Grâce à notre plateforme, nous permettons aux équipes de machine learning de déployer et surveiller des modèles en 15 minutes avec une fiabilité à 100 %, une évolutivité et la possibilité de revenir en arrière en quelques secondes, ce qui leur permet de réduire les coûts et de mettre les modèles en production plus rapidement, ce qui permet de réaliser une véritable valeur commerciale.