Link to this sectionUltralytics Inference pour Rust#

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

Le projet est distribué sous forme de crate unique, ultralytics-inference, que tu peux utiliser de deux manières : comme une CLI pour des prédictions rapides et des travaux 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 éventail de backends matériels via une interface de périphérique uniforme.

Link to this sectionPourquoi choisir l'inférence en Rust ?#

• Vitesse native et faible empreinte. Se compile en binaire natif sans interpréteur, idéal pour les serveurs, les conteneurs et les périphériques edge.
• 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étection, segmentation, pose, OBB, classification et segmentation sémantique à 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.

Link to this sectionInstallation#

Rust 1.89 ou version ultérieure est requis. La fonctionnalité video nécessite également que FFmpeg 7+ soit installé 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

Link to this sectionDémarrage rapide CLI#

La CLI expose une sous-commande predict. Sans aucun argument, elle télécharge un modèle de détection nano et des images d'exemple, exécute l'inférence et enregistre 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

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

Link to this sectionDé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 de l'image, la précision et le périphérique avec une API de construction :

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 remplit un champ différent sur Results. Chaque onglet ci-dessous est 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 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(())
}

Link to this sectionTâ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.

Link to this sectionCompatibilité des modèles#

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

La segmentation sémantique (-sem) est réservée à YOLO26.

Link to this sectionSources 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 :

Link to this sectionPériphériques et fournisseurs d'exécution#

L'inférence s'exécute sur CPU par défaut. Les backends GPU et accélérateurs sont compilés en tant que fonctionnalités Cargo et sélectionnés au moment de 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

Link to this sectionAccé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 disposition HWC vers CHW sous forme d'un unique noyau CUDA fusionné, puis transmet le résultat au modèle sous forme de tenseur périphérique zéro-copie. Cela élimine le coût de prétraitement CPU par image et la copie de l'hôte vers le périphérique, ce qui est crucial 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 detect, segment, pose, OBB ou segmentation sémantique, 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

Link to this sectionFonctionnalité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 pratiques 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.18", features = ["video"] }

Link to this sectionSortie 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 écrite sous forme de fichier vidéo ; passe --save-frames pour écrire des images individuelles à la place. Pour la tâche semantic, --save-json écrit des fichiers PNG de carte de classes par pixel dans un sous-dossier results/. L'enregistrement des images et vidéos annotées nécessite la fonctionnalité annotate ; l'exportation PNG de carte de classes sémantiques ne le nécessite pas. L'entrée et la sortie vidéo nécessitent la fonctionnalité video.

Link to this sectionFAQ#

Link to this sectionAi-je besoin de Python installé ?#

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

Link to this sectionQuels modèles puis-je exécuter ?#

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

Link to this sectionComment obtenir un fichier de modèle ?#

Exporte depuis le package 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.

Link to this sectionLa 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.

Link to this sectionQue 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 écrive les résultats annotés. visualize ouvre une fenêtre en direct pour --show. Pour une version plus légère et headless qui retourne uniquement les résultats par programmation, désactive-les avec cargo build --no-default-features (ajoute les fonctionnalités individuelles au besoin).

Link to this sectionOù se trouve la référence complète de l'API ?#

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