Advanced YOLO26 Experiment Tracking with DVCLive

Experiment tracking in machine learning is critical to model development and evaluation. It involves recording and analyzing various parameters, metrics, and outcomes from numerous training runs. This process is essential for understanding model performance and making data-driven decisions to refine and optimize models.

Integrating DVCLive with Ultralytics YOLO26 automatically logs key experiment details, compares results across runs, and visualizes data for in-depth analysis. This guide shows how to set up and use the integration.

DVCLive#

DVCLive, developed by DVC, is an open-source tool for experiment tracking in machine learning. It works with Git and DVC to automate the logging of experiment data like model parameters and training metrics, and makes it easy to compare and analyze multiple runs with data visualization and analysis tools.

YOLO26 Training with DVCLive#

YOLO26 training sessions can be monitored with DVCLive. DVC also provides tools for visualizing these experiments, including a report that compares metric plots across all tracked experiments.

Installation#

To install the required packages, run:

# Install the required packages for YOLO26 and DVCLive
pip install ultralytics dvclive

For detailed instructions and best practices related to the installation process, be sure to check our YOLO26 Installation guide. While installing the required packages for YOLO26, if you encounter any difficulties, consult our Common Issues guide for solutions and tips.

Configuring DVCLive#

Once you have installed the necessary packages, set up your project environment so DVCLive can record experiments alongside your code.

Begin by initializing a Git repository, as Git plays a crucial role in version control for both your code and DVCLive configurations.

# Initialize a Git repository
git init -q

# Configure Git with your details
git config --local user.email "your-email"
git config --local user.name "Your Name"

# Initialize DVC in your project
dvc init -q

# Commit the DVC setup to your Git repository
git commit -m "DVC init"

In these commands, ensure you replace your-email with the email address associated with your Git account, and "Your Name" with your Git account username.

Usage#

Training YOLO26 Models with DVCLive#

Start by running your YOLO26 training sessions. You can use different model configurations and training parameters to suit your project needs. For instance:

# Example training commands for YOLO26 with varying configurations
yolo train model=yolo26n.pt data=coco8.yaml epochs=5 imgsz=512
yolo train model=yolo26n.pt data=coco8.yaml epochs=5 imgsz=640

Adjust the model, data, epochs, and imgsz parameters according to your specific requirements. For a detailed understanding of the model training process and best practices, refer to our YOLO26 Model Training guide.

Monitoring Experiments with DVCLive#

DVCLive enhances the training process by enabling the tracking and visualization of key metrics. Once DVCLive is installed, its callback is enabled by default. It logs the training arguments, per-epoch losses, validation metrics and learning rates, the training and validation plots, a confusion matrix, and best.pt as a model artifact. Run yolo settings dvc=False to disable the integration. For a comprehensive understanding of the specific performance metrics used during training, be sure to explore our detailed guide on performance metrics.

Analyzing Results#

After your YOLO26 training sessions are complete, you can use DVCLive's visualization tools to analyze the results. Because the integration logs all training metrics, you can evaluate your model's performance across runs.

To start the analysis, you can extract the experiment data using DVC's API and process it with Pandas for easier handling and visualization:

import dvc.api
import pandas as pd

# Define the columns of interest
columns = ["Experiment", "epochs", "imgsz", "model", "metrics.mAP50-95(B)"]

# Retrieve experiment data
df = pd.DataFrame(dvc.api.exp_show(), columns=columns)

# Clean the data
df.dropna(inplace=True)
df.reset_index(drop=True, inplace=True)

# Display the DataFrame
print(df)

The output of the code snippet above provides a clear tabular view of the different experiments conducted with YOLO26 models. Each row represents a different training run, detailing the experiment's name, the number of epochs, image size (imgsz), the specific model used, and the mAP_50-95(B) metric. This metric is crucial for evaluating the model's accuracy, with higher values indicating better performance.

Visualizing Results with Plotly#

For a more interactive and visual analysis of your experiment results, you can use Plotly's parallel coordinates plot. This type of plot is particularly useful for understanding the relationships and trade-offs between different parameters and metrics.

from plotly.express import parallel_coordinates

# Create a parallel coordinates plot
fig = parallel_coordinates(df, columns, color="metrics.mAP50-95(B)")

# Display the plot
fig.show()

The output of the code snippet above generates a plot that will visually represent the relationships between epochs, image size, model type, and their corresponding mAP_50-95(B) scores, enabling you to spot trends and patterns in your experiment data.

Generating Comparative Visualizations with DVC#

DVC provides a useful command to generate comparative plots for your experiments. This can be especially helpful to compare the performance of different models over various training runs.

# Generate DVC comparative plots
dvc plots diff $(dvc exp list --names-only)

After executing this command, DVC generates plots comparing the metrics across different experiments, which are saved as HTML files. Below is an example image illustrating typical plots generated by this process. The image showcases various graphs, including those representing mAP, recall, precision, loss values, and more, providing a visual overview of key performance metrics:

Displaying DVC Plots#

If you are using a Jupyter Notebook and you want to display the generated DVC plots, you can use the IPython display functionality.

from IPython.display import HTML

# Display the DVC plots as HTML
HTML(filename="./dvc_plots/index.html")

This code will render the HTML file containing the DVC plots directly in your Jupyter Notebook, providing an easy and convenient way to analyze the visualized experiment data.

Making Data-Driven Decisions#

Use the insights gained from these visualizations to make informed decisions about model optimizations, hyperparameter tuning, and other modifications to enhance your model's performance.

Iterating on Experiments#

Based on your analysis, iterate on your experiments. Adjust model configurations, training parameters, or even the data inputs, and repeat the training and analysis process. This iterative approach is key to refining your model for the best possible performance.

Summary#

This guide has led you through integrating DVCLive with Ultralytics YOLO26, from setup to experiment monitoring, visualization, and analysis.

For further details on usage, visit DVCLive's official documentation.

FAQ#