Approche minimaliste de DataOps et MLOps avec DVC et CML

Dans cet article, nous examinerons l'importance cruciale de DataOps et MLOps dans le développement logiciel et en IA. Nous présenterons une approche MVP pratique, mettant l'accent sur l'utilisation de DVC (Contrôle de Version de Données) et CML (Apprentissage Automatique Continu), intégrés à Git, pour illustrer efficacement ces concepts.

• Approche Pratique : En utilisant DVC et CML, nous démontrerons une approche pratique de produit minimal viable (MVP) pour DataOps et MLOps.
• Intégration avec Git : En mettant en évidence l'intégration fluide de ces outils avec Git, nous montrerons comment les flux de travail familiers peuvent être améliorés pour la gestion des données et des modèles.
• Implémentation Efficace : Notre objectif est de fournir des directives claires pour implémenter efficacement les pratiques DataOps et MLOps.

‍

Problèmes Courants dans les Projets AI & Data

1. "Quelle Version de Données ?" Perdez-vous constamment la trace de la version de données utilisée pour l'entraînement du modèle ?
2. "Le Nouveau Modèle Est-il Bon ?" Arrêtez de vous demander si votre dernier modèle bat l'ancien ou ce qui a changé entre eux.
3. "Pourquoi Notre Dépôt Est-il Si Lourd ?" Dépôt GitHub surchargé avec des données ?

Compréhension de DataOps et MLOps

DataOps et MLOps sont des pratiques fondamentales pour le développement logiciel moderne, en particulier en IA. Ces approches sont essentielles pour gérer efficacement les cycles de vie des données et des modèles d'apprentissage automatique.

• Scalabilité : Gérer efficacement les données (DataOps) et les modèles d'apprentissage automatique (MLOps) est essentiel pour construire des systèmes d'IA évolutifs et robustes, cruciaux pour les projets de développement logiciel.
• Performance et Fiabilité : La mise en œuvre de ces pratiques garantit des performances système constantes et une fiabilité, ce qui est particulièrement vital pour les start-ups opérant dans des environnements dynamiques et contraints en ressources.
• Éviter les Pièges : De nombreuses équipes de développement ont besoin de versionner correctement les données et les modèles ou adoptent une approche réactive de la gestion système, ce qui entraîne des défis significatifs en matière de reproductibilité et d'augmentation des taux d'erreur, entravant la croissance et l'innovation.

Comprendre et intégrer DataOps et MLOps dans les flux de travail n'est pas seulement bénéfique ; c'est une nécessité stratégique.

L'Approche MVP

L'approche MVP (Produit Minimal Viable) en DataOps et MLOps consiste à s'aligner sur les principes fondamentaux du Manifeste Agile, en mettant l'accent sur la simplicité, l'efficacité et le déploiement.

• Principes Agiles : Mettez l'accent sur la simplicité, l'efficacité et les processus axés sur les personnes, favorisant la flexibilité et la réactivité dans la gestion de projet.
• Réduire la Dépendance aux Systèmes Complexes : Plaidez pour une minimisation de la dépendance aux systèmes SaaS complexes et propriétaires, maintenant ainsi le contrôle et la flexibilité dans votre développement.
• Outils Efficaces : Exploitez des outils comme DVC et CML qui s'intègrent avec les flux de travail Git familiers ; cette approche garantit une adoption fluide et améliore la collaboration et l'efficacité de l'équipe.

Adopter une approche MVP signifie créer des flux de travail en DataOps et MLOps plus agiles, adaptables et efficaces, permettant le développement de solutions robustes et évolutives sans être encombré par des complexités inutiles.

Pratique

Maintenant, nous plongeons dans les aspects pratiques de la mise en place d'un environnement Python et de l'utilisation d'outils essentiels comme DVC, CML et SciKit-Learn. Nous passerons par la configuration d'un dépôt GitHub pour un contrôle de version efficace et démontrerons la construction et l'évaluation d'un modèle en utilisant SciKit-Learn dans un calepin Jupyter.

• Configuration : Configurez un environnement Python et installez DVC, CML et SciKit-Learn.
• Construction de Modèle : Utilisez SciKit-Learn avec un ensemble de données intégré dans un calepin Jupyter pour une démonstration simple d'entraînement et d'évaluation de modèle.
• Processus Simplifié : Configurez GitHub et Git pour exécuter et évaluer votre modèle.

Installez l'Environnement Python

Nous utiliserons Poetry  pour gérer notre environnement Python. Poetry est un outil de gestion de dépendances Python qui vous permet de créer des environnements reproductibles et d'installer facilement des packages.

# Install Poetry
pipx install poetry

# Init Poetry project
poetry init

# Add dependencies
poetry add dvc cml scikit-learn

Chargement des données

Nous utiliserons l'ensemble de données sur leBreast Cancer Data Set de UCI Machine Learning Repository.

Caractéristiques clés :

• Nombre d'Instances : 569
• Nombre d'Attributs : 30 attributs numériques prédictifs, plus la classe.
• Attributs : Mesures telles que le rayon, la texture, le périmètre, la zone, la régularité, la compacité, la concavité, les points concaves, la symétrie et la dimension fractale.
• Distribution des Classes : 212 Malignes, 357 Bénignes.

import sklearn.datasets

# Load dataset
data = sklearn.datasets.load_breast_cancer(as_frame=True)
print(data.data.info())

Mise en Œuvre de Paramètres Externes pour les Ajustements de Données et de ModèlesNous utiliserons des fichiers de configuration externes, comme settings.toml, pour ajuster dynamiquement les paramètres des données et du modèle. Cette approche ajoute de la flexibilité à notre projet et souligne l'importance de la versionnage et du suivi des changements, surtout lors de l'introduction de modifications intentionnelles ou de "bugs" à des fins de démonstration.

Dégradation des Données avec des Paramètres Externes

Parce que l'ensemble de données de démonstration fonctionne bien avec un modèle simple, nous allons dégrader artificiellement les données pour souligner l'importance du suivi des changements et de la versionnage.

• Configuration Externe : Utilisez settings.toml pour définir des paramètres comme num_features=1, qui dicte le nombre de fonctionnalités à utiliser à partir de l'ensemble de données.
• Manipulation des Données : Nous modifions dynamiquement nos données en lisant le paramètre num_features depuis settings.toml. Par exemple, en réduisant l'ensemble de données à une seule fonctionnalité :

python
import toml

settings = toml.load("settings.toml")
data.data = data.data.iloc[:, : settings["num_features"]]
print(data.data.info())

Entraînement du Modèle

We'll use SciKit-Learn to split the data and train a simple model.

python
import sklearn.model_selection

# Split into train and test
X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(
data.data, data.target, test_size=0.3, random_state=42
)

python
import sklearn.linear_model

# Train a simple logistic regression model
model = sklearn.linear_model.LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)

python
# Evaluate the model
predictions = model.predict(X_test)
accuracy = sklearn.metrics.accuracy_score(y_test, predictions)
print(f"Model Accuracy: {accuracy:.2f}")

Model Accuracy: 0.91

python
# View the classification report
report = sklearn.metrics.classification_report(y_test, predictions)
print(report)

# Export the report to a file
with open("report.txt", "w") as f:
f.write(report)

                 precision    recall  f1-score   support
 
              0       0.93      0.83      0.87        63
              1       0.90      0.96      0.93       108
 
       accuracy                           0.91       171
      macro avg       0.92      0.89      0.90       171
   weighted avg       0.91      0.91      0.91       171

python
import seaborn as sns
import matplotlib.pyplot as plt

# Create a confusion matrix
confusion_matrix = sklearn.metrics.confusion_matrix(y_test, predictions)

# Plot the confusion matrix
sns.heatmap(confusion_matrix, annot=True, fmt="d")

# Export the plot to a file
plt.savefig("confusion_matrix.png")

‍

‍

Sauvegarde du modèle et des données

Nous allons sauvegarder le modèle et les données localement pour démontrer les capacités de suivi de DVC.

pythonCopy code

from pathlib import Path

# Sauvegarder les données
Path("data").mkdir(exist_ok=True)
data.data.to_csv("data/data.csv", index=False)
data.target.to_csv("data/target.csv", index=False)


pythonCopy code

import joblib

# Sauvegarder le modèle
Path("model").mkdir(exist_ok=True)
joblib.dump(model, "model/model.joblib")


Mise en œuvre de la versionnage des données et des modèles avec DVC

Jusqu'à présent, nous avons couvert les aspects standards du développement de l'IA et de l'apprentissage automatique. Nous entrons maintenant dans le domaine du versionnage des données et du suivi des modèles. C'est là que la véritable magie du développement efficace de l'IA se manifeste, transformant la gestion et l'évolution de nos projets de machine learning.

• Meilleures opérations : Le versionnage des données et le suivi des modèles sont cruciaux pour la gestion des projets d'IA.
• Versionnage des données : Gérer efficacement les changements de données et maintenir une précision historique pour la cohérence et la reproductibilité des modèles.
• Suivi des modèles : Commencer à suivre les itérations des modèles, identifier les améliorations et assurer un développement progressif.

Rationaliser le flux de travail avec les commandes DVC

Pour intégrer efficacement le contrôle de version des données (DVC) dans votre flux de travail, nous décomposons le processus en étapes distinctes, assurant une approche fluide et compréhensible du versionnage des données et des modèles.

Initialisation de DVC

Commencez par configurer DVC dans votre répertoire de projet. Cette initialisation pose les bases pour le versionnage et le suivi des données.

bashCopy code

dvc init


Configuration du stockage distant

Configurez un stockage distant pour DVC. Ce stockage hébergera vos données et modèles versionnés, assurant leur sécurité et accessibilité.

bashCopy code

dvc remote add -d myremote /tmp/myremote


Versionnage des données avec DVC

Ajoutez les données de votre projet à DVC. Cette étape versionne vos données, vous permettant de suivre les changements et de revenir en arrière si nécessaire.

bashCopy code

dvc add data


Versionnage des modèles avec DVC

De même, ajoutez vos modèles de ML à DVC. Cela garantit que vos modèles sont également versionnés et que les changements sont suivis.

bashCopy code

dvc add model


Validation des modifications avec Git

Après avoir ajouté des données et des modèles à DVC, validez ces changements avec Git. Cette étape lie votre versionnage DVC avec le système de contrôle de version de Git.

bashCopy code

git add data.dvc model.dvc .gitignore
git commit -m "Add data and model"


Pousser vers le stockage distant

Enfin, poussez vos données et modèles versionnés vers le stockage distant configuré. Cela sécurise vos données et les rend accessibles pour la collaboration ou la sauvegarde.

bashCopy code

dvc push


Marquage d'une version

Créez une étiquette dans Git pour la version actuelle de vos données :

bashCopy code

git tag -a v1.0 -m "Version 1.0 of data"


Mise à jour et versionnage des données

• Modifiez vos données : Modifiez votre data.csv si nécessaire.
• Suivre les changements avec DVC : Exécutez de nouveau dvc add pour suivre les modifications :

bashCopy code

dvc add data


• Validez la nouvelle version avec Git : Validez le fichier DVC mis à jour avec Git :

bashCopy code

git add data.dvc
git commit -m "Update data to version 2.0"


• Marquer la nouvelle version : Créez une nouvelle étiquette pour la version mise à jour :

bashCopy code

git tag -a v2.0 -m "Version 2.0 of data"


Basculer entre les versions

• Rétablir une version précédente : Pour revenir à une version précédente de vos données, utilisez Git pour passer à l'étiquette correspondante :

bashCopy code

git checkout v1.0


• Revenir aux données avec DVC : Après avoir récupéré l'étiquette dans Git, utilisez DVC pour revenir aux données :

bashCopy code

dvc checkout


Comprendre le suivi des données avec DVC

DVC offre une approche sophistiquée de la gestion des données en suivant les pointeurs et les hachages des données plutôt que les données elles-mêmes. Cette méthodologie est particulièrement significative dans le contexte de Git, un système non conçu pour gérer efficacement les fichiers volumineux ou les données binaires.

Comment DVC suit les données

• Stockage des pointeurs dans Git : DVC stocke de petits fichiers .dvc dans Git. Ces pointeurs font référence aux fichiers de données réels. Chaque pointeur contient des métadonnées sur le fichier de données, y compris une valeur de hachage identifiant de manière unique la version des données.
• Valeurs de hachage pour l'intégrité des données : DVC génère un hachage unique pour chaque version de fichier de données. Ce hachage assure l'intégrité et la cohérence de la version des données suivies. Toute modification des données entraîne un nouveau hachage, facilitant la détection des modifications.
• Séparation des données et du code : Contrairement à Git, qui suit et stocke chaque version de chaque fichier, DVC conserve les données réelles séparément dans un stockage distant (comme S3, GCS ou un système de fichiers local). Cette séparation des données et du code empêche de gonfler le dépôt Git avec des fichiers de données volumineux.

Importance dans le contexte de Git

• Efficacité avec les données volumineuses : Git rencontre des difficultés avec les fichiers volumineux, entraînant des performances lentes et un gonflement du dépôt. DVC contourne cela en déchargeant le stockage des données. Les développeurs peuvent utiliser Git comme prévu - pour le code source - tandis que DVC gère les données.
• Contrôle de version amélioré : DVC étend les capacités de contrôle de version de Git aux fichiers de données volumineux sans surcharger l'infrastructure de Git. Les équipes peuvent suivre les modifications des données avec la même granularité et simplicité que les modifications du code source.
• Collaboration et reproductibilité : DVC facilite la collaboration en permettant aux membres de l'équipe de partager facilement et de manière fiable des données via un stockage distant. La reproductibilité est améliorée car DVC garantit l'alignement correct des versions des données et du code, ce qui est crucial dans les projets de science des données et d'apprentissage automatique.

Utiliser DVC comme un magasin de fonctionnalités

DVC peut être un magasin de fonctionnalités dans les flux de travail de machine learning. Il offre des avantages tels que le contrôle de version, la reproductibilité et la collaboration, rationalisant la gestion des fonctionnalités à travers plusieurs projets.

Qu'est-ce qu'un magasin de fonctionnalités ?

Un magasin de fonctionnalités est un référentiel centralisé pour stocker et gérer les fonctionnalités - des morceaux de logique réutilisables qui transforment les données brutes en formats adaptés aux modèles de machine learning. Les principaux avantages d'un magasin de fonctionnalités incluent :

• Cohérence : Assure un calcul uniforme des fonctionnalités à travers différents modèles et projets.
• Efficacité : Réduit les calculs redondants en réutilisant les fonctionnalités.
• Collaboration : Facilite le partage et la découverte des fonctionnalités parmi les équipes de science des données.
• Qualité et conformité : Maintient une source unique de vérité pour les fonctionnalités, améliorant la qualité des données et aidant à la conformité aux réglementations de données.

Avantages de DVC dans la gestion des fonctionnalités

• Contrôle de version pour les fonctionnalités : DVC permet le contrôle de version des fonctionnalités, permettant de suivre l'évolution des fonctionnalités.
• Reproductibilité : Assure que chaque entraînement de modèle est traçable à l'ensemble exact des fonctionnalités utilisées.
• Collaboration : Facilite le partage des fonctionnalités entre les équipes, assurant la cohérence et réduisant la redondance.

Configuration de DVC en tant que magasin de fonctionnalités

• Organisation des données de fonctionnalités : Stockez les données de fonctionnalités dans des répertoires structurés dans votre dépôt de projet.
• Suivi des fonctionnalités avec DVC : Utilisez DVC pour ajouter et suivre les fichiers de fonctionnalités (par exemple, dvc add data/features.csv).
• Validation des changements de fonctionnalités : Validez les modifications avec Git aux côtés des fichiers .dvc pour maintenir l'historique de l'évolution des fonctionnalités.

Utilisation de DVC pour les mises à jour et les retours en arrière des fonctionnalités

• Mise à jour des fonctionnalités : Suivez les changements en relançant dvc add sur les fonctionnalités mises à jour.
• Retours en arrière : Utilisez dvc checkout pour revenir à des versions spécifiques des fonctionnalités.

Meilleures pratiques pour utiliser DVC comme un magasin de fonctionnalités

• Mises à jour régulières : Maintenez le magasin de fonctionnalités à jour avec des validations régulières.
• Documentation : Documentez chaque ensemble de fonctionnalités, en détaillant la source, la transformation et l'utilisation.
• Intégration avec les pipelines CI/CD : Automatisez les tests de fonctionnalités et le déploiement des modèles en utilisant des pipelines CI/CD intégrés avec DVC.

Mise en œuvre d'un magasin de fonctionnalités basé sur DVC dans plusieurs projets

• Stockage centralisé des données : Choisissez un stockage partagé accessible par tous les projets et configurez-le comme un stockage distant DVC.
• Versionnage et partage des fonctionnalités : Contrôlez la version des ensembles de données de fonctionnalités dans DVC et poussez-les vers le stockage centralisé. Partagez les fichiers .dvc entre les projets.
• Extraction des fonctionnalités dans différents projets : Clonez les dépôts et extrayez les fichiers de fonctionnalités spécifiques en utilisant DVC, permettant leur intégration dans divers flux de travail.

Meilleures pratiques pour gérer un magasin de fonctionnalités basé sur DVC à travers plusieurs projets

• Documentation : Maintenez une documentation complète pour chaque fonctionnalité.
• Contrôle d'accès : Mettez en place des mécanismes pour réguler l'accès aux fonctionnalités sensibles.
• Stratégie de versionnage : Développez une stratégie claire pour le versionnage des fonctionnalités.
• Automatisation des mises à jour : Utilisez des pipelines CI/CD pour mettre à jour et valider les fonctionnalités.

Rationaliser les flux de travail de ML avec l'intégration de CML

Intégrer le Continuous Machine Learning (CML) est une révolution pour le CI/CD dans le machine learning. Cela automatise les processus critiques et assure un flux de travail plus rationalisé et efficace.

Configuration des flux de travail CML

Créez un workflow GitHub Actions dans votre dépôt GitHub, en vous assurant qu'il est configuré pour s'exécuter à chaque push ou PR.

yamlCopy code

name: model-training
on: [push]
jobs:
 run:
   runs-on: ubuntu-latest
   steps:
     - uses: actions/checkout@v4
     - name: Install Poetry
       run: pipx install poetry
     - name: Set up Python
       uses: actions/setup-python@v4
       with:
         python-version: "3.10"
         cache: "poetry"
     - name: Install dependencies
       run: poetry install --no-root
     - uses: iterative/setup-cml@v2
     - name: Train model
       run: |
         make run
     - name: Create CML report
       env:
         REPO_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |
         echo "```" > report.md
         cat report.txt >> report.md
         echo "```" >> report.md
         echo "![](./confusion_matrix.png)" >> report.md
         cml comment create report.md


Conclusion : Améliorer les opérations logicielles et d'IA

Pour conclure, nous avons exploré le cœur des pratiques DataOps et MLOps, démontrant leur rôle vital dans le développement logiciel moderne, en particulier dans l'IA. En maîtrisant ces pratiques et outils comme DVC et CML, vous apprenez de nouvelles techniques et améliorez votre ensemble de compétences en tant que développeur logiciel.

• Restez agile et évolutif : Adopter DataOps et MLOps est essentiel pour se développer dans le monde rapide de l'IA et maintenir vos projets agiles et évolutifs.
• Exploitez des outils puissants : La maîtrise de DVC et CML vous permet de gérer les données et les modèles de manière efficace, vous rendant plus compétent et polyvalent.
• Apprentissage et application continus : Le voyage ne s'arrête pas ici. Le véritable potentiel est réalisé en appliquant et en affinant continuellement ces pratiques dans vos projets. Cela va au-delà de la simple amélioration des processus ; il s'agit d'améliorer vos flux de travail de développement pour répondre aux demandes évolutives de l'IA et de l'ingénierie logicielle.

‍

‍