Inférence Ultralytics pour Rust
Ultralytics Inference est une bibliothèque d’inférence YOLO hautes performances et un outil en ligne de commande écrits en Rust. Il exécute des modèles ONNX exportés via ONNX Runtime pour produire rapidement des prédictions sécurisées en 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 distribué sous la forme d’une crate unique, ultralytics-inference, que tu peux utiliser de deux façons : comme CLI pour des prédictions rapides et des traitements par lots, ou comme bibliothèque intégrée directement à ton application Rust. Elle prend en charge toutes les tâches Ultralytics et un large éventail de backends matériels via une interface de périphérique uniforme. Pour l’inférence dans le navigateur, le même référentiel publie le package npm @ultralytics/yolo ; consulte son guide de configuration.
Pourquoi l’inférence avec Rust ?#
- Performances natives et faible encombrement. Compile en 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 toute une catégorie d’erreurs d’exécution sans ramasse-miettes.
- Toutes les tâches YOLO. Détection, segmentation, segmentation sémantique, estimation de profondeur, classification, pose et OBB avec une seule API, ainsi que l’OCR de texte dans les scènes et l’inférence par tuiles pour les grandes images.
- Large compatibilité matérielle. CPU et fournisseurs d’exécution CUDA, TensorRT, CoreML, OpenVINO, DirectML, ROCm, MIGraphX et XNNPACK sélectionnés à la compilation, ainsi que modèles IR OpenVINO natifs.
- Prétraitement sur GPU. Un noyau CUDA fusionné facultatif exécute le letterboxing, la normalisation et la conversion de disposition sur le GPU, puis transmet le résultat au modèle sans quitter le périphérique.
- Téléchargement automatique. Les noms de modèles YOLO connus, les modèles OCR et les ressources d’exemple sont téléchargés automatiquement lors de la première utilisation.
- Même sortie qu’avec Python. Les masques, les contours des masques et les résultats dessinés suivent le package Python Ultralytics, de sorte que
--saveproduit la même image queplot().
Cette page présente la crate Rust autonome. Pour le workflow Python (entraînement, validation, exportation et prédiction), consulte le guide de démarrage rapide principal et le mode Predict. Exporte n’importe quel modèle Ultralytics au format ONNX avec l’intégration ONNX, puis exécute-le ici.
Installation#
Rust 1.92 ou une version ultérieure est nécessaire. La fonctionnalité vidéo nécessite également l’installation de FFmpeg 6 à 9 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,tensorrtLe binaire se trouve à l’emplacement ~/.cargo/bin/ultralytics-inference (Linux et macOS) ou %USERPROFILE%\.cargo\bin\ sous Windows.
Démarrage rapide de la CLI#
La CLI expose une sous-commande predict. Sans 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
# 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 --quantize 16
# Tile a large aerial image into overlapping 640 px windows to find small objects
ultralytics-inference predict --model yolo26n-obb.onnx --source aerial.jpg --tile 640
# Read scene text (auto-downloads yolo26n-text.onnx and the PaddleOCR models)
ultralytics-inference predict --ocr --source sign.jpg
# Thicker lines, no confidences in labels
ultralytics-inference predict --source image.jpg --line-width 4 --show-conf falseTous les indicateurs predict :
| Option | Valeur par défaut | Description |
|---|---|---|
--model, -m | yolo26n.onnx | Chemin vers un modèle ONNX ou un export OpenVINO ; un nom YOLO connu est téléchargé automatiquement. |
--task | detect | L’une des valeurs detect, segment, semantic, depth, classify, pose, obb ; sélectionne le modèle nano si --model est omis. |
--source, -s | exemple | Image, répertoire, motif glob, vidéo, index de webcam, flux ou URL. |
--conf | 0.25 | Seuil de confiance. |
--iou | 0.5 | Seuil IoU pour la suppression non maximale. |
--max-det | 300 | Nombre maximal de détections par image. |
--imgsz | métadonnées du modèle | Taille de l'image pour l'inférence. |
--rect [<BOOL>] | true | Inférence rectangulaire avec un remplissage minimal. |
--tile [<TILE>] | désactivé | Taille des tuiles pour l’inférence par fenêtres chevauchantes ; --tile sans valeur utilise --imgsz. Voir l’inférence par tuiles. |
--retina-masks | false | Construire les masques de segmentation à la taille de l’image d’origine plutôt qu’à la taille d’inférence. |
--ocr | false | Lire le texte dans chaque boîte, boîte orientée ou masque avec PaddleOCR ; sans --model, cette option exécute yolo26n-text.onnx. Voir l’OCR. |
--batch | 1 | Taille du lot pour l'inférence. |
--quantize | précision du modèle | Précision d’inférence : 8, 16, 32, int8, fp16, fp32, w8a8, w16a16, w32a32, w8a16 ou w8a32. |
--save [<BOOL>] | true | Enregistrer les résultats annotés dans runs/<task>/predict. |
--save-frames | false | Enregistrer des images individuelles pour une entrée vidéo plutôt qu'un fichier vidéo. |
--save-json | false | Enregistrer les cartes de classes de segmentation sémantique au format PNG. |
--show | false | Afficher les résultats dans une fenêtre. |
--show-labels [<BOOL>] | true | Afficher les noms des classes dans les étiquettes des boîtes. |
--show-conf [<BOOL>] | true | Afficher les scores de confiance dans les étiquettes des boîtes. |
--show-boxes [<BOOL>] | true | Dessiner les boîtes et leurs étiquettes. |
--line-width | à partir de la taille de l’image | Épaisseur du trait des boîtes en pixels, qui détermine aussi la taille des étiquettes. |
--device | auto | Périphérique d’exécution, par exemple cpu, cuda:0, tensorrt:0, coreml, intel:gpu, directml:0, rocm:0, migraphx:0, xnnpack. |
--verbose [<BOOL>] | true | Afficher les résultats et les temps d'exécution pour chaque image. |
--classes | tous | Filtrer les détections par ID de classe, par exemple 0, "0,1,2" ou "[0, 1, 2]". |
[<BOOL>] indique un indicateur dont la valeur est facultative : utilisé sans valeur (--rect), il prend la valeur true, et --rect false le désactive. L’ancien indicateur --half est toujours accepté, correspond à --quantize 16 et affiche le même avertissement de dépréciation que le package Python.
Démarrage rapide de la bibliothèque#
Charge un modèle et lance une prédiction. Les métadonnées du modèle, comme les noms des classes, le type de tâche et la taille de l'image, sont lues automatiquement dans 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 à l'aide d'une API à chaînage de méthodes :
use ultralytics_inference::{Device, InferenceConfig, Quantization, YOLOModel};
let config = InferenceConfig::new()
.with_confidence(0.5)
.with_iou(0.45)
.with_imgsz(640, 640)
.with_device(Device::Cuda(0))
.with_quantize(Quantization::Fp16);
let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("image.jpg")?;Chaque tâche renseigne un champ différent de Results. Chaque onglet ci-dessous présente un programme complet et exécutable ; le modèle et les exemples d'entrée sont téléchargés automatiquement lors de la première exécution. Remplace predict_default() par predict("image.jpg") pour exécuter le programme 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. Si --model est omis, le modèle nano correspondant à la tâche sélectionnée est téléchargé automatiquement.
| Tâche | --task | Sortie | Modèle par défaut |
|---|---|---|---|
| Détection | detect | Boîtes englobantes et classes | yolo26n.onnx |
| Segmentation d’instances | segment | Boîtes et masques par instance | yolo26n-seg.onnx |
| Segmentation sémantique | semantic | Carte de classes par pixel | yolo26n-sem.onnx |
| Estimation de profondeur | depth | Carte de profondeur par pixel, en mètres | yolo26n-depth.onnx |
| Classification | classify | Probabilités des classes | yolo26n-cls.onnx |
| Pose | pose | Boîtes et points clés | yolo26n-pose.onnx |
| Boîtes orientées | obb | Boîtes englobantes pivotées | yolo26n-obb.onnx |
--ocr ajoute la lecture du texte dans les scènes à tout modèle de détection, de segmentation ou OBB ; sans --model, il exécute le détecteur de texte yolo26n-text.onnx. Voir l’OCR de texte dans les scènes.
Compatibilité des modèles#
Tout modèle Ultralytics exporté au format ONNX peut être chargé depuis 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 :
| Famille de modèles | Variantes téléchargeables automatiquement |
|---|---|
| YOLO26 | yolo26{n,s,m,l,x}.onnx, -seg, -sem, -depth, -cls, -pose, -obb et -text |
| YOLO11 | yolo11{n,s,m,l,x}.onnx, -seg, -cls, -pose et -obb |
| YOLOv8 | yolov8{n,s,m,l,x}.onnx, -seg, -cls, -pose et -obb |
La segmentation sémantique (-sem), l’estimation de profondeur (-depth) et les détecteurs de texte dans les scènes -text sont réservés à YOLO26. Le reconnaisseur PaddleOCR PP-OCRv6_medium_rec.onnx et le classificateur d’orientation PP-LCNet_x0_25_textline_ori.onnx utilisés par --ocr (Apache-2.0) sont également téléchargés automatiquement. Les modèles de détection RT-DETR fonctionnent aussi, mais ne sont pas téléchargés automatiquement : exporte-en un au format ONNX au préalable. Les exports IR natifs OpenVINO s’exécutent avec la fonctionnalité openvino-native ; consulte les modèles IR OpenVINO.
Sources d'entrée#
L'argument --source (et le type Source dans la bibliothèque) accepte de nombreux types d'entrée, détectés automatiquement à partir de la chaîne :
| Source | Exemple | Remarques |
|---|---|---|
| Image | image.jpg | Fichier unique. |
| Répertoire | images/ | Toutes les images du dossier. |
| Glob | images/*.jpg | Motif de type shell. |
| Vidéo | video.mp4 | Nécessite la fonctionnalité video. |
| Webcam | 0 | Nécessite la fonctionnalité video. |
| Flux | rtsp://... | Nécessite la fonctionnalité video. |
| URL | https://example.com/image.jpg | Téléchargement d'image distante. |
Inférence par tuiles#
Les grandes images contenant de petits objets, comme les photos aériennes ou satellites, peuvent être découpées en fenêtres chevauchantes, puis fusionnées pour obtenir un seul résultat, comme avec l’argument Python tile. Les fenêtres se chevauchent de 20 %, les boîtes sont reprojetées dans l’image source et les doublons sont supprimés par classe. Avec un export à taille de lot dynamique, --batch traite plusieurs fenêtres lors d’un seul appel d’inférence. Toutes les tâches sont prises en charge.
# 640 px windows; a bare --tile uses --imgsz
ultralytics-inference predict --model yolo26n-obb.onnx --source aerial.jpg --tile 640use ultralytics_inference::{InferenceConfig, YOLOModel};
// with_tile(0) uses the inference size
let config = InferenceConfig::new().with_tile(640);
let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("aerial.jpg")?;OCR de texte dans les scènes#
Les détecteurs YOLO26-Text repèrent les mots sous forme de boîtes orientées, et TextRecognizer les lit avec PP-OCRv6 de PaddleOCR, le même reconnaisseur que celui de la solution OCR Python. Les boîtes des modèles de détection et les masques des modèles de segmentation fonctionnent aussi : un masque est lu à partir du rectangle de surface minimale entourant son contour, et conserve le contour sous forme de polygone. Chaque recadrage est tourné à l’endroit ; les textes que le classificateur d’orientation détecte à l’envers sont relus après une rotation de 180°, puis les textes sont renvoyés dans l’ordre de lecture. Le reconnaisseur s’exécute sur le périphérique du détecteur.
# Auto-downloads yolo26n-text.onnx and the PaddleOCR models
ultralytics-inference predict --ocr --source sign.jpg
# Any size of the text detector, on the GPU
ultralytics-inference predict --ocr --model yolo26x-text.onnx --source sign.jpg --device cuda:0L’exemple de la bibliothèque charge l’image avec le crate image ; ajoute-le donc à côté du package avec cargo add image.
use ultralytics_inference::YOLOModel;
use ultralytics_inference::ocr::{DEFAULT_ORIENTATION, DEFAULT_RECOGNIZER, TextRecognizer};
let mut detector = YOLOModel::load("yolo26n-text.onnx")?;
let mut ocr = TextRecognizer::new(&detector, DEFAULT_RECOGNIZER, DEFAULT_ORIENTATION)?;
let image = image::open("sign.jpg")?;
let result = detector.predict_image(&image, "sign.jpg".into())?.remove(0);
for text in ocr.read(&image, &result)? {
println!("{} {:.2} {:?}", text.text, text.confidence, text.polygon);
}predict --ocr dessine chaque texte comme la solution Python, et --line-width, --show-labels et --show-conf s’appliquent aussi à ce texte.
Périphériques et fournisseurs d'exécution#
Les moteurs GPU et accélérateurs sont compilés sous forme de fonctionnalités Cargo et sélectionnés à l'exécution avec --device (CLI) ou Device (bibliothèque). Si aucun périphérique n'est spécifié, les fournisseurs compilés dans le build sont enregistrés selon un ordre de priorité fixe (TensorRT d'abord, puis CUDA, etc.), de sorte qu'un build utilisant uniquement les fonctionnalités par défaut s'exécute sur CPU.
| Chaîne du périphérique | Variante Device | Fonctionnalité de build | Matériel |
|---|---|---|---|
cpu | Device::Cpu | intégré | Tout CPU |
cuda:0 | Device::Cuda(0) | cuda | GPU NVIDIA |
tensorrt:0 | Device::TensorRt(0) | tensorrt | GPU NVIDIA, optimisé |
coreml | Device::CoreMl | coreml | Apple Silicon / macOS |
intel:cpu | Device::IntelCpu | openvino ou openvino-native | CPU Intel |
intel:gpu | Device::IntelGpu | openvino ou openvino-native | GPU Intel |
intel:npu | Device::IntelNpu | openvino ou openvino-native | NPU Intel |
directml:0 | Device::DirectMl(0) | directml | GPU Windows |
rocm:0 | Device::Rocm(0) | rocm | GPU AMD |
migraphx:0 | Device::MiGraphX(0) | migraphx | GPU AMD (Linux x64) |
xnnpack | Device::Xnnpack | xnnpack | CPU optimisé |
# Build the CLI with the providers you need
cargo install ultralytics-inference --features cuda,tensorrtModèles IR OpenVINO#
Avec la fonctionnalité openvino-native, --model accepte aussi un export OpenVINO natif, le fichier .xml ou le dossier issu de yolo export format=openvino, et l’exécute avec le runtime OpenVINO plutôt qu’ONNX Runtime. Toutes les tâches s’exécutent sur intel:cpu, intel:gpu et intel:npu, et la bibliothèque le charge avec YOLOModel::load("yolo26n_openvino_model"). La compilation ne nécessite aucune installation d’OpenVINO ; le runtime est chargé à l’ouverture du premier modèle. Consulte le guide OpenVINO pour la configuration.
yolo export model=yolo26n.pt format=openvino # add quantize=16, quantize=8, dynamic=True, or batch=4
ultralytics-inference predict --model yolo26n_openvino_model --source bus.jpg --device intel:gpuAccé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 optimiser davantage (il inclut cuda, qui exécute aussi le reconnaisseur OCR). Pour obtenir la latence d’inférence la plus faible possible, la fonctionnalité cuda-preprocess déplace le prétraitement sur le GPU.
cuda-preprocess effectue le redimensionnement letterbox, la normalisation et la conversion de disposition HWC vers CHW dans un seul noyau CUDA fusionné, puis transmet le résultat au modèle sous forme de tenseur de périphérique sans copie. L'image brute de 8 bits est toujours transférée vers le GPU, via un tampon intermédiaire épinglé sur les GPU discrets ; le noyau évite le redimensionnement et la normalisation sur CPU, la conversion de disposition ainsi que le transfert séparé du tenseur prétraité, ce qui est particulièrement important 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-preprocessLe chemin rapide est utilisé automatiquement, sans changement de l’API, lorsque toutes les conditions suivantes sont réunies : la fonctionnalité est compilée, le périphérique est CUDA ou TensorRT, ou n’est pas défini, la tâche est la détection, la segmentation, la segmentation sémantique (images uniques uniquement), l’estimation de profondeur, la pose ou OBB, et le modèle utilise une entrée FP32. Cette option est activée par défaut et peut être désactivée pour chaque modèle :
use ultralytics_inference::{Device, InferenceConfig};
let config = InferenceConfig::new()
.with_device(Device::TensorRt(0))
.with_cuda_preprocess(false); // force CPU preprocessingcuda-preprocess nécessite une boîte à outils CUDA correspondante au moment du build et utilise NVRTC à l'exécution pour le noyau de prétraitement fusionné. Consulte le guide d'accélération CUDA et TensorRT pour connaître les exigences de version et les solutions aux problèmes courants.
Fonctionnalités Cargo#
Les fonctionnalités sont activées au moment du build. Les fonctionnalités par défaut couvrent l'annotation et l'affichage en direct.
| Fonctionnalité | Valeur par défaut | Rôle |
|---|---|---|
annotate | oui | Dessiner les boîtes, les masques, les points clés, les étiquettes et les textes OCR ; nécessaire pour --save. |
visualize | oui | Affichage en temps réel dans une fenêtre pour --show. |
video | non | Lire et écrire des fichiers vidéo (nécessite FFmpeg 6 à 9). |
cuda | non | Fournisseur d'exécution CUDA de NVIDIA. |
tensorrt | non | Fournisseur d’exécution NVIDIA TensorRT (inclut cuda). |
cuda-preprocess | non | Prétraitement GPU fusionné (implique cuda et tensorrt ; nécessite le kit de développement CUDA). |
coreml | non | Fournisseur d'exécution CoreML d'Apple. |
openvino | non | Fournisseur d’exécution Intel OpenVINO (Linux et Windows x64). |
openvino-native | non | Modèles IR OpenVINO natifs (.xml) via le runtime OpenVINO. |
rocm | non | Fournisseur d’exécution AMD ROCm (nécessite ta propre compilation d’ONNX Runtime). |
migraphx | non | Fournisseur d’exécution AMD MIGraphX (Linux x64). |
directml | non | Fournisseur d'exécution DirectML de Windows. |
xnnpack | non | Fournisseur d’exécution XNNPACK pour optimiser l’inférence sur CPU. |
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, onednn, nnapi, qnn, acl, tvm, rknpu, cann, webgpu et azure, 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.58", features = ["video"] }Sortie et enregistrement#
Par défaut, les prédictions sont annotées et enregistrées dans un répertoire d'exécution dont le nom s'incrémente automatiquement :
runs/
└── detect/
└── predict/ # then predict2, predict3, ...
└── image.jpg # annotated resultLe sous-dossier correspond à la tâche (runs/segment/, runs/pose/, etc.). Pour les sources vidéo, la sortie annotée est écrite dans un 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/. Pour la tâche depth, la carte de profondeur colorisée est superposée à l'image source, comme dans la sortie plot() de l'API Python d'Ultralytics. L'enregistrement des images et vidéos annotées nécessite la fonctionnalité annotate ; l'exportation des cartes PNG de classes sémantiques ne la nécessite pas. L'entrée et la sortie vidéo nécessitent la fonctionnalité video.
Le dessin suit le Results.plot() Python : l’épaisseur du trait est par défaut de 0,3 % du côté moyen de l’image (au moins 2 px), les étiquettes sont placées au-dessus de chaque boîte ou à l’intérieur s’il n’y a pas assez de place, et les masques d’instance sont fusionnés de la même façon, de sorte que les images enregistrées correspondent à celles de Python. --line-width, --show-labels, --show-conf et --show-boxes fonctionnent comme les arguments Python du même nom. Dans la bibliothèque, transmets-les via AnnotateOptions :
use ultralytics_inference::annotate::{AnnotateOptions, annotate_image_with_options};
let options = AnnotateOptions {
line_width: Some(3),
show_conf: false,
..Default::default()
};
let annotated = annotate_image_with_options(&image, &results[0], &options);Les masques de segmentation sont construits à la taille d’inférence, comme avec Python ; transmets --retina-masks (ou InferenceConfig::with_retina_masks(true)) pour les construire à la taille de l’image d’origine.
FAQ#
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.
Exporte-le 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.
Oui.
--ocrlit le texte dans les scènes à l’aide d’un détecteur YOLO26-Text et de PaddleOCR, comme la solution OCR Python, et fonctionne aussi sur les boîtes ou les masques de tes propres modèles de détection et de segmentation. Voir l’OCR de texte dans les scènes.Utilise l’inférence par tuiles :
--tile 640découpe l’image en fenêtres chevauchantes de 640 px et fusionne les détections pour obtenir un seul résultat.Oui, avec la fonctionnalité
videoactivée et FFmpeg 6 à 9 installé sur le système. Cela prend en charge les fichiers vidéo, les webcams et les flux RTSP/RTMP/HTTP.Les deux sont activées par défaut.
annotatedessine des boîtes, des masques, des points clés et des étiquettes de classe sur l’image, et est nécessaire à--savepour écrire les résultats annotés.visualizeouvre une fenêtre en direct pour--show. Pour une version plus légère, sans interface graphique et qui renvoie uniquement les résultats par programmation, désactive-les aveccargo build --no-default-features(réactive les fonctionnalités individuellement selon tes besoins).Cette page est une présentation générale. La référence complète de l’API, détaillée pour chaque type et couvrant toutes les structures publiques, méthodes et options de configuration, est publiée sur docs.rs et générée directement à partir du code source.
Commentaires
Pose une question, partage tes résultats ou aide quelqu’un d’autre.