YoloDotNet 2.3.0

YoloDotNet v2.3

YoloDotNet is a blazing-fast C# .NET 8 implementation of Yolo and Yolo-World models for real-time object detection in images and videos. Powered by ONNX Runtime, and supercharged with GPU acceleration using CUDA, this app is all about detecting objects at lightning speed!

Supported Versions:

Yolov8 Yolov9 Yolov10 Yolov11 Yolo-World

Supported Tasks:

  ✓   Classification   Categorize an image
  ✓   Object Detection   Detect multiple objects in a single image
  ✓   OBB Detection   OBB (Oriented Bounding Box)
  ✓   Segmentation   Separate detected objects using pixel masks
  ✓   Pose Estimation   Identifying location of specific keypoints in an image

Batteries not included.

What's new in YoloDotNet v2.3?

Hold onto your GPUs, folks! YoloDotNet 2.3 is here, and it's bringing some serious upgrades! Whether you're fine-tuning your models or pushing for peak performance, this update has got you covered. Let's dive in!

Yolo v12 Support – The latest YOLO v12 model is now at your fingertips!

Custom Image Resizing – When creating a dataset for training, preserving small details is crucial. Depending on your dataset, you might get better results by squaring images instead of resizing them proportionally. Now, you can choose between "proportional" resizing (default) to maintain aspect ratio or "stretched" resizing to match the dataset and model input exactly.

SkiaSharp Sampling Options – Fine-tune image resizing like never before! This new option allows you to adjust SkiaSharp´s SamplingOptions, optimizing for either better rendering quality or faster performance. These adjustments can directly impact inference results, influencing detection accuracy and speed. You can tweak it to suit your needs or simply stick with the defaults—your call!
(See ImageResize benchmark tests for more details)

Class Label Filtering – Tired of detecting everything? Now you can filter out unwanted classes and focus only on what matters.
(See Example 1 - Image inference)

Performance Boosts – Pixel normalization just got even faster. Because every millisecond counts.

Dependency Updates –

Updated SkiaSharp to 3.116.1
Updated OnnxRuntime to 1.21.0

So what are you waiting for? Get out there and start detecting like a pro!

Nuget

> dotnet add package YoloDotNet

Install CUDA (optional)

YoloDotNet with GPU-acceleration requires CUDA Toolkit 12.x and cuDNN 9.x.

ONNX runtime's current compatibility with specific versions.

• Install CUDA v12.x
• Install cuDNN v9.x
• Update your system PATH-variable

1. Open File Explorer and navigate to the folder where the cuDNN-dll's are installed. The typical path looks like:
   C:\Program Files\NVIDIA\CUDNN\v9.x\bin\v12.x (where x is your version)

2. Once you are in this specific folder (which contains .dll files), copy the folder path from the address bar at the top of the window.

3. Add the cuDNN-Path to your System Variables:

   • Type env in windows search
   • Click on Edit the system environment variables
   • Click on Environment Variables
   • Under System Variables select the Path-variable and click Edit
   • Click on New and paste in your cuDNN dll-folder path
   • Click Ok a million times to save the changes

4. Super-duper-important! In order for Windows to pick up the changes in your Environment Variables, make sure to close all open programs before you continue with whatever you were doing 😉

Export your Yolo models to ONNX

All models—including your own custom models or any other YOLO model—must be exported to the ONNX format.
Need help? Check out this guide

The ONNX-models included in this repo are from Ultralytics s-series (small). https://docs.ultralytics.com/models.

Verify your model

using YoloDotNet;

// Instantiate a new Yolo object with your ONNX-model
using var yolo = new Yolo(@"path\to\model.onnx");

Console.WriteLine(yolo.OnnxModel.ModelType); // Output modeltype...

Example 1 - Image inference

using YoloDotNet;
using YoloDotNet.Enums;
using YoloDotNet.Models;
using YoloDotNet.Extensions;
using SkiaSharp;

// Instantiate a new Yolo object
using var yolo = new Yolo(new YoloOptions
{
    OnnxModel = @"path\to\model.onnx",          // Your Yolo model in onnx format
    ModelType = ModelType.ObjectDetection,      // Set your model type
    Cuda = false,                               // Use CPU or CUDA for GPU accelerated inference. Default = true
    GpuId = 0,                                  // Select Gpu by id. Default = 0
    PrimeGpu = false,                           // Pre-allocate GPU before first inference. Default = false

    // ImageResize = ImageResize.Proportional   // Proportional = Default, Stretched = Squares the image
    // SamplingOptions =  new SKSamplingOptions(SKFilterMode.Linear, SKMipmapMode.None) // View benchmark-test examples: https://github.com/NickSwardh/YoloDotNet/blob/development/test/YoloDotNet.Benchmarks/ImageExtensionTests/ResizeImageTests.cs
});

// Load image
using var image = SKImage.FromEncodedData(@"path\to\image.jpg");

// Run inference and get the results
var results = yolo.RunObjectDetection(image, confidence: 0.25, iou: 0.7);

// Tip:
// Use the extension method FilterLabels([]) on any result if you only want specific labels.
// Example: Select only the labels you're interested in and exclude the rest.
// var results = yolo.RunObjectDetection(image).FilterLabels(["person", "car", "cat"]);

// Draw results
using var resultImage = image.Draw(results);

// Save to file
resultImage.Save(@"save\as\new_image.jpg", SKEncodedImageFormat.Jpeg, 80);

Example 2 - Inference on a batch of images

using System;
using System.IO;
using SkiaSharp;
using YoloDotNet;
using YoloDotNet.Enums;
using YoloDotNet.Models;
using YoloDotNet.Extensions;
using System.Threading.Tasks;

// Instantiate a new yolo-object
using var yolo = new Yolo(new YoloOptions()
{
    OnnxModel = @"path\to\model.onnx",          // Your Yolo model in onnx format
    ModelType = ModelType.ObjectDetection,      // Set your model type
    Cuda = true,                                // Use CPU or CUDA for GPU accelerated inference. Default = true
    GpuId = 0                                   // Select Gpu by id. Default = 0
    PrimeGpu = true,                            // Pre-allocate GPU before first inference. Default = false

    // ImageResize = ImageResize.Proportional   // Proportional = Default, Stretched = Squares the image
    // SamplingOptions =  new SKSamplingOptions(SKFilterMode.Linear, SKMipmapMode.None) // View benchmark-test examples: https://github.com/NickSwardh/YoloDotNet/blob/development/test/YoloDotNet.Benchmarks/ImageExtensionTests/ResizeImageTests.cs
});

// Collect images
var images = Directory.GetFiles(@"path\to\image\folder");

// Process images using parallelism for faster processing
Parallel.ForEach(images, image =>
{
    // Load image
    using var img = SKImage.FromEncodedData(image);

    // Run inference
    var results = yolo.RunObjectDetection(img, 0.25, 0.5);

    // Draw results
    using var resultImg = img.Draw(results);

    // Save results
    resultImg.Save(Path.Combine(@"path\to\save\folder", Path.GetFileName(image)));

    // Do further processing if needed...

});

Example 3 - Video inference

[!IMPORTANT] Processing video requires FFmpeg and FFProbe

• Download FFMPEG
• Add FFmpeg and ffprobe to the Path-variable in your Environment Variables

using YoloDotNet;
using YoloDotNet.Enums;
using YoloDotNet.Models;

// Instantiate a new Yolo object
using var yolo = new Yolo(new YoloOptions
{
    OnnxModel = @"path\to\model.onnx",      // Your Yolov8 or Yolov10 model in onnx format
    ModelType = ModelType.ObjectDetection,  // Set your model type
    Cuda = false,                           // Use CPU or CUDA for GPU accelerated inference. Default = true
    GpuId = 0                               // Select Gpu by id. Default = 0
    PrimeGpu = false,                       // Pre-allocate GPU before first. Default = false
});

// Set video options
var options = new VideoOptions
{
    VideoFile = @"path\to\video.mp4",
    OutputDir = @"path\to\output\dir",
    //GenerateVideo = true,
    //DrawLabels = true,
    //FPS = 30,
    //Width = 640,  // Resize video...
    //Height = -2,  // -2 automatically calculate dimensions to keep proportions
    //Quality = 28,
    //DrawConfidence = true,
    //KeepAudio = true,
    //KeepFrames = false,
    //DrawSegment = DrawSegment.Default,
    //PoseOptions = MyPoseMarkerConfiguration // Your own pose marker configuration...
};

// Run inference on video
var results = yolo.RunObjectDetection(options, 0.25, 0.7);

// Do further processing with 'results'...

Custom KeyPoint configuration for Pose Estimation

Example on how to configure Keypoints for a Pose Estimation model

// Pass in a KeyPoint options parameter to the Draw() extension method. Ex:
image.Draw(poseEstimationResults, poseOptions);

Access ONNX metadata and labels

The internal ONNX metadata such as input & output parameters, version, author, description, date along with the labels can be accessed via the yolo.OnnxModel property.

Example:

using var yolo = new Yolo(@"path\to\model.onnx");

// ONNX metadata and labels resides inside yolo.OnnxModel
Console.WriteLine(yolo.OnnxModel);

Example:

// Instantiate a new object
using var yolo = new Yolo(@"path\to\model.onnx");

// Display metadata
foreach (var property in yolo.OnnxModel.GetType().GetProperties())
{
    var value = property.GetValue(yolo.OnnxModel);
    Console.WriteLine($"{property.Name,-20}{value!}");

    if (property.Name == nameof(yolo.OnnxModel.CustomMetaData))
        foreach (var data in (Dictionary<string, string>)value!)
            Console.WriteLine($"{"",-20}{data.Key,-20}{data.Value}");
}

// Get ONNX labels
var labels = yolo.OnnxModel.Labels;

Console.WriteLine();
Console.WriteLine($"Labels ({labels.Length}):");
Console.WriteLine(new string('-', 58));

// Display
for (var i = 0; i < labels.Length; i++)
    Console.WriteLine($"index: {i,-8} label: {labels[i].Name,20} color: {labels[i].Color}");

// Output:

// ModelType           ObjectDetection
// InputName           images
// OutputName          output0
// CustomMetaData      System.Collections.Generic.Dictionary`2[System.String,System.String]
//                     date                2023-11-07T13:33:33.565196
//                     description         Ultralytics YOLOv8n model trained on coco.yaml
//                     author              Ultralytics
//                     task                detect
//                     license             AGPL-3.0 https://ultralytics.com/license
//                     version             8.0.202
//                     stride              32
//                     batch               1
//                     imgsz               [640, 640]
//                     names               {0: 'person', 1: 'bicycle', 2: 'car' ... }
// ImageSize           Size [ Width=640, Height=640 ]
// Input               Input { BatchSize = 1, Channels = 3, Width = 640, Height = 640 }
// Output              ObjectDetectionShape { BatchSize = 1, Elements = 84, Channels = 8400 }
// Labels              YoloDotNet.Models.LabelModel[]
//
// Labels (80):
// ---------------------------------------------------------
// index: 0        label: person              color: #5d8aa8
// index: 1        label: bicycle             color: #f0f8ff
// index: 2        label: car                 color: #e32636
// index: 3        label: motorcycle          color: #efdecd
// ...

Donate

https://paypal.me/nickswardh

References & Acknowledgements

https://github.com/ultralytics/ultralytics

https://github.com/sstainba/Yolov8.Net

https://github.com/mentalstack/yolov5-net

Benchmarks

There are some benchmarks included in the project. To run them, you simply need to build the project and run the YoloDotNet.Benchmarks project. The solution must be set to Release mode to run the benchmarks.

There is a if DEBUG section in the benchmark project that will run the benchmarks in Debug mode, but it is not recommended as it will not give accurate results. This is however useful to debug and step through the code. Two examples have been left in place to show how to run the benchmarks in Debug mode, but have been commented out.

Because there is no persistant storage for benchmark results, the results below are in the form of starting point and ending point. If one makes changes to the benchmarks, you would move the ending point to the starting point and run the benchmarks again to see the improvements and those values would be the new ending point.

Benchmark results would be very much based on the hardware used. It is important to try run benchmarks on the same hardware for future comparisons. If different hardware is used, it is important to note the hardware used, as the results would be different, thus the starting point and ending point would need to be updated. Hopefully in future a single hardware configuration can be used for benchmarks, before updating documentation.

Simple Benchmarks

Simple benchmarks were modeled around the test project. The test project uses the same images and models as the benchmarks. The benchmarks are run on the same images and models as the test project. These benchmarks provide a good starting point to identify bottlenecks and areas for improvement.

The hardware these benchmarks used are detailed below, the graphics card used was a NVIDIA GeForce RTX 4070 Ti.

* Summary *

Starting Point, YoloDotNet v2.2

BenchmarkDotNet v0.13.12, Windows 10 (10.0.19045.4529/22H2/2022Update)
Intel Core i7-7700K CPU 4.20GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores
.NET SDK 8.0.302
[Host]     : .NET 8.0.6 (8.0.624.26715), X64 RyuJIT AVX2
DefaultJob : .NET 8.0.6 (8.0.624.26715), X64 RyuJIT AVX2

CLASSIFICATION (Input image size: 1280x844)

OBJECT DETECTION (input image size: 1280x851)

ORIENTED OBJECT DETECTION (OBB) (input image size: 1280x720)

POSE ESTIMATION (input image size: 1280x720)

SEGMENTATION (input image size: 1280x853)

Ending Point, YoloDotNet v2.2

Starting Point, YoloDotNet v2.3

BenchmarkDotNet v0.14.0, Windows 11 (10.0.26100.3476)
Intel Core i7-14700KF, 1 CPU, 28 logical and 20 physical cores
.NET SDK 9.0.103
  [Host]     : .NET 8.0.13 (8.0.1325.6609), X64 RyuJIT AVX2
  DefaultJob : .NET 8.0.13 (8.0.1325.6609), X64 RyuJIT AVX2

CLASSIFICATION (Input image size: 1280x844)

OBJECT DETECTION (input image size: 1280x851)

ORIENTED OBJECT DETECTION (OBB) (input image size: 1280x720)

POSE ESTIMATION (input image size: 1280x720)

SEGMENTATION (input image size: 1280x853)