Começar

Acompanhamento e visualização de experiências YOLO com Weights & Biases

Modelos de deteção de objetos, como Ultralytics YOLO26, tornaram-se essenciais em muitas aplicações de visão por computador. No entanto, o treino, a avaliação e a implementação destes modelos complexos trazem vários desafios. Acompanhar as principais métricas de treino, comparar variantes dos modelos, analisar o comportamento dos modelos e detetar problemas exige instrumentação significativa e gestão de experiências.



Assista: Como usar Ultralytics YOLO26 com Weights and Biases

Este guia apresenta a integração do Ultralytics YOLO26 com Weights & Biases para acompanhar experimentos, salvar artefatos do melhor modelo e visualizar o desempenho do modelo. Ele também inclui instruções para configurar a integração, treinar e visualizar resultados usando os recursos interativos do Weights & Biases.

Já tem checkpoints YOLO registrados no W&B? Importe os projetos correspondentes para o Ultralytics Platform em Settings > Integrations > Weights & Biases.

Weights & Biases#

O Weights & Biases é uma plataforma MLOps desenvolvida para acompanhar, visualizar e gerenciar experimentos de aprendizado de máquina. Ela oferece registro automático de métricas de treinamento para reproduzir experimentos integralmente, uma interface interativa para simplificar a análise de dados e ferramentas eficientes de gerenciamento de modelos para implantação em vários ambientes.

Treino do YOLO26 com Weights & Biases#

Você pode usar o Weights & Biases para tornar o processo de treinamento do YOLO26 mais eficiente e automatizado. A integração permite acompanhar experimentos, comparar modelos e tomar decisões baseadas em dados para aprimorar seus projetos de visão computacional.

Instalação#

Para instalar os pacotes necessários, executa:

Instalação
# Install the required packages for Ultralytics YOLO and Weights & Biases
pip install -U ultralytics wandb

# Enable W&B logging for Ultralytics
yolo settings wandb=True

Para obter instruções detalhadas e boas práticas relacionadas com o processo de instalação, consulta o nosso guia de instalação do YOLO26. Se tiveres dificuldades ao instalar os pacotes necessários para YOLO26, consulta o nosso guia de problemas comuns para encontrar soluções e sugestões.

Configurar o Weights & Biases#

Depois de instalar os pacotes necessários, o próximo passo é configurar o teu ambiente Weights & Biases. Isto inclui criar uma conta no Weights & Biases e obter a chave API necessária para estabelecer uma ligação simples entre o teu ambiente de desenvolvimento e a plataforma W&B.

Começa por inicializar o ambiente Weights & Biases no teu espaço de trabalho. Para isso, executa o seguinte comando e segue as instruções apresentadas.

Configuração inicial do SDK
import wandb

# Inicialize seu ambiente do Weights & Biases (solicita a chave da API ou lê WANDB_API_KEY)
wandb.login()

Acede à página de autorização do Weights & Biases para criar e obter a tua chave API. Usa esta chave quando te for pedido para autenticar o teu ambiente com o W&B.

Utilização: Treino do YOLO26 com Weights & Biases#

Utilização: Treino do YOLO26 com Weights & Biases
from ultralytics import YOLO

# Carregar um modelo YOLO
model = YOLO("yolo26n.pt")

# Treina e ajusta o modelo
model.train(data="coco8.yaml", epochs=5, project="ultralytics", name="yolo26n")

As execuções que a Ultralytics cria representam graficamente as métricas de treinamento em função de epoch. Se você iniciar uma execução com wandb.init() antes do treinamento, a Ultralytics registra os dados nessa execução, com um valor epoch em cada linha, e a mantém aberta para que você continue registrando dados nela e chame wandb.finish() por conta própria. Os argumentos de treinamento são adicionados à configuração dessa execução, e qualquer chave que você ou uma varredura do W&B já tenha definido mantém seu valor.

Argumentos do W&B#

ArgumentoPadrãoDescrição
projectNoneEspecifica o nome do projeto registado localmente e no W&B, agrupando várias execuções. Se não for definido, as execuções do W&B são registadas no projeto Ultralytics.
nameNoneO nome da execução de treino. Determina o nome usado para criar subpastas e o nome usado nos registos do W&B.
saveTrueDetermina se o melhor ponto de controlo deve ser carregado como um artefacto de modelo do W&B.
Ativar ou desativar o Weights & Biases

Se quiseres ativar ou desativar o registo do Weights & Biases no Ultralytics, podes usar o comando yolo settings. Por predefinição, o registo do Weights & Biases está desativado.

# Enable Weights & Biases logging
yolo settings wandb=True

# Disable Weights & Biases logging
yolo settings wandb=False
Modo offline e retomada

Define WANDB_MODE=offline para registrar sem uma ligação à rede e, em seguida, carrega a execução com wandb sync <save_dir>/wandb/offline-run-*. Ao retomar o treino com resume=True, a mesma execução do W&B continua, online ou offline e em qualquer sistema operativo, lendo o ID da execução da pasta de execução mais recente no diretório wandb/ do diretório original de gravação; por isso, mantém esse diretório no lugar.

Compreender os resultados#

Ao executar o trecho de código de utilização acima, podes esperar os seguintes resultados principais:

  • A configuração de uma nova execução com um ID exclusivo, que indica o início do processo de treino.
  • Um resumo conciso da estrutura do modelo, incluindo o número de camadas e parâmetros.
  • Atualizações regulares de métricas importantes, como as perdas de treinamento, precisão, revocação e pontuações mAP, durante cada época de treinamento.
  • No fim do treino, são apresentadas métricas detalhadas, incluindo a velocidade de inferência do modelo e as métricas gerais de exatidão.
  • Ligações para o painel do Weights & Biases, onde podes analisar e visualizar detalhadamente o processo de treino, juntamente com informações sobre as localizações dos ficheiros de registo locais.

Ver o painel do Weights & Biases#

Depois de executares o trecho de código de utilização, podes aceder ao painel do Weights & Biases (W&B) através da ligação fornecida na saída. Este painel oferece uma visão abrangente do processo de treino do teu modelo com YOLO26.

Principais funcionalidades do painel do Weights & Biases#

  • Acompanhamento de métricas em tempo real: Observa métricas como a perda, a exatidão e as pontuações de validação à medida que evoluem durante o treino, obtendo informações imediatas para ajustar o modelo. Vê como as experiências são acompanhadas com o Weights & Biases.

  • Comparação de hiperparâmetros: Cada execução registra seus argumentos de treinamento, como a taxa de aprendizado e o tamanho do lote, para que você possa comparar configurações entre execuções. Para buscas automatizadas com registro no W&B, use o Ray Tune.

  • Análise comparativa: A plataforma permite comparar lado a lado diferentes execuções de treino, o que é essencial para avaliar o impacto das várias configurações do modelo e perceber que alterações melhoram o desempenho.

  • Visualização do progresso do treino: As representações gráficas das principais métricas permitem compreender intuitivamente o desempenho do modelo ao longo das épocas. Vê como o Weights & Biases te ajuda a visualizar os resultados da validação.

  • Monitorização de recursos: Acompanha a utilização da CPU, da GPU e da memória para otimizar a eficiência do processo de treino e identificar possíveis estrangulamentos no teu fluxo de trabalho.

  • Gerenciamento de artefatos do modelo: Acesse e compartilhe o checkpoint do melhor modelo, carregado como um artefato do W&B ao final do treinamento, facilitando a implantação e a colaboração com membros da equipe em projetos complexos.

Com esses recursos, você pode acompanhar, analisar e otimizar o treinamento do seu modelo YOLO26 para tarefas de detecção de objetos.

Resumo#

Este guia abordou a integração do Ultralytics YOLO com o Weights & Biases, que acompanha e visualiza os resultados do treinamento de modelos. Com o W&B, você pode simplificar seu fluxo de trabalho de aprendizado de máquina, tomar decisões baseadas em dados e melhorar o desempenho do seu modelo.

Para mais detalhes, veja a apresentação de Soumik Rakshit sobre essa integração no YOLO VISION 2023.

Perguntas frequentes#

  • Para integrar o Weights & Biases com o Ultralytics YOLO26:

    1. Instale os pacotes necessários:

      pip install -U ultralytics wandb
      yolo settings wandb=True
    2. Inicia sessão na tua conta do Weights & Biases:

      wandb login
    3. Treina o teu modelo YOLO26 com o registo do W&B ativado:

      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      model.train(data="coco8.yaml", epochs=5, project="ultralytics", name="yolo26n")

    Isto vai registar automaticamente as métricas, os hiperparâmetros e os artefactos do modelo no teu projeto W&B.

  • As principais funcionalidades incluem:

    • Acompanhamento de métricas em tempo real durante o treino
    • Comparação de hiperparâmetros entre execuções
    • Análise comparativa de diferentes execuções de treino
    • Visualização do progresso do treino através de gráficos
    • Monitorização de recursos (utilização da CPU, da GPU e da memória)
    • Gestão e partilha de artefactos de modelos

    Estas funcionalidades ajudam a acompanhar experiências, otimizar modelos e colaborar de forma mais eficaz em projetos YOLO26.

  • Depois de executares o teu script de treino com a integração do W&B:

    1. Será fornecida uma ligação para o teu painel W&B na saída da consola.
    2. Clica na ligação ou acede a wandb.ai e inicia sessão na tua conta.
    3. Acede ao teu projeto para veres métricas detalhadas, visualizações e dados sobre o desempenho do modelo.

    O painel fornece informações sobre o processo de treino do teu modelo, permitindo-te analisar e melhorar eficazmente os teus modelos YOLO26.

  • Sim, podes desativar o registo do W&B com o seguinte comando:

    yolo settings wandb=False

    Para voltar a ativar o registo, usa:

    yolo settings wandb=True

    Isto permite-te controlar quando queres usar o registo do W&B sem modificar os teus scripts de treino.

  • O Weights & Biases ajuda a otimizar os modelos YOLO26 ao:

    1. Fornecer visualizações detalhadas das métricas de treino
    2. Permitir comparar facilmente diferentes versões do modelo
    3. Registro dos argumentos de treinamento de cada execução para comparar o ajuste de hiperparâmetros
    4. Permitir a análise colaborativa do desempenho do modelo
    5. Facilitar a partilha de artefactos e resultados do modelo

    Esses recursos ajudam pesquisadores e desenvolvedores a iterar mais rapidamente e a tomar decisões baseadas em dados para aprimorar os modelos YOLO26.

Comentários25

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  1. TJdeWetGitHub

    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=...)

    1. 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.

  2. marcory-hubGitHub
    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!

    1. Glenn JocherUltralytics

      @marcory-hub yes, you can integrate Weights & Biases (W&B) with YOLO11 in Google Colab. Please ensure the latest ultralytics and wandb packages are installed using pip install -U ultralytics wandb. If training metrics are not being logged, ensure your W&B environment is authenticated (wandb.login(key="<API_KEY>")) and that project and name parameters are correctly specified in model.train(). Detailed setup instructions are available in our documentation: https://docs.ultralytics.com/integrations/weights-biases/. Let us know if further assistance is needed!

    2. marcory-hubGitHub

      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.

    3. marcory-hubGitHub

      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.

    4. 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!

  3. Pushtogithub23GitHub

    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'
                )
    1. Glenn JocherUltralytics

      @Pushtogithub23 to log all training metrics and media with Weights & Biases, ensure you have the latest versions of ultralytics and wandb installed. Also, verify that your Weights & Biases account is properly authenticated. For detailed setup instructions, visit the Weights & Biases integration guide.

  4. TJdeWetGitHub

    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!

    1. Glenn JocherUltralytics(editado)

      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: maximize

      This setup ensures you're targeting the maximization of mAP50 on the validation data directly.

      Using val/box_loss with 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: minimize

      Both 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. 😊

    2. TJdeWetGitHub

      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!

    3. Glenn JocherUltralytics(editado)

      Hi there!

      In the Ultralytics W&B integration, validation metrics are logged automatically under names such as metrics/mAP50(B) and metrics/mAP50-95(B) (not val/mAP50; the val/ prefix is used for validation losses like val/box_loss). Use that name in your sweep config:

      metric:
        name: metrics/mAP50(B)
        goal: maximize

      Enable the integration with yolo settings wandb=True; no manual wandb.log() call is needed.

  5. JiyongBooGitHub

    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?

    1. Paula DerrengerUltralytics(editado)

      @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 manual wandb.log() calls. Enable it with yolo 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.

  6. DungHD-1997GitHub

    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)

    1. Glenn JocherUltralytics(editado)

      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:

      1. 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
      2. Clear CUDA Cache: Manually clearing the CUDA cache after each epoch might help release unused memory.

        import torch
        torch.cuda.empty_cache()
      3. 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.

      4. Disable W&B to isolate the cause: Run yolo settings wandb=False and 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.

  7. danielst4GitHub

    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

    1. Paula DerrengerUltralytics(editado)

      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:

      1. Initialize WandB: Before starting your training, make sure to log in to WandB in your script or notebook using:
        import wandb
        wandb.login()
      2. 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]
      3. 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)
      4. 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! 🚀

    2. danielst4GitHub

      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.0007013348811086657 where "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 line program: training_rtdetr.py and in a terminal I used the resulting call wandb 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

    3. 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 lr0 and batch, respectively. If you're using these parameters in your training_rtdetr.py script, ensure they're correctly parsed from the command line arguments. Here's a quick Python snippet using argparse for 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 script

      Make 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: 1280

      If 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! 🚀

  8. J0ELhGitHub

    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 = False or something like that.

    1. Glenn JocherUltralytics(editado)

      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 wandb argument to False when initiating your training command. Here's how you can do it:

      yolo settings wandb=False

      This 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! 🚀