Erste Schritte

Ultralytics Inference für Rust

Ultralytics Inference GitHub Ultralytics Inference Crates.io Ultralytics Inference docs.rs Ultralytics Inference Downloads Ultralytics Inference MSRV

Ultralytics Inference ist eine leistungsstarke Inferenzbibliothek und ein Befehlszeilenwerkzeug für YOLO, geschrieben in Rust. Das Werkzeug führt exportierte ONNX-Modelle über ONNX Runtime aus und ermöglicht so schnelle, speichersichere Vorhersagen für Bilder, Videos, Webcams und Streams, ohne dass zur Inferenzzeit eine Python-Laufzeitumgebung erforderlich ist.

Das Projekt wird als einzelnes Crate namens ultralytics-inference bereitgestellt, das du auf zwei Arten verwenden kannst: als CLI für schnelle Vorhersagen und Stapelverarbeitung oder als Bibliothek, die direkt in deine Rust-Anwendung eingebunden wird. Es unterstützt alle Ultralytics-Aufgaben und eine breite Auswahl an Hardware-Backends über eine einheitliche Geräteschnittstelle. Für Inferenz im Browser veröffentlicht dasselbe Repository das npm-Paket @ultralytics/yolo; die Einrichtungsanleitung findest du hier.

Warum Inferenz mit Rust?#

  • Native Geschwindigkeit und geringer Platzbedarf. Wird ohne Interpreter zu einer nativen Binärdatei kompiliert – ideal für Server, Container und Edge-Geräte.
  • Speichersicherheit. Das Besitzmodell von Rust verhindert ganze Klassen von Laufzeitfehlern, ohne dass eine Garbage Collection erforderlich ist.
  • Alle YOLO-Aufgaben. Erkenne und segmentiere Objekte, führe semantische Segmentierung, Tiefenschätzung, Klassifizierung, Posenschätzung und OBB mit einer einzigen API durch und nutze außerdem OCR für Szenentext sowie gekachelte Inferenz für große Bilder.
  • Breite Hardwareunterstützung. CPU sowie die zur Build-Zeit ausgewählten Ausführungsanbieter CUDA, TensorRT, CoreML, OpenVINO, DirectML, ROCm, MIGraphX und XNNPACK sowie native OpenVINO-IR-Modelle.
  • Vorverarbeitung auf der GPU. Ein optionaler, fusionierter CUDA-Kernel führt Letterbox, Normalisierung und Layoutkonvertierung auf der GPU aus und übergibt das Ergebnis an das Modell, ohne das Gerät zu verlassen.
  • Automatischer Download. Bekannte YOLO-Modellnamen, die OCR-Modelle und Beispielressourcen werden bei der ersten Verwendung automatisch heruntergeladen.
  • Gleiche Ausgabe wie in Python. Masken, Maskenumrisse und gezeichnete Ergebnisse entsprechen dem Ultralytics-Python-Paket, sodass --save dasselbe Bild wie plot() erzeugt.
Suchst du das Python-Paket?

Diese Seite behandelt das eigenständige Rust-Crate. Informationen zum Python-Ablauf (Training, Validierung, Export und Vorhersage) findest du im allgemeinen Schnellstart und im Vorhersagemodus. Exportiere ein beliebiges Ultralytics-Modell mit der ONNX-Integration nach ONNX und führe es anschließend hier aus.

Installation#

Rust 1.92 oder neuer ist erforderlich. Für die Videofunktion muss außerdem FFmpeg 6 bis 9 auf dem System installiert sein.

# 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

Die Binärdatei wird unter ~/.cargo/bin/ultralytics-inference (Linux und macOS) oder unter %USERPROFILE%\.cargo\bin\ auf Windows abgelegt.

CLI-Schnellstart#

Die CLI stellt einen Unterbefehl predict bereit. Ohne Argumente lädt sie ein Nano-Erkennungsmodell und Beispielbilder herunter, führt die Inferenz aus und speichert die annotierten Ergebnisse unter 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 false

Alle predict-Flags:

FlagStandardBeschreibung
--model, -myolo26n.onnxPfad zu einem ONNX-Modell oder einem OpenVINO-Export; ein bekannter YOLO-Name wird automatisch heruntergeladen.
--taskdetectEiner von detect, segment, semantic, depth, classify, pose, obb; wählt das Nano-Modell aus, wenn --model nicht angegeben ist.
--source, -sBeispielBild, Verzeichnis, Glob-Muster, Video, Webcam-Index, Stream oder URL.
--conf0.25Konfidenzschwellenwert.
--iou0.5IoU-Schwellenwert für die nicht-maximale Unterdrückung.
--max-det300Maximale Anzahl an Erkennungen pro Bild.
--imgszModellmetadatenBildgröße für die Inferenz.
--rect [<BOOL>]trueRechteckige Inferenz mit minimalem Padding.
--tile [<TILE>]ausKachelgröße für die Inferenz mit überlappenden Fenstern; bei alleinstehendem --tile wird --imgsz verwendet. Siehe gekachelte Inferenz.
--retina-masksfalseSegmentierungsmasken in der Originalbildgröße statt in der Inferenzgröße erstellen.
--ocrfalseDen Text in jeder Box, orientierten Box oder Maske mit PaddleOCR auslesen; ohne --model wird yolo26n-text.onnx ausgeführt. Siehe OCR.
--batch1Batchgröße für die Inferenz.
--quantizeModellpräzisionInferenzpräzision: 8, 16, 32, int8, fp16, fp32, w8a8, w16a16, w32a32, w8a16 oder w8a32.
--save [<BOOL>]trueAnnotierte Ergebnisse unter runs/<task>/predict speichern.
--save-framesfalseBei Videoeingaben einzelne Frames statt einer Videodatei speichern.
--save-jsonfalsePNG-Dateien mit semantischen Segmentierungsklassenkarten speichern.
--showfalseErgebnisse in einem Fenster anzeigen.
--show-labels [<BOOL>]trueKlassennamen in Boxbeschriftungen anzeigen.
--show-conf [<BOOL>]trueKonfidenzwerte in Boxbeschriftungen anzeigen.
--show-boxes [<BOOL>]trueBoxen und ihre Beschriftungen zeichnen.
--line-widthab BildgrößeLinienbreite der Box in Pixeln; sie bestimmt auch die Größe der Beschriftungen.
--deviceautomatischAusführungsgerät, zum Beispiel cpu, cuda:0, tensorrt:0, coreml, intel:gpu, directml:0, rocm:0, migraphx:0, xnnpack.
--verbose [<BOOL>]trueErgebnisse und Zeitmessungen für jedes Bild ausgeben.
--classesalleErkennungen nach Klassen-IDs filtern, zum Beispiel 0, "0,1,2" oder "[0, 1, 2]".

[<BOOL>] kennzeichnet ein Flag mit optionalem Wert: Wird es ohne Wert angegeben (--rect), wird es auf true gesetzt; --rect false deaktiviert es. Das veraltete Flag --half wird weiterhin akzeptiert, auf --quantize 16 abgebildet und gibt dieselbe Deprecation-Warnung wie das Python-Paket aus.

Schnelleinstieg für die Bibliothek#

Lade ein Modell und führe eine Vorhersage aus. Modellmetadaten wie Klassennamen, Aufgabentyp und Bildgröße werden automatisch aus der ONNX-Datei gelesen.

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(())
}

Verwende InferenceConfig, um Schwellenwerte, Bildgröße, Genauigkeit und Gerät über eine Builder-API festzulegen:

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")?;

Jede Aufgabe befüllt ein anderes Feld in Results. Jeder Tab unten enthält ein vollständiges, ausführbares Programm; das Modell und die Beispieleingaben werden beim ersten Start automatisch heruntergeladen. Ersetze predict_default() durch predict("image.jpg"), um eigene Dateien zu verwenden.

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(())
}

Unterstützte Aufgaben#

Alle Ultralytics-Aufgaben werden unterstützt. Wenn --model nicht angegeben ist, wird das passende Nano-Modell für die ausgewählte Aufgabe automatisch heruntergeladen.

Aufgabe--taskAusgabeStandardmodell
ErkennungdetectBegrenzungsrahmen und Klassenyolo26n.onnx
InstanzsegmentierungsegmentRahmen sowie Masken für einzelne Instanzenyolo26n-seg.onnx
Semantische SegmentierungsemanticKlassenkarte pro Pixelyolo26n-sem.onnx
TiefenschätzungdepthTiefenkarte pro Pixel in Meternyolo26n-depth.onnx
KlassifizierungclassifyKlassenwahrscheinlichkeitenyolo26n-cls.onnx
PoseposeRahmen sowie Keypointsyolo26n-pose.onnx
Orientierte RahmenobbGedrehte Begrenzungsrahmenyolo26n-obb.onnx

--ocr ergänzt jedes Detect-, Segment- oder OBB-Modell um das Auslesen von Szenentext; ohne --model wird der Textdetektor yolo26n-text.onnx ausgeführt. Siehe OCR für Szenentext.

Modellkompatibilität#

Jedes Ultralytics-Modell, das nach ONNX exportiert wurde, kann aus einer lokalen Datei geladen werden. Der automatische Download ist für die standardmäßigen Modellnamen YOLO26, YOLO11 und YOLOv8 in den Größen n, s, m, l und x verfügbar:

ModellfamilieAutomatisch herunterladbare Varianten
YOLO26yolo26{n,s,m,l,x}.onnx, -seg, -sem, -depth, -cls, -pose, -obb und -text
YOLO11yolo11{n,s,m,l,x}.onnx, -seg, -cls, -pose und -obb
YOLOv8yolov8{n,s,m,l,x}.onnx, -seg, -cls, -pose und -obb

Semantische Segmentierung (-sem), Tiefenschätzung (-depth) und die Textdetektoren für Szenentext (-text) sind nur für YOLO26 verfügbar. Auch der PaddleOCR-Texterkenner PP-OCRv6_medium_rec.onnx und der Orientierungsklassifikator PP-LCNet_x0_25_textline_ori.onnx, die von --ocr verwendet werden (Apache-2.0), werden automatisch heruntergeladen. Erkennungsmodelle von RT-DETR können ebenfalls ausgeführt werden, werden aber nicht automatisch heruntergeladen: Exportiere zuerst eines nach ONNX. Native OpenVINO-IR-Exporte werden mit dem Feature openvino-native ausgeführt; siehe OpenVINO-IR-Modelle.

Eingabequellen#

Das Argument --source (und der Typ Source in der Bibliothek) akzeptiert viele Arten von Eingaben, die automatisch anhand der Zeichenfolge erkannt werden:

QuelleBeispielHinweise
Bildimage.jpgEinzelne Datei.
Verzeichnisimages/Alle Bilder im Ordner.
Glob-Musterimages/*.jpgMuster im Shell-Stil.
Videovideo.mp4Erfordert das Feature video.
Webcam0Erfordert das Feature video.
Streamrtsp://...Erfordert das Feature video.
URLhttps://example.com/image.jpgHerunterladen eines entfernten Bildes.

Gekachelte Inferenz#

Große Bilder mit kleinen Objekten, etwa Luft- oder Satellitenaufnahmen, lassen sich in überlappende Fenster aufteilen und anschließend zu einem Ergebnis zusammenführen – genauso wie mit dem Python-Argument tile. Die Fenster überlappen sich um 20 %, die Boxen werden auf das Quellbild zurückprojiziert und Duplikate klassenweise entfernt. Bei einem Export mit dynamischer Batchgröße verarbeitet --batch mehrere Fenster in einem Inferenzaufruf. Alle Aufgaben werden unterstützt.

# 640 px windows; a bare --tile uses --imgsz
ultralytics-inference predict --model yolo26n-obb.onnx --source aerial.jpg --tile 640
use 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 für Szenentext#

YOLO26-Text-Detektoren finden Wörter in gedrehten Boxen, und TextRecognizer liest sie mit PaddleOCR PP-OCRv6 aus, demselben Erkennungsmodell wie in der Python-OCR-Lösung. Auch die Boxen von Detektionsmodellen und die Masken von Segmentierungsmodellen funktionieren: Eine Maske wird anhand des flächenminimalen Rechtecks um ihren Umriss gelesen und behält den Umriss als Polygon bei. Jeder Ausschnitt wird aufrecht gedreht; Text, den der Orientierungsklassifikator als auf dem Kopf stehend erkennt, wird nach einer weiteren Drehung erneut gelesen. Die Texte werden in Leserichtung zurückgegeben. Das Erkennungsmodell läuft auf dem Gerät des Detektors.

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

Das Bibliotheksbeispiel lädt das Bild mit dem Crate image; füge es daher mit cargo add image neben dem Paket hinzu.

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 zeichnet jeden Text wie die Python-Lösung; auch --line-width, --show-labels und --show-conf gelten dafür.

Geräte und Ausführungsprovider#

GPU- und Beschleuniger-Backends werden als Cargo-Features einkompiliert und zur Laufzeit mit --device (CLI) oder Device (Bibliothek) ausgewählt. Wenn kein Gerät angegeben ist, werden die in den Build einkompilierten Provider in einer festgelegten Prioritätsreihenfolge registriert (zuerst TensorRT, dann CUDA usw.). Ein Build mit ausschließlich den Standard-Features läuft daher auf der CPU.

GerätezeichenfolgeVariante von DeviceBuild-FeatureHardware
cpuDevice::CpuintegriertBeliebige CPU
cuda:0Device::Cuda(0)cudaNVIDIA-GPU
tensorrt:0Device::TensorRt(0)tensorrtOptimierte NVIDIA-GPU
coremlDevice::CoreMlcoremlApple Silicon / macOS
intel:cpuDevice::IntelCpuopenvino oder openvino-nativeIntel-CPU
intel:gpuDevice::IntelGpuopenvino oder openvino-nativeIntel-GPU
intel:npuDevice::IntelNpuopenvino oder openvino-nativeIntel-NPU
directml:0Device::DirectMl(0)directmlWindows-GPU
rocm:0Device::Rocm(0)rocmAMD-GPU
migraphx:0Device::MiGraphX(0)migraphxAMD-GPU (Linux x64)
xnnpackDevice::XnnpackxnnpackOptimierte CPU
# Build the CLI with the providers you need
cargo install ultralytics-inference --features cuda,tensorrt

OpenVINO-IR-Modelle#

Mit dem Feature openvino-native kann --model auch einen nativen OpenVINO-Export entgegennehmen – die Datei .xml oder den Ordner aus yolo export format=openvino – und ihn über die OpenVINO-Laufzeit statt über ONNX Runtime ausführen. Alle Aufgaben laufen auf intel:cpu, intel:gpu und intel:npu; die Bibliothek lädt das Modell mit YOLOModel::load("yolo26n_openvino_model"). Für den Build ist keine OpenVINO-Installation nötig; die Laufzeit wird geladen, sobald das erste Modell geöffnet wird. Informationen zur Einrichtung findest du in der OpenVINO-Anleitung.

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

GPU-Beschleunigung und CUDA-Vorverarbeitung#

Auf NVIDIA-Hardware aktiviert das Feature cuda den CUDA-Ausführungsanbieter, und tensorrt fügt den TensorRT-Anbieter zur weiteren Optimierung hinzu (es umfasst cuda, das auch den OCR-Texterkenner ausführt). Für eine möglichst geringe Inferenzlatenz verlagert das Feature cuda-preprocess die Vorverarbeitung auf die GPU.

cuda-preprocess führt das Letterbox-Resizing, die Normalisierung und die Layoutkonvertierung von HWC zu CHW als einen einzigen fusionierten CUDA-Kernel aus und übergibt das Ergebnis anschließend als Gerätetensor ohne Kopiervorgang an das Modell. Der rohe 8-Bit-Frame wird weiterhin auf die GPU hochgeladen, bei diskreten GPUs über einen gepinnten Staging-Puffer. Der Kernel übernimmt jedoch das Resizing, die Normalisierung und die Layoutkonvertierung auf der CPU sowie den separaten Upload des vorverarbeiteten Tensors. Das ist vor allem bei Batches mit hohem Durchsatz und Echtzeit-Streams wichtig.

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

Der schnelle Ausführungspfad wird automatisch und ohne Änderung an der API verwendet, wenn alle folgenden Bedingungen erfüllt sind: Das Feature ist einkompiliert, das Gerät ist CUDA oder TensorRT oder nicht festgelegt, die Aufgabe ist Detect, Segment, semantische Segmentierung (nur Einzelbilder), Tiefenschätzung, Pose oder OBB, und das Modell verwendet FP32-Eingaben. Er ist standardmäßig aktiviert und kann für jedes Modell deaktiviert werden:

use ultralytics_inference::{Device, InferenceConfig};

let config = InferenceConfig::new()
    .with_device(Device::TensorRt(0))
    .with_cuda_preprocess(false); // force CPU preprocessing
CUDA-Toolkit passend auswählen

cuda-preprocess benötigt beim Build ein passendes CUDA-Toolkit und verwendet zur Laufzeit NVRTC für den fusionierten Kernel zur Vorverarbeitung. Versionsanforderungen und Hinweise zur Fehlerbehebung findest du im Leitfaden zur CUDA- und TensorRT-Beschleunigung.

Cargo-Features#

Features werden beim Build aktiviert. Die Standardeinstellungen umfassen Annotation und Live-Anzeige.

MerkmalStandardZweck
annotatejaBoxen, Masken, Keypoints, Beschriftungen und OCR-Texte zeichnen; erforderlich für --save.
visualizejaEchtzeitanzeige in einem Fenster für --show.
videoneinVideodateien lesen und schreiben (erfordert FFmpeg 6 bis 9).
cudaneinNVIDIA-CUDA-Ausführungsprovider.
tensorrtneinNVIDIA-TensorRT-Ausführungsanbieter (umfasst cuda).
cuda-preprocessneinZusammengeführte GPU-Vorverarbeitung (setzt cuda und tensorrt voraus; benötigt das CUDA-Toolkit).
coremlneinApple-CoreML-Ausführungsprovider.
openvinoneinIntel-OpenVINO-Ausführungsanbieter (Linux und Windows x64).
openvino-nativeneinNative OpenVINO-IR-Modelle (.xml) über die OpenVINO-Laufzeit.
rocmneinAMD-ROCm-Ausführungsanbieter (benötigt einen eigenen ONNX-Runtime-Build).
migraphxneinAMD-MIGraphX-Ausführungsanbieter (Linux x64).
directmlneinWindows-DirectML-Ausführungsprovider.
xnnpackneinXNNPACK-Ausführungsanbieter für optimierte CPU-Inferenz.

Praktische Gruppen bündeln zusammengehörige Anbieter: nvidia (cuda, tensorrt), amd (rocm, migraphx), intel (openvino, onednn), mobile (nnapi, coreml, qnn) und all (annotate, visualize, video). Außerdem sind die Anbieter onednn, nnapi, qnn, acl, tvm, rknpu, cann, webgpu und azure verfügbar.

Aktiviere Features beim Installieren der CLI oder beim Hinzufügen der Bibliothek:

cargo install ultralytics-inference --features video
cargo install ultralytics-inference --features cuda,tensorrt
[dependencies]
ultralytics-inference = { version = "0.0.58", features = ["video"] }

Ausgabe und Speichern#

Vorhersagen werden standardmäßig annotiert und in einem automatisch nummerierten Ausführungsverzeichnis gespeichert:

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

Der Unterordner entspricht der Aufgabe (runs/segment/, runs/pose/ usw.). Bei Videoquellen wird die annotierte Ausgabe als Videodatei geschrieben; übergib --save-frames, um stattdessen einzelne Frames zu speichern. Für die Aufgabe semantic schreibt --save-json PNG-Dateien mit Klassenkarten pro Pixel in einen Unterordner results/. Für die Aufgabe depth wird die farbige Tiefenkarte über das Quellbild gelegt, wie bei der Ausgabe plot() von Ultralytics Python. Das Speichern annotierter Bilder und Videos erfordert das Feature annotate; der Export semantischer Klassenkarten als PNG erfordert es nicht. Videoeingabe und -ausgabe erfordern das Feature video.

Das Zeichnen entspricht dem Python-Results.plot(): Die Linienbreite beträgt standardmäßig 0,3 % der mittleren Bildseite (mindestens 2 px), Beschriftungen stehen über jeder Box oder darin, wenn kein Platz darüber ist, und Instanzmasken werden auf dieselbe Weise überlagert, sodass gespeicherte Bilder mit Python übereinstimmen. --line-width, --show-labels, --show-conf und --show-boxes funktionieren wie die gleichnamigen Python-Argumente. In der Bibliothek übergibst du sie über 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);

Segmentierungsmasken werden wie in Python in der Inferenzgröße erstellt; übergib --retina-masks (oder InferenceConfig::with_retina_masks(true)), um sie in der Originalbildgröße zu erstellen.

Häufig gestellte Fragen#

  • Nein. Die Crate führt exportierte ONNX-Modelle direkt mit ONNX Runtime aus. Python wird nur benötigt, wenn du Modelle zuvor mit dem Ultralytics-Paket trainierst oder exportierst.

  • Jedes nach ONNX exportierte Ultralytics-YOLO-Modell, einschließlich YOLO26, YOLO11 und YOLOv8. Bekannte Modellnamen werden automatisch heruntergeladen; du kannst --model auch auf eine beliebige lokale .onnx-Datei verweisen.

  • Exportiere das Modell aus dem Python-Paket, zum Beispiel mithilfe der ONNX-Integration, oder lass die CLI beim ersten Start automatisch ein standardmäßiges Nano-Modell für die ausgewählte Aufgabe herunterladen.

  • Ja. --ocr liest Szenentext mit einem YOLO26-Text-Detektor und PaddleOCR aus, wie die Python-OCR-Lösung, und funktioniert auch mit den Boxen oder Masken deiner eigenen Detect- und Segment-Modelle. Siehe OCR für Szenentext.

  • Nutze die gekachelte Inferenz: --tile 640 teilt das Bild in überlappende Fenster von 640 px auf und führt die Erkennungen anschließend zu einem Ergebnis zusammen.

  • Ja, wenn das Feature video aktiviert und FFmpeg 6 bis 9 auf dem System installiert ist. Damit werden Videodateien, Webcams und RTSP-/RTMP-/HTTP-Streams unterstützt.

  • Beide sind standardmäßig aktiviert. annotate zeichnet Boxen, Masken, Keypoints und Klassenbezeichnungen in das Bild ein und ist erforderlich, damit --save annotierte Ergebnisse speichern kann. visualize öffnet ein Live-Fenster für --show. Für einen kleineren Build ohne grafische Oberfläche, der Ergebnisse nur programmgesteuert zurückgibt, deaktiviere sie mit cargo build --no-default-features (füge bei Bedarf einzelne Features wieder hinzu).

  • Diese Seite bietet einen allgemeinen Überblick. Die vollständige API-Referenz mit Angaben zu jedem öffentlichen Struct, jeder Methode und jeder Konfigurationsoption ist auf docs.rs veröffentlicht und wird direkt aus dem Quellcode generiert.

Kommentare

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.