Suivi d'expériences avec Neptune

Neptune est un magasin de métadonnées pour MLOps, conçu pour les équipes qui mènent beaucoup d'expériences. Il t'offre un emplacement unique pour enregistrer, stocker, afficher, organiser, comparer et interroger toutes les métadonnées de construction de tes modèles.

Ultralytics YOLO26 s'intègre à Neptune pour rationaliser le suivi d'expériences. Cette intégration te permet d'enregistrer automatiquement les métriques d'entraînement, de visualiser les prédictions des modèles et de stocker les artefacts de modèles sans écrire de code de journalisation personnalisé.

Fonctionnalités clés

• Journalisation automatisée : Enregistre automatiquement les métriques d'entraînement clés telles que la perte de boîte (box loss), la perte de classification et le mAP.
• Visualisation d'images : Affiche les mosaïques d'entraînement et les prédictions de validation directement dans le tableau de bord Neptune.
• Points de contrôle de modèles : Télécharge et versionne automatiquement tes poids de modèle entraînés (best.pt) à la fin de l'entraînement.
• Suivi des hyperparamètres : Enregistre tous les paramètres de configuration pour garantir une reproductibilité totale de tes expériences.
• Graphiques interactifs : Visualise les matrices de confusion et les courbes précision-rappel pour analyser les performances du modèle.

Installation

Pour utiliser Neptune avec Ultralytics, tu devras installer le package client neptune ainsi que ultralytics.

# Install the required packages
pip install ultralytics neptune

# Enable Neptune integration in Ultralytics settings
yolo settings neptune=True

Configuration

Avant de commencer l'entraînement, tu dois connecter ton environnement local à ton projet Neptune. Tu auras besoin de ton Jeton API (API Token) et du Nom du projet depuis ton tableau de bord Neptune.

Obtiens tes identifiants

1. Connecte-toi à Neptune.ai.
2. Crée un nouveau projet (ou sélectionne-en un existant).
3. Accède à ton menu utilisateur et récupère ton Jeton API.

Définit les variables d'environnement

La manière la plus sécurisée de gérer les identifiants passe par les variables d'environnement. Note que le rappel (callback) Neptune d'Ultralytics lit l'argument YOLO project et n'utilise pas NEPTUNE_PROJECT. Passe le slug Neptune complet (par exemple workspace/name) via project= dans ta commande d'entraînement ; sinon, Neptune essaiera d'utiliser la valeur par défaut littérale "Ultralytics" et l'exécution échouera.

export NEPTUNE_API_TOKEN="your_long_api_token_here" # required

Utilisation

Une fois configuré, tu peux commencer à entraîner tes modèles YOLO26. L'intégration Neptune fonctionne automatiquement lorsque le package neptune est installé et que l'intégration est activée dans les paramètres.

Exemple d'entraînement

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Train the model
# Pass the Neptune project slug as the 'project' argument (workspace/name)
results = model.train(data="coco8.yaml", epochs=10, project="my-workspace/my-project", name="experiment-1")

Comprendre l'intégration

Le diagramme suivant illustre comment le pipeline d'entraînement Ultralytics interagit avec Neptune pour enregistrer divers artefacts et métriques.

graph LR
    A[YOLO Training Loop] --> B{Neptune Callback}
    B -->|Log Scalars| C[Loss, mAP, LR]
    B -->|Log Images| D[Mosaics, Preds]
    B -->|Log Artifacts| E[Model Weights]
    B -->|Log Metadata| F[Hyperparameters]

    C --> G[Neptune Server]
    D --> G
    E --> G
    F --> G

    G --> H[Neptune Web Dashboard]

Qu'est-ce qui est enregistré ?

Lorsque tu exécutes la commande d'entraînement, l'intégration Neptune capture automatiquement la structure de données suivante dans ton exécution :

1. Configuration/Hyperparamètres : Tous les arguments d'entraînement (époques, lr0, optimiseur, etc.) sont enregistrés sous la section Configuration.
2. Configuration/Modèle : L'architecture et la définition du modèle.
3. Métriques :
   • Entraînement : box_loss, cls_loss, dfl_loss, lr (taux d'apprentissage).
   • Métriques : precision, recall, mAP50, mAP50-95.
4. Images :
   • Mosaic : Lots d'entraînement montrant l'augmentation de données.
   • Validation : Étiquettes de vérité terrain et prédictions du modèle sur les données de validation.
   • Plots : Matrices de confusion, courbes Précision-Rappel.
5. Poids : Le modèle final entraîné (best.pt) est téléchargé dans le dossier weights de l'exécution Neptune.

Utilisation avancée

Organisation des exécutions

Tu peux utiliser les arguments standard project et name d'Ultralytics pour organiser tes exécutions dans Neptune.

• project : Doit être le slug de projet Neptune workspace/name ; c'est ce que le rappel transmet à neptune.init_run.
• name : Sert d'identifiant pour l'exécution spécifique.

Journalisation personnalisée

Si tu dois enregistrer des métriques personnalisées supplémentaires en plus de la journalisation automatique, tu peux accéder à l'instance d'exécution Neptune. Note que tu devras modifier la logique de l'entraîneur ou créer un rappel personnalisé pour accéder à l'objet d'exécution spécifique, car l'intégration Ultralytics gère le cycle de vie de l'exécution en interne.

FAQ

Comment désactiver la journalisation Neptune ?

Si tu as installé neptune mais que tu souhaites désactiver la journalisation pour une session spécifique ou globalement, tu peux modifier les paramètres YOLO.

# Disable Neptune integration
yolo settings neptune=False

Mes images ne sont pas téléchargées. Quel est le problème ?

Assure-toi que ton réseau autorise les connexions aux serveurs de Neptune. De plus, la journalisation des images se produit généralement à des intervalles spécifiques (par exemple, fin des époques ou fin de l'entraînement). Si tu interromps l'entraînement prématurément avec Ctrl+C, certains artefacts finaux comme les matrices de confusion ou les meilleurs poids de modèle pourraient ne pas être téléchargés.

Puis-je enregistrer vers un ID d'exécution Neptune spécifique ?

L'intégration actuelle crée automatiquement une nouvelle exécution pour chaque session d'entraînement. Pour reprendre la journalisation vers une exécution existante, tu devrais généralement gérer l'initialisation Neptune manuellement dans ton code Python, ce qui sort du cadre de l'intégration automatique. Cependant, Ultralytics prend en charge la reprise de l'entraînement localement, ce qui créera une nouvelle exécution dans Neptune pour suivre les époques reprises.

Où puis-je trouver les poids du modèle dans Neptune ?

Dans ton tableau de bord Neptune, navigue vers la section Artifacts ou All Metadata. Tu trouveras un dossier weights contenant ton fichier best.pt, que tu peux télécharger pour le déploiement.