Suivi des expériences et visualisation YOLO avec Weights & Biases
Les modèles de détection d'objets, comme Ultralytics YOLO26, sont devenus essentiels à de nombreuses applications de vision par ordinateur. Toutefois, l'entraînement, l'évaluation et le déploiement de ces modèles complexes posent plusieurs défis. Le suivi des métriques d'entraînement clés, la comparaison des variantes de modèles, l'analyse du comportement des modèles et la détection des problèmes nécessitent une instrumentation et une gestion des expériences importantes.
À regarder : Comment utiliser Ultralytics YOLO26 avec Weights and Biases
Ce guide présente l’intégration d’Ultralytics YOLO26 à Weights & Biases pour le suivi des expériences, les artefacts des meilleurs modèles et la visualisation des performances des modèles. Il explique également comment configurer l’intégration, entraîner un modèle et visualiser les résultats grâce aux fonctionnalités interactives de Weights & Biases.
Tu as déjà enregistré des points de contrôle YOLO dans W&B ? Importe leurs projets dans Ultralytics Platform depuis Settings > Integrations > Weights & Biases.
Weights & Biases#
Weights & Biases est une plateforme MLOps conçue pour suivre, visualiser et gérer des expériences de machine learning. Elle offre l’enregistrement automatique des métriques d’entraînement pour assurer la reproductibilité complète des expériences, une interface interactive qui simplifie l’analyse des données et des outils efficaces de gestion des modèles pour les déployer dans divers environnements.
Entraîner YOLO26 avec Weights & Biases#
Tu peux utiliser Weights & Biases pour rendre ton processus d’entraînement YOLO26 plus efficace et automatisé. L’intégration te permet de suivre les expériences, de comparer les modèles et de prendre des décisions fondées sur les données afin d’améliorer tes projets de vision par ordinateur.
Installation#
Pour installer les paquets requis, exécute :
# Install the required packages for Ultralytics YOLO and Weights & Biases
pip install -U ultralytics wandb
# Enable W&B logging for Ultralytics
yolo settings wandb=TruePour obtenir des instructions détaillées et des bonnes pratiques concernant l’installation, consulte notre guide d’installation de YOLO26. Si tu rencontres des difficultés lors de l’installation des paquets requis pour YOLO26, consulte notre guide des problèmes courants pour trouver des solutions et des conseils.
Configurer Weights & Biases#
Après avoir installé les packages nécessaires, l'étape suivante consiste à configurer ton environnement Weights & Biases. Cela comprend la création d'un compte Weights & Biases et l'obtention de la clé API nécessaire pour établir une connexion fluide entre ton environnement de développement et la plateforme W&B.
Commence par initialiser l'environnement Weights & Biases dans ton espace de travail. Pour cela, exécute la commande suivante et suis les instructions affichées.
import wandb
# Initialise ton environnement Weights & Biases (demande la clé API ou lit WANDB_API_KEY)
wandb.login()Rends-toi sur la page d'autorisation Weights & Biases pour créer et récupérer ta clé API. Utilise cette clé lorsque tu y es invité pour authentifier ton environnement auprès de W&B.
Utilisation : entraîner YOLO26 avec Weights & Biases#
from ultralytics import YOLO
# Charger un modèle YOLO
model = YOLO("yolo26n.pt")
# Entraîner et affiner le modèle
model.train(data="coco8.yaml", epochs=5, project="ultralytics", name="yolo26n")Les exécutions créées par Ultralytics tracent les métriques d'entraînement par rapport à epoch. Si tu démarres une exécution avec wandb.init() avant l'entraînement, Ultralytics consigne les données dans cette exécution, avec une valeur epoch dans chaque ligne, et la laisse ouverte pour que tu puisses continuer à y consigner des données et appeler toi-même wandb.finish(). Les paramètres d'entraînement sont ajoutés à la configuration de cette exécution, et toute clé dont toi ou un sweep W&B avez déjà défini la valeur conserve cette valeur.
Arguments W&B#
| Argument | Valeur par défaut | Description |
|---|---|---|
| project | None | Indique le nom du projet enregistré localement et dans W&B, qui regroupe plusieurs exécutions. Si aucun nom n'est défini, les exécutions W&B sont enregistrées dans le projet Ultralytics. |
| name | None | Nom de l'exécution d'entraînement. Il détermine le nom des sous-dossiers créés et celui utilisé pour la journalisation dans W&B. |
| save | True | Détermine si le meilleur point de contrôle doit être téléversé en tant qu'artefact de modèle W&B. |
Pour activer ou désactiver la journalisation Weights & Biases dans Ultralytics, tu peux utiliser la commande yolo settings. Par défaut, la journalisation Weights & Biases est désactivée.
# Enable Weights & Biases logging
yolo settings wandb=True
# Disable Weights & Biases logging
yolo settings wandb=FalseDéfinis WANDB_MODE=offline pour journaliser sans connexion réseau, puis téléverse l’exécution avec wandb sync <save_dir>/wandb/offline-run-*. Reprendre l’entraînement avec resume=True poursuit la même exécution W&B, en ligne ou hors ligne et sur tous les systèmes d’exploitation, en lisant l’ID de l’exécution dans le dossier d’exécution le plus récent du répertoire de sauvegarde d’origine, dans le répertoire wandb/ ; conserve donc ce répertoire en place.
Comprendre la sortie#
Après avoir exécuté l'extrait de code d'utilisation ci-dessus, tu peux t'attendre aux principaux résultats suivants :
- La configuration d'une nouvelle exécution avec son identifiant unique, qui indique le début du processus d'entraînement.
- Un résumé concis de la structure du modèle, comprenant le nombre de couches et de paramètres.
- Mises à jour régulières des métriques importantes, comme les pertes d’entraînement, la précision, le rappel et les scores mAP, à chaque époque d’entraînement.
- À la fin de l'entraînement, des métriques détaillées, notamment la vitesse d'inférence du modèle et les métriques globales d'exactitude, sont affichées.
- Des liens vers le tableau de bord Weights & Biases pour analyser et visualiser en détail le processus d'entraînement, ainsi que des informations sur l'emplacement des fichiers journaux locaux.
Consulter le tableau de bord Weights & Biases#
Après avoir exécuté l'extrait de code d'utilisation, tu peux accéder au tableau de bord Weights & Biases (W&B) à l'aide du lien fourni dans la sortie. Ce tableau de bord offre une vue d'ensemble du processus d'entraînement de ton modèle avec YOLO26.
Fonctionnalités clés du tableau de bord Weights & Biases#
-
Suivi des métriques en temps réel : observe l'évolution des métriques comme la perte, l'exactitude et les scores de validation pendant l'entraînement pour obtenir immédiatement des informations utiles à l'ajustement du modèle. Découvre comment les expériences sont suivies avec Weights & Biases.
-
Comparaison des hyperparamètres : Chaque exécution enregistre ses arguments d’entraînement, comme le taux d’apprentissage et la taille du lot, ce qui te permet de comparer les configurations entre les exécutions. Pour effectuer une recherche automatisée avec la journalisation W&B, utilise Ray Tune.
-
Analyse comparative : la plateforme permet de comparer côte à côte différentes exécutions d'entraînement, ce qui est essentiel pour évaluer l'effet des configurations de modèles et comprendre quelles modifications améliorent les performances.
-
Visualisation de la progression de l'entraînement : des représentations graphiques des métriques clés permettent de comprendre intuitivement les performances du modèle au fil des époques. Découvre comment Weights & Biases t'aide à visualiser les résultats de validation.
-
Surveillance des ressources : surveille l'utilisation du CPU, du GPU et de la mémoire pour optimiser l'efficacité du processus d'entraînement et repérer les éventuels goulots d'étranglement dans ton flux de travail.
-
Gestion des artefacts de modèle : Accède au meilleur point de contrôle du modèle et partage-le. Il est importé en tant qu’artefact W&B à la fin de l’entraînement, ce qui facilite le déploiement et la collaboration avec les membres de l’équipe sur des projets complexes.
Grâce à ces fonctionnalités, tu peux suivre, analyser et optimiser l’entraînement de ton modèle YOLO26 pour tes tâches de détection d’objets.
Résumé#
Ce guide présentait l’intégration d’Ultralytics YOLO à Weights & Biases, qui permet de suivre et de visualiser les résultats de l’entraînement des modèles. Avec W&B, tu peux simplifier ton flux de travail en machine learning, prendre des décisions fondées sur les données et améliorer les performances de ton modèle.
Pour en savoir plus, découvre la présentation de Soumik Rakshit sur cette intégration, donnée lors de YOLO VISION 2023.
FAQ#
Pour intégrer Weights & Biases à Ultralytics YOLO26 :
-
Installe les paquets requis :
pip install -U ultralytics wandb yolo settings wandb=True -
Connecte-toi à ton compte Weights & Biases :
wandb login -
Entraîne ton modèle YOLO26 en activant la journalisation W&B :
from ultralytics import YOLO model = YOLO("yolo26n.pt") model.train(data="coco8.yaml", epochs=5, project="ultralytics", name="yolo26n")
Les métriques, les hyperparamètres et les artefacts du modèle seront automatiquement enregistrés dans ton projet W&B.
-
Les principales fonctionnalités comprennent :
- Le suivi des métriques en temps réel pendant l'entraînement
- Comparaison des hyperparamètres entre les exécutions
- L'analyse comparative de différentes exécutions d'entraînement
- La visualisation de la progression de l'entraînement sous forme de graphiques
- La surveillance des ressources (utilisation du CPU, du GPU et de la mémoire)
- La gestion et le partage des artefacts de modèle
Ces fonctionnalités facilitent le suivi des expériences, l'optimisation des modèles et la collaboration sur les projets YOLO26.
Après avoir exécuté ton script d'entraînement avec l'intégration W&B :
- Un lien vers ton tableau de bord W&B s'affichera dans la sortie de la console.
- Clique sur le lien ou rends-toi sur wandb.ai et connecte-toi à ton compte.
- Accède à ton projet pour consulter les métriques détaillées, les visualisations et les données sur les performances du modèle.
Le tableau de bord te donne des informations sur le processus d'entraînement de ton modèle, ce qui te permet d'analyser et d'améliorer efficacement tes modèles YOLO26.
Oui, tu peux désactiver la journalisation W&B à l'aide de la commande suivante :
yolo settings wandb=FalsePour réactiver la journalisation, utilise :
yolo settings wandb=TrueCela te permet de choisir quand utiliser la journalisation W&B sans modifier tes scripts d'entraînement.
Weights & Biases aide à optimiser les modèles YOLO26 en :
- Fournissant des visualisations détaillées des métriques d'entraînement
- Permettant de comparer facilement différentes versions du modèle
- Journalisation des arguments d’entraînement de chaque exécution pour comparer le réglage des hyperparamètres
- Permettant l'analyse collaborative des performances des modèles
- Facilitant le partage des artefacts et des résultats des modèles
Ces fonctionnalités aident les chercheurs et les développeurs à itérer plus rapidement et à prendre des décisions fondées sur les données pour améliorer leurs modèles YOLO26.
Commentaires25
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
TJdeWet
Hi there,
I would like to know how (if possible) to log more than just these standard metrics for a yolov8 or v11 model during HP tuning logged with wandb: train/loss, val/loss, metrics/accuracy_top1, metrics_accuracy_top5.
This is what the code looks like:
!pip install -U ultralytics wandb !yolo settings wandb=True import wandb from ultralytics import YOLO wandb.login(key="...")
sweep_config = { 'method': "bayes", 'metric': { 'name': 'val/loss', 'goal': 'minimize', }, 'parameters': { .... } }
sweep_id = ...
def train(): run = wandb.init() model = YOLO('yolo11n-cls.pt')
results = model.train( data='...', batch=wandb.config.batch, lr0=wandb.config.lr0, epochs=..., optimizer=..., momentum=..., patience=..., save_period=..., imgsz=..., cache=False, save=True )wandb.agent(sweep_id, train, count=...)
Glenn JocherUltralytics@TJdeWet for custom metric logging beyond default training metrics in YOLO11 with W&B, you can access the complete results dictionary during training and log additional metrics manually through W&B's API. The automatically logged metrics vary by task type (detection/classification), but you can extend them using a callback. For implementation details, refer to the Weights & Biases integration documentation.
marcory-hub
Integration of Weights & Biases with YOLO11 in Google Colab
Is it currently possible to integrate Weights & Biases (W&B) with Ultralytics YOLO11 in Google Colab? If yes, where can I find the correct and up-to-date information to set this up properly?
My Issue
With YOLOv10, I was able to track all my training metrics in W&B seamlessly. However, when trying to replicate this with YOLO11, only GPU and system-related data are logged to the W&B platform. None of the training metrics or results appear.
Summary of things I've Tried
- Following the YouTube tutorial linked at the top of this page.
- Using the Try on Colab button on W&B's site
WARNING: Did not find branch or tag 'feat/ultralytics', assuming revision or ref. error: subprocess-exited-with-error × git checkout -q feat/ultralytics did not run successfully. │ exit code: 1 ╰─> See above for output. note: This error originates from a subprocess, and is likely not a problem with pip. error: subprocess-exited-with-error × git checkout -q feat/ultralytics did not run successfully. │ exit code: 1 ╰─> See above for output. note: This error originates from a subprocess, and is likely not a problem with pip. Note: The Ultralytcs integration will be soon available as a fully supported feature on Weights & Biases once this pull request is merged.This is because the branch https://github.com/wandb/wandb@feat/ultralytics does not exist. To resolve this, I tried various fixes, including following older tutorials and experimenting with suggestions from forums and community discussions.
I’m particularly keen to switch to YOLO11 because it shows significant improvements in wildlife detection when compared to YOLOv10.
Any guidance, updates, or resources on enabling this integration would be greatly appreciated!
Glenn JocherUltralytics@marcory-hub yes, you can integrate Weights & Biases (W&B) with YOLO11 in Google Colab. Please ensure the latest
ultralyticsandwandbpackages are installed usingpip install -U ultralytics wandb. If training metrics are not being logged, ensure your W&B environment is authenticated (wandb.login(key="<API_KEY>")) and thatprojectandnameparameters are correctly specified inmodel.train(). Detailed setup instructions are available in our documentation: https://docs.ultralytics.com/integrations/weights-biases/. Let us know if further assistance is needed!marcory-hub
Thanks for the suggestions, @glenn-jocker ! I tried starting from scratch with W&B with YOLO11 but unfortunately, only system information showed up in W&B.
On top of that, it seems like my Colab runtime might be banned due to a potential issue with a compromised package. Hopefully, they'll restore access soon for everyone affected.
marcory-hub
Good news! My initial code now works for YOLO11. All metrics are automatically saved to W&B, and training is significantly faster than last week without maxing out Colab's RAM.
I'm not sure why it's significantly faster today, but I suspect the previous slowness prevented training from progressing beyond the warmup epochs, resulting in only system information being sent to W&B.
Glenn JocherUltralytics@marcory-hub glad to hear it's working well now, and thank you for sharing your experience! The faster training could indeed be related to runtime or hardware optimizations in Colab. Feel free to explore additional tips and resources in the YOLO11 W&B integration guide to further enhance your workflow. Let us know if you run into any other issues!
Pushtogithub23
I used this code, but it only logs system logs; no training metrics, media, or validation metrics are being logged as shown in the video. How can I log all the training metrics and media as demonstrated in the video? Can anyone help me with this?
from ultralytics import YOLO from wandb.integration.ultralytics import add_wandb_callback wandb.login() wandb.init(project = 'Hand-Gestures-Detection', name = 'yolov8n_5', job_type='training') model = YOLO("yolov8n.pt") add_wandb_callback(model, enable_model_checkpointing=True) model.train(data="HAND-GESTURE-DETECTION-1/data.yaml", epochs=5, imgsz = 640, project = "Hand-Gestures-Detection", name = 'yolov8n_5' )
Glenn JocherUltralytics@Pushtogithub23 to log all training metrics and media with Weights & Biases, ensure you have the latest versions of
ultralyticsandwandbinstalled. Also, verify that your Weights & Biases account is properly authenticated. For detailed setup instructions, visit the Weights & Biases integration guide.
TJdeWet
Hi!
I am using wandb to do hyperparameter tuning. Is it possible to maximise validation mAP50? This seems to be maximising the training mAP50 if I am not mistaken?
metric: name: mAP50 goal: maximise
Otherwise should I do hyperparameter using something like this instead:
metric: name: val/box_loss goal: minimize
Thanks!
Glenn JocherUltralytics(modifié)Hi there!
For your hyperparameter tuning in Weights & Biases, if you're aiming to maximize validation mAP50 specifically, I recommend adjusting your metric settings accordingly. To focus on validation mAP50, your metric configuration might look something like this:
metric: name: metrics/mAP50(B) goal: maximizeThis setup ensures you're targeting the maximization of mAP50 on the validation data directly.
Using
val/box_losswith the goal to minimize can also be effective, especially if you prefer to focus on reducing the box prediction errors during validation:metric: name: val/box_loss goal: minimizeBoth approaches are valid and can be chosen based on your specific model performance goals. Hope this helps! If you have more questions, feel free to ask. 😊
TJdeWet
Hi Glenn,
Thanks for getting back to me. I just tried it, and it doesn't seem that tuning to maximize val/mAP50 is working - the only metrics I see that are being logged are: cls, box, and dfl loss (both train and val), and metrics/mAP50(B), metrics/mAP50-75(B), metrics/Recall(B), and metrics/Precision(B), which I believe are the training metrics? I would like to log those same metrics for validation, and tune based on val/mAP50. Is there a way I can do this?
Thanks!
Glenn JocherUltralytics(modifié)Hi there!
In the Ultralytics W&B integration, validation metrics are logged automatically under names such as
metrics/mAP50(B)andmetrics/mAP50-95(B)(notval/mAP50; theval/prefix is used for validation losses likeval/box_loss). Use that name in your sweep config:metric: name: metrics/mAP50(B) goal: maximizeEnable the integration with
yolo settings wandb=True; no manualwandb.log()call is needed.
JiyongBoo
Is it possible to train RT-DETR model with wandb? In add_wandb_callback() function, there are nothing about rt-detr. I tried replacing yolov8 with rt-detr in the example code. In the result, I confirmed that runs.summary["Validation-Table"] and runs.summary["Train-Table"] did not appear. How do I solve this problem?
Paula DerrengerUltralytics(modifié)@JiyongBoo hi there! 😊 RT-DETR trains with the same built-in Weights & Biases integration as other Ultralytics models, so you don't need
add_wandb_callback()or manualwandb.log()calls. Enable it withyolo settings wandb=True, then train as usual:from ultralytics import RTDETR model = RTDETR("rtdetr-l.pt") model.train(data="coco8.yaml", epochs=5, project="ultralytics", name="rtdetr-l")See the Weights & Biases integration guide for details.
DungHD-1997
from ultralytics import YOLO from wandb.integration.ultralytics import add_wandb_callback import wandb def train(): wandb.login() project_name = "test_ai" # Step 1: Initialize a Weights & Biases run wandb.init(project=project_name, job_type="training",name="old_data")
# Step 2: Define the YOLOv8 Model and Dataset model_name = "yolov8x" dataset_name = "C://Users//Administrator//project//yolov5_train_data//data//slant_2024.yaml" model = YOLO(f"{model_name}.pt") # Step 3: Add W&B Callback for Ultralytics add_wandb_callback(model, enable_model_checkpointing=True) model_name = "train_01" # Step 4: Train and Fine-Tune the Model model.train(project=project_name,name=model_name, data=dataset_name, epochs=100, imgsz=640, batch = 8) # Step 5: Validate the Model model.val() # Step 6: Perform Inference and Log Results #model(["path/to/image1", "path/to/image2"]) # Step 7: Finalize the W&B Run wandb.finish()if name == "main": train() I used the above code to train custom data, but when using wandb, the GPU memory continuously increases over epochs until an out of memory error appears. program has been stopped. Error message: torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate 20.00 MiB. GPU 0 has a total capacity of 15.88 GiB of which 7.62 MiB is free. Of the allocated memory 14.53 GiB is allocated by PyTorch, and 103.44 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation. See documentation for Memory Management (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)
DungHD-1997
If I don't use wandb, the GPU memory hardly changes over each epoch. Is there something wrong with my code?
Glenn JocherUltralytics(modifié)Hey there! It looks like you're encountering a memory issue related to using Weights & Biases (W&B) with YOLOv8, specifically the GPU running out of memory during training. This can happen for a few reasons, including excessive memory allocation by PyTorch or W&B logging mechanisms. Here are a couple of suggestions that might help:
-
Reduce Batch Size: Lowering the batch size can significantly reduce memory usage. Although this might increase training time, it can help avoid out-of-memory errors.
model.train(batch=4) # Try reducing the batch size -
Clear CUDA Cache: Manually clearing the CUDA cache after each epoch might help release unused memory.
import torch torch.cuda.empty_cache() -
Optimize Model and DataLoader: Ensure that your DataLoader is not the source of the memory leak, and try to optimize your model's memory usage.
-
Disable W&B to isolate the cause: Run
yolo settings wandb=Falseand train again; if the out-of-memory error persists, W&B is not the cause.
Finally, consider profiling your code to identify specific lines or operations that cause the memory spike. PyTorch and W&B offer tools and documentation on best practices to optimize memory usage. 📘
Hope this helps! If the issue persists, feel free to reach out with more details or check the W&B and YOLOv8 docs for more insights.
-
danielst4
Hey there, I am trying to make a sweep using WandB but cant quite put together where to insert what into the YOLO call, to use different hyperparameters and track them. Even though I found a site where one has done this he too doesnt describe what he had to do. I am not sure if it is more complicated than I think and if I really have to insert stuff into the training function or if there is an easy way to achieve this. I would be really greatful for help to know what exactly is necessary to make a WandB hyperparameter sweep with YOLO Thanks Daniel
Paula DerrengerUltralytics(modifié)Hey Daniel 👋,
Great to hear you're exploring hyperparameter sweeps with WandB and YOLO! It's simpler than it might seem at first. Here's a quick guide to get you started:
- Initialize WandB: Before starting your training, make sure to log in to WandB in your script or notebook using:
import wandb wandb.login() - Set Up the Sweep: Define your sweep configuration in WandB, using Ultralytics training argument names for the hyperparameters. For example:
method: random metric: name: val/box_loss goal: minimize parameters: lr0: min: 0.0001 max: 0.001 batch: values: [16, 32, 64] - Integrate Sweep with YOLO: Enable the built-in integration with
yolo settings wandb=True. If a W&B run is already active (as in a sweep agent), Ultralytics logs into it and keeps any config values the sweep already set.import wandb from ultralytics import YOLO def train(): wandb.init(project="your_project_name") model = YOLO("yolov8n.pt") model.train(data="coco128.yaml", epochs=5, imgsz=640, lr0=wandb.config.lr0, batch=wandb.config.batch) - Start the Sweep: Once everything is set up, you can start the sweep in WandB. This will iterate over the defined hyperparameter space, automatically logging each experiment's results.
Remember, the key parts are enabling the W&B setting and making sure your sweep parameter names match Ultralytics training arguments.
Hope this helps! If you have any more questions or run into issues, feel free to ask. Happy sweeping! 🚀
- Initialize WandB: Before starting your training, make sure to log in to WandB in your script or notebook using:
danielst4
Thank you Paula, this helped a lot! I can make a sweep now but I noticed that the values of the parameters which are given from the sweep to the script dont match the parameters used. Even though the command looks like this:
wandb.wandb_agent - INFO - About to run command: /usr/bin/env python training_rtdetr.py --batch=8 --epochs=6 --imgsz=1280 --learning_rate=0.0007013348811086657where "training_rtdetr.py" is a script with the code you gave me. (I am working with the RTDETR but it shouldnt make a difference as the metrics and calls are the same if I understand correctly?) But then after engine/trainer it says its using epochs=100 and it also uses that number for training. So just to be sure about a few things, I already logged in to WandB, I wrote a script with the code from your 3., I went to wandb, created a sweep there with the code from 2. + the lineprogram: training_rtdetr.pyand in a terminal I used the resulting callwandb agent [sweepid]Also I am kinda confused because you used "learning_rate" and "batch_size" but as far as I can tell these are not the parameters I can give for the training and they should be called "lr0" and "batch" respectively (which I both tried but they didnt work) I hope I provided all the necessary information otherwise just tell me what you need to know
Paula DerrengerUltralytics@danielst4 hey Daniel,
It sounds like you're on the right track with setting up your WandB sweep with YOLOv8! Regarding the mismatch in parameter values, it seems like there might be a discrepancy between the parameter names expected by your script and those defined in your WandB sweep configuration.
For YOLOv8, the correct parameter names for learning rate and batch size are indeed
lr0andbatch, respectively. If you're using these parameters in yourtraining_rtdetr.pyscript, ensure they're correctly parsed from the command line arguments. Here's a quick Python snippet usingargparsefor reference:import argparse # Parse command line arguments parser = argparse.ArgumentParser() parser.add_argument('--batch', type=int, help='batch size') parser.add_argument('--epochs', type=int, help='number of epochs') parser.add_argument('--imgsz', type=int, help='image size') parser.add_argument('--learning_rate', type=float, help='learning rate') args = parser.parse_args() # Now you can use args.batch, args.epochs, etc., in your scriptMake sure your WandB sweep configuration uses the same parameter names as those your script expects. For example:
program: training_rtdetr.py method: bayes metric: name: val/box_loss goal: minimize parameters: learning_rate: min: 0.0001 max: 0.001 batch: values: [8, 16, 32] epochs: value: 6 imgsz: value: 1280If you've already done this and the issue persists, it might be helpful to double-check how your script handles these parameters and ensure they're being correctly applied to your YOLOv8 model configuration.
Feel free to share more details if you're still encountering issues. We're here to help! 🚀
J0ELh
Is it possible to remove logging and only log progress in the command line? For my training process yolov8 seems to automatically connect with my wandb account and start logging. This process is very time-consuming so I'd like to know whether there's a flag like
log = Falseor something like that.J0ELh
^ this is because I'm done experimenting and need quick retraining options now.
Glenn JocherUltralytics(modifié)Hey there! 👋 If you're looking to disable automatic logging to Weights & Biases (W&B) during your YOLOv8 training to speed things up, you can do so by setting the
wandbargument toFalsewhen initiating your training command. Here's how you can do it:yolo settings wandb=FalseThis is a global Ultralytics setting, not a train argument, and it stops YOLOv8 from connecting to your W&B account and logging training progress there. Happy training! 🚀