Ultralytics Inference pour Rust#

Ultralytics Inference est une bibliothèque d'inférence YOLO haute performance et un outil en ligne de commande écrits en Rust. Elle exécute des modèles ONNX exportés via ONNX Runtime pour fournir des prédictions rapides et sûres pour la mémoire sur des images, des vidéos, des webcams et des flux, sans nécessiter d'environnement d'exécution Python au moment de l'inférence.

Le projet est fourni sous forme d'un crate unique, ultralytics-inference, que tu peux utiliser de deux manières : comme une CLI pour des prédictions rapides et des traitements par lots, ou comme une bibliothèque intégrée directement dans ton application Rust. Il prend en charge toutes les tâches Ultralytics ainsi qu'un large ensemble de backends matériels grâce à une interface de périphérique uniforme.

Pourquoi choisir l'inférence en Rust ?#

• Vitesse native et faible empreinte. Compilé en un binaire natif sans interpréteur, idéal pour les serveurs, les conteneurs et les appareils en périphérie.
• Sécurité mémoire. Le modèle de propriété de Rust élimine des catégories entières d'erreurs d'exécution sans recourir à un ramasse-miettes.
• Toutes les tâches YOLO. Détecte, segmente, réalise une segmentation sémantique, estime la profondeur, classifie, fait de la pose et de l'OBB à partir d'une seule API.
• Large support matériel. CPU ainsi que les fournisseurs d'exécution CUDA, TensorRT, CoreML, OpenVINO, DirectML, ROCm et XNNPACK sélectionnés au moment de la compilation.
• Prétraitement côté GPU. Un noyau CUDA fusionné optionnel maintient le letterbox, la normalisation et la conversion de disposition sur le périphérique pour un chemin d'entrée zéro copie.
• Téléchargement automatique. Les noms de modèles YOLO connus et les ressources d'exemple sont téléchargés automatiquement lors de la première utilisation.

Installation#

Rust 1.89 ou une version ultérieure est requis. La fonctionnalité video nécessite en outre l'installation de FFmpeg 7+ sur le système.

# Install the command-line tool from crates.io
cargo install ultralytics-inference

# Or with GPU support compiled in
cargo install ultralytics-inference --features cuda,tensorrt

Démarrage rapide CLI#

La CLI expose un sous-commande predict. Sans arguments, elle télécharge un modèle de détection nano et des images d'exemple, exécute l'inférence et sauvegarde les résultats annotés dans runs/detect/predict.

# Detect on the built-in samples (downloads model and images)
ultralytics-inference predict

# Detect on your own image
ultralytics-inference predict --model yolo26n.onnx --source image.jpg

# Segmentation (auto-downloads yolo26n-seg.onnx)
ultralytics-inference predict --task segment --source image.jpg

# Pose on a video, shown live in a window
ultralytics-inference predict --task pose --source video.mp4 --show

# Depth estimation (auto-downloads yolo26n-depth.onnx)
ultralytics-inference predict --task depth --source image.jpg

# Tune thresholds and filter to specific classes
ultralytics-inference predict --source image.jpg --conf 0.5 --iou 0.45 --classes "0,1,2"

# Run a whole folder on the GPU in half precision
ultralytics-inference predict --source images/ --device cuda:0 --half

Indicateurs courants :

Démarrage rapide de la bibliothèque#

Charge un modèle et exécute une prédiction. Les métadonnées du modèle telles que les noms de classes, le type de tâche et la taille de l'image sont lues automatiquement depuis le fichier ONNX.

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Metadata (classes, task, imgsz) is parsed from the model.
    let mut model = YOLOModel::load("yolo26n.onnx")?;

    let results = model.predict("image.jpg")?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let conf = boxes.conf()[i];
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("{name} {conf:.2}");
            }
        }
    }

    Ok(())
}

Utilise InferenceConfig pour contrôler les seuils, la taille des images, la précision et le périphérique avec une API de type builder :

use ultralytics_inference::{Device, InferenceConfig, YOLOModel};

let config = InferenceConfig::new()
    .with_confidence(0.5)
    .with_iou(0.45)
    .with_imgsz(640, 640)
    .with_device(Device::Cuda(0))
    .with_half(true);

let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("image.jpg")?;

Chaque tâche alimente un champ différent sur Results. Chaque onglet ci-dessous correspond à un programme complet et exécutable ; le modèle et les entrées d'exemple se téléchargent automatiquement lors de la première exécution. Remplace predict_default() par predict("image.jpg") pour l'exécuter sur tes propres fichiers.

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            println!("{} detections", boxes.len());
            let xyxy = boxes.xyxy(); // rows of [x1, y1, x2, y2]
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2} {:?}", boxes.conf()[i], xyxy.row(i).to_vec());
            }
        }
    }

    Ok(())
}

Tâches prises en charge#

Toutes les tâches Ultralytics sont prises en charge. Lorsque --model est omis, le modèle nano correspondant pour la tâche sélectionnée est téléchargé automatiquement.

Compatibilité des modèles#

N'importe quel modèle Ultralytics exporté vers ONNX peut être chargé à partir d'un fichier local. Le téléchargement automatique est disponible pour les noms de modèles standard YOLO26, YOLO11 et YOLOv8 dans les tailles n, s, m, l et x :

La segmentation sémantique (-sem) et l'estimation de profondeur (-depth) sont exclusives à YOLO26.

Sources d'entrée#

L'argument --source (et le type Source dans la bibliothèque) accepte de nombreux types d'entrées, détectés automatiquement à partir de la chaîne de caractères :

Périphériques et fournisseurs d'exécution#

L'inférence s'exécute sur le CPU par défaut. Les backends GPU et accélérateurs sont compilés en tant que fonctionnalités Cargo et sélectionnés à l'exécution avec --device (CLI) ou Device (bibliothèque).

# Build the CLI with the providers you need
cargo install ultralytics-inference --features cuda,tensorrt

Accélération GPU et prétraitement CUDA#

Sur le matériel NVIDIA, la fonctionnalité cuda active le fournisseur d'exécution CUDA, et tensorrt ajoute le fournisseur TensorRT pour une optimisation supplémentaire. Pour obtenir la latence la plus faible possible, la fonctionnalité cuda-preprocess déplace le prétraitement sur le GPU.

cuda-preprocess exécute le redimensionnement letterbox, la normalisation et la conversion de la disposition HWC vers CHW sous la forme d'un unique noyau CUDA fusionné, puis transmet le résultat au modèle sous forme de tenseur sur l'appareil sans copie. Cela élimine le coût de prétraitement CPU par image et la copie de l'hôte vers l'appareil, ce qui est primordial pour les lots à haut débit et les flux en temps réel.

# Build with fused GPU preprocessing (implies cuda + tensorrt)
cargo build --release --features cuda-preprocess

Le chemin rapide est utilisé automatiquement, sans changement d'API, lorsque toutes les conditions suivantes sont remplies : la fonctionnalité est compilée, le périphérique est CUDA ou TensorRT, la tâche est la détection, la segmentation, la pose, l'OBB, la segmentation sémantique ou l'estimation de profondeur, et le modèle utilise une entrée FP32. Il est activé par défaut et peut être désactivé par modèle :

use ultralytics_inference::{Device, InferenceConfig};

let config = InferenceConfig::new()
    .with_device(Device::TensorRt(0))
    .with_cuda_preprocess(false); // force CPU preprocessing

Fonctionnalités Cargo#

Les fonctionnalités sont activées au moment de la compilation. Les valeurs par défaut couvrent l'annotation et l'affichage en direct.

Les groupes de commodité regroupent les fournisseurs associés : nvidia (cuda, tensorrt), amd (rocm, migraphx), intel (openvino, onednn), mobile (nnapi, coreml, qnn) et all (annotate, visualize, video). D'autres fournisseurs tels que nnapi, qnn, xnnpack, webgpu et d'autres sont également disponibles.

Active les fonctionnalités lors de l'installation de la CLI ou de l'ajout de la bibliothèque :

cargo install ultralytics-inference --features video
cargo install ultralytics-inference --features cuda,tensorrt

[dependencies]
ultralytics-inference = { version = "0.0.33", features = ["video"] }

Sortie et enregistrement#

Par défaut, les prédictions sont annotées et enregistrées dans un répertoire d'exécution à incrémentation automatique :

runs/
└── detect/
    └── predict/          # then predict2, predict3, ...
        └── image.jpg     # annotated result

Le sous-dossier correspond à la tâche (runs/segment/, runs/pose/, etc.). Pour les sources vidéo, la sortie annotée est enregistrée sous forme de fichier vidéo ; passe --save-frames pour enregistrer des trames individuelles à la place. Pour la tâche semantic, --save-json écrit des PNG de cartes de classes par pixel dans un sous-dossier results/. Pour la tâche depth, la carte de profondeur colorisée est superposée sur l'image source, ce qui correspond à la sortie plot() de Python Ultralytics. L'enregistrement d'images et de vidéos annotées nécessite la fonctionnalité annotate, contrairement à l'exportation des cartes de classes sémantiques au format PNG. L'entrée et la sortie vidéo nécessitent la fonctionnalité video.

FAQ#

Ai-je besoin de Python installé ?#

Non. Le crate exécute les modèles ONNX exportés directement via ONNX Runtime. Python n'est nécessaire que si tu entraînes ou exportes des modèles avec le paquet Ultralytics au préalable.

Quels modèles puis-je exécuter ?#

N'importe quel modèle YOLO Ultralytics exporté vers ONNX, y compris YOLO26, YOLO11 et YOLOv8. Les noms de modèles connus se téléchargent automatiquement ; tu peux également pointer --model vers n'importe quel fichier .onnx local.

Comment obtenir un fichier de modèle ?#

Exporte à partir du paquet Python, par exemple avec l'intégration ONNX, ou laisse la CLI télécharger un modèle nano standard pour la tâche choisie lors de la première exécution.

La vidéo est-elle prise en charge ?#

Oui, avec la fonctionnalité video activée et FFmpeg 7+ installé sur le système. Cela couvre les fichiers vidéo, les webcams et les flux RTSP/RTMP/HTTP.

Que font les fonctionnalités annotate et visualize ?#

Les deux sont activées par défaut. annotate dessine des boîtes, des masques, des points clés et des étiquettes de classe sur l'image et est requis pour que --save puisse écrire les résultats annotés. visualize ouvre une fenêtre en direct pour --show. Pour une compilation plus légère et sans tête qui renvoie uniquement les résultats par programmation, désactive-les avec cargo build --no-default-features (réactive les fonctionnalités individuelles selon les besoins).

Où se trouve la référence complète de l'API ?#

Cette page est une vue d'ensemble de haut niveau. La référence d'API complète, type par type, pour chaque structure, méthode et option de configuration publique est publiée sur docs.rs et générée directement à partir du code source.