Kleine Objekte mit Bildkachelung in Ultralytics YOLO erkennen – von Python bis Rust

Warum übersieht ein Detektor, der bei gewöhnlichen Fotos gut funktioniert, die meisten Menschen in einer Drohnenaufnahme? Oft, weil er sie nie in voller Größe sieht. Bei der Standardeinstellung imgsz=640 verkleinert Ultralytics YOLO ein Bild mit 1920 x 1080 Pixeln dreimal, bevor das Modell es untersucht. Ein 15 Pixel großer Fußgänger ist dann nur noch etwa 5 Pixel groß.

Durch Bildkachelung bleiben Details kleiner Objekte erhalten, indem das Modell auf überlappende Ausschnitte des Bildes in voller Auflösung angewendet und die Ergebnisse zusammengeführt werden. Bei einem VisDrone-Bild in unserer Dokumentation stieg die Zahl der Erkennungen mit Ultralytics YOLO26s von 35 auf 161. Dafür fällt pro Bild mehr Rechenaufwand an: Bei diesem Bild werden acht Kacheleingaben statt eines Bildes verarbeitet.

Die Kachelung ist jetzt auf beiden Seiten der Bereitstellung integriert. Das Python-Paket unterstützt seit dem 6. November mit Ultralytics 8.4.204 das Argument tile, und die Rust-Bibliothek hat am 9. November mit Ultralytics Inference 0.0.57 das Flag --tile hinzugefügt. Dieser Leitfaden erläutert, wann Kachelung kleine Objekte wieder sichtbar macht, welchen Aufwand sie verursacht und wie du sie in beiden Fällen ausführst.

Durch Verkleinern werden kleine Objekte unsichtbar#

Kleine Objekte zu erkennen ist aus einem einfachen Grund schwierig: Ein Objekt hat nur die Pixel, die es hat. Ein Objekterkennungsmodell lernt Formen anhand einer Handvoll Pixel pro Objekt. Wird das gesamte Bild auf eine längste Seite von 640 Pixeln verkleinert, sind weit entfernte Menschen, Fahrzeuge und Defekte so klein, dass das Netzwerk sie nicht mehr von Texturen und Bildrauschen unterscheiden kann.

Das zeigt sich besonders bei Luftbildern, der Analyse von Satellitenbildern, Weitwinkel-Verkehrs- und Überwachungskameras sowie hochauflösenden Inspektionsfotos. VisDrone ist ein weit verbreiteter öffentlicher Luftbild-Benchmark: In der Dokumentation werden Objekte beschrieben, die im Bild oft nur einige Dutzend Pixel groß sind und in dichten, stark verdeckten Gruppen auftreten.

Durch Kachelung bleiben diese Pixel erhalten. Ist tile auf die Eingabegröße des Modells eingestellt, sieht das Modell mehrere Ausschnitte in nativer Auflösung statt eines verkleinerten Bildes in einem Durchlauf. Das Konzept entspricht der vom Autorenteam des SAHI-Artikels als slicing-aided hyper inference bezeichneten Methode, die anhand der Luftbilddatensätze VisDrone und xView evaluiert wurde.

Im Leitfaden zur Kachelung hochauflösender Bilder liefert YOLO26s für ein VisDrone-Bild mit 1920 x 1080 Pixeln und dem standardmäßigen Konfidenzschwellenwert 35 Erkennungen für das gesamte Bild bei imgsz=640 und 161 bei tile=640. Darunter sind weit entfernte Fußgänger, Radfahrer und Autos. Der Leitfaden zeigt beide Bilder nebeneinander. Dabei handelt es sich um Vorhersagezahlen, nicht um eine bewertete Evaluation. Für beide Zahlen wurden dieselben Gewichte verwendet; durch die Kachelung änderte sich außerdem der Kontext, den jeder Ausschnitt erfasste.

Ein zweites VisDrone-Validierungsbild mit 1920 x 1080 Pixeln, YOLO26s mit der standardmäßigen Konfidenz: 8 Erkennungen im gesamten Bild bei imgsz=640, 128 bei tile=640. Ausschnitt der Straße, Begrenzungsrahmen ohne Klassenbezeichnungen.

Kachelung fügt eine Modelleingabe pro Ausschnitt hinzu#

Der Leitfaden definiert die Aufteilung in Ausschnitte präzise. Die Ausschnitte überlappen sich grundsätzlich um 20 %, und die letzte Zeile und Spalte werden am Bildrand ausgerichtet, sodass sich die Randbereiche stärker überlappen können. Ist ein Bild kleiner als der Ausschnitt, wird ein einzelner Ausschnitt des gesamten Bildes verwendet.

So lässt sich der Aufwand leicht abschätzen. Ein Bild mit 1920 x 1080 Pixeln wird bei tile=640 in acht Ausschnitten verarbeitet: vier nebeneinander und zwei untereinander. Auch ein Bild mit 3840 x 2160 Pixeln wird bei tile=1280 in acht Ausschnitten verarbeitet. Wendet man dieselbe 20-%-Regel auf ein Bild mit 3840 x 2160 Pixeln bei tile=640 an, erhält man acht Spalten und vier Zeilen, also 32 Ausschnitte. Eine Halbierung der Ausschnittgröße vervierfacht somit die Anzahl der Kacheleingaben bei einem 4K-Bild.

Die acht Ausschnitte, die bei tile=640 für ein Bild mit 1920 x 1080 Pixeln verwendet werden: Die Spalten beginnen bei x = 0, 512, 1024 und 1280, die Zeilen bei y = 0 und 440. Die schattierten Bereiche werden von mehreren Ausschnitten erfasst.

Batching beeinflusst, wie diese Eingaben das Modell erreichen. In Python legt batch fest, wie viele Ausschnitte in einem Inferenzaufruf gemeinsam durch das Modell laufen. Die Rust-Bibliothek bietet dasselbe mit --batch bei einem Export mit dynamischer Batchgröße. Batching kann den Durchsatz erhöhen, aber miss die Latenz auf deiner Hardware. Unser Leitfaden zur Batch-Inferenz mit Ultralytics YOLO erläutert die Gründe.

So schneidet Kachelung im Vergleich zu anderen Möglichkeiten ab, kleinen Objekten mehr Pixel zu geben:

Jede Kachel ist eine gewöhnlich große Modelleingabe. So verarbeitet Kachelung sehr große Bilder, ohne imgsz zu erhöhen. Ausgaben in der Größe der Quelle, etwa Masken und Tiefenkarten, benötigen weiterhin Speicher proportional zur Größe des Originalbildes, und max_det begrenzt die Anzahl der gespeicherten Instanzmasken.

Wann Kachelung hilft – und wann sie schadet#

Kachelung hilft, wenn Objekte im Verhältnis zum Bild klein sind und das Bild viel größer als die Modelleingabe ist. Dazu zählen Drohnen- und Satellitenbilder, Verkehr aus der Vogelperspektive, Menschenmengen, weitwinklig fotografierte Ladenregale und Bilder zur visuellen Inspektion ganzer Platinen oder Schalttafeln.

Bei großen Objekten ist sie nachteilig. Ein Ausschnitt zeigt nur einen Teil eines Lastwagens, der die Hälfte des Bildes ausfüllt. Der Leitfaden weist ausdrücklich darauf hin: Objekte, die größer als die Überlappung sind, können weiterhin geteilt werden, weil kein Ausschnitt sie vollständig erfasst, und beim Zusammenführen werden einzelne Fragmente nicht verbunden. Außerdem geht der globale Kontext verloren, was sich besonders auf Klassifikation und Tiefenschätzung auswirkt, bei denen die Ergebnisse der Ausschnitte im Bild voneinander abweichen können.

Kleinere Ausschnitte bringen einen weiteren Zielkonflikt mit sich. Wird ein 400 Pixel großer Ausschnitt auf 640 Pixel vergrößert, hilft das bei Objekten, die nur wenige Pixel breit sind. Gleichzeitig wird aber auch der störende Hintergrund vergrößert, was zu falsch positiven Ergebnissen führen kann. Vergleiche zwei oder drei Kachelgrößen mit deinem eigenen Validierungssatz und achte sowohl auf die Präzision als auch auf den Recall.

So werden Kacheln wieder zu einem Ergebnis zusammengeführt#

Jeder Ausschnitt liefert eigene Vorhersagen in den Koordinaten des Ausschnitts. Die Kachelung überträgt sie auf das Quellbild zurück und gibt pro Originalbild ein Results-Objekt zurück. Nachgelagerter Code, der result.boxes ausliest, funktioniert daher unverändert weiter.

Durch Überlappungen kann ein Objekt nahe einer Nahtstelle zweimal erkannt werden. Bei der Objekterkennung werden Duplikate mithilfe der Nicht-Maximum-Unterdrückung und deiner Einstellungen iou, agnostic_nms und max_det unterdrückt. Unser Leitfaden zum Einstellen des NMS-IoU-Schwellenwerts gilt daher direkt für gekachelte Ausgaben. Ein an der Kante eines Ausschnitts abgeschnittener Begrenzungsrahmen wird verworfen, wenn ein anderer Ausschnitt das Objekt vollständig innerhalb seiner Grenzen erfasst und ein beibehaltener Begrenzungsrahmen es abdeckt. So bleibt an der Nahtstelle die vollständigere Vorhersage erhalten. Ein abgeschnittener Begrenzungsrahmen ohne bessere Übereinstimmung bleibt erhalten.

Eine Darstellung des Umgangs mit der Nahtstelle bei y = 640 im selben Bild. Türkisfarbene Begrenzungsrahmen werden an der Unterkante der oberen Ausschnitte abgeschnitten, magentafarbene Begrenzungsrahmen stammen aus den unteren Ausschnitten. Die rechte Abbildung zeigt für jedes Auto den vollständigeren Begrenzungsrahmen, der nach dem Zusammenführen erhalten bleibt.

Jede Ultralytics-YOLO-Aufgabe führt die Ergebnisse auf eigene Weise zusammen:

• Detect, Segment, Pose und OBB übertragen Begrenzungsrahmen, Masken, Keypoints oder gedrehte Begrenzungsrahmen zurück in die Koordinaten des Quellbildes und wählen Begrenzungsrahmen aus; für OBB wird gedrehtes NMS angewendet.
• Semantische Segmentierung fügt Klassenkarten zusammen und wählt bei überlappenden Ausschnitten den jeweils zentralsten Ausschnitt aus.
• Tiefenschätzung mischt überlappende Tiefenkarten mit Gewichtungen, die zur Mitte jeder Kachel hin zunehmen.
• Klassifikation mittelt die Wahrscheinlichkeiten der Kacheln.

Die Python-Pipeline kachelt bei Vorhersagen außerdem YOLO-World, YOLOE, RT-DETR und FastSAM. SAM verwendet eine eigene Ausschnitt-Pipeline und akzeptiert tile nicht.

Gekachelte Inferenz in Python mit dem tile-Argument#

Für die Kachelung brauchst du Ultralytics 8.4.204 oder höher und kein zusätzliches Paket. Übergib im Vorhersagemodus tile=True, um imgsz als Ausschnittgröße zu verwenden, oder gib eine Ganzzahl an, um die Ausschnittgröße separat festzulegen:

from ultralytics import YOLO

model = YOLO("yolo26s.pt")

# Basisversion: ein Durchlauf über das auf 640 Pixel verkleinerte Bild
full = model.predict("intersection.jpg", imgsz=640)

# Gekachelt: 640 Pixel große Ausschnitte in nativer Auflösung, 8 Ausschnitte pro Batch
tiled = model.predict("intersection.jpg", imgsz=640, tile=640, batch=8)

print(len(full[0].boxes), len(tiled[0].boxes))

Dasselbe Argument funktioniert auch mit der CLI über yolo predict model=yolo26s.pt source=large-image.tif tile=640 imgsz=640 batch=8. Übergib bei Videos stream=True, um den Speicherverbrauch zu begrenzen. Im Tracking-Modus wird der Tracker pro Bild einmal auf die zusammengeführten Vorhersagen angewendet.

Kachelung ist nicht nur für Vorhersagen gedacht. Wenn deine Bilder viel größer als imgsz sind, trainiere und validiere mit derselben Einstellung:

1. Auf Kacheln trainieren mit model.train(data="aerial.yaml", tile=True, imgsz=640). Beschriftungen werden auf die einzelnen Ausschnitte begrenzt. Instanzen, bei denen weniger als 10 % der ursprünglichen Begrenzungsrahmenfläche übrig bleiben, werden entfernt, und leere Ausschnitte bleiben als negative Beispiele erhalten.
2. Anhand zusammengeführter Ergebnisse validieren mit model.val(data="aerial.yaml", tile=True, imgsz=640). Vorhersagen werden zusammengeführt, bevor sie anhand der Originalannotationen bewertet werden. So entspricht der mAP dem, was du bereitstellen wirst.
3. Große Quelldateien zwischenspeichern mit cache="ram", da beim Training die Kacheln zufällig angeordnet werden und dasselbe große Bild sonst viele Male dekodiert werden müsste.
4. Mit einer Basisversion für das gesamte Bild vergleichen, und zwar anhand derselben Validierungsaufteilung, bevor du das gekachelte Modell übernimmst. Weitere Möglichkeiten, die Bewertung kleiner Objekte zu verbessern, findest du in unserer Checkliste für den mAP kleiner Objekte.

Beim Training mit Kacheln sieht das Modell Objekte in der Größe, in der sie auch bei der gekachelten Vorhersage auftreten. Unser Leitfaden zu Datensätzen für die Drohnenerkennung führt anhand von 4K-Bildern durch den gesamten Ablauf aus Training, Kachelung und Evaluation.

Auch exportierte Modelle lassen sich kacheln. Da die Kachelung in der Python-Vorhersagepipeline ausgeführt wird, behält ein nach ONNX oder TensorRT exportiertes Modell seinen üblichen Eingabegraphen, und YOLO("yolo26s.onnx").predict(source, tile=640) funktioniert wie gewohnt – auch mit festen Batchgrößen beim Export und dem letzten unvollständigen Batch.

Der VisDrone-Datensatz in Ultralytics Platform ist ein sofort nutzbarer Benchmark, um Kachelgrößen zu testen, bevor du deine eigenen Daten beschriftest.

Wenn du Kachelgrößen zunächst mit öffentlichen Daten ausprobieren möchtest, beginne mit dem VisDrone-Datensatz auf Ultralytics Platform. Um einen gekachelten Lauf neben deiner Basisversion zu protokollieren, kopiere den Befehl für lokales Training aus dem Trainingsdialog der Platform, setze project auf das Platform-Projekt deiner Basisversion und füge tile=True hinzu, um die Metriken des gekachelten Laufs dorthin zu übertragen.

Gekachelte Inferenz in Rust mit dem neuen Flag --tile#

Ultralytics Inference ist unsere Rust-Bibliothek und CLI zum Ausführen exportierter ONNX-Modelle mit ONNX Runtime sowie von OpenVINO-IR-Modellen direkt und ohne Python-Laufzeitumgebung zur Inferenz. Sie ist für Server, Container und Edge-Geräte mit CPU, CUDA, TensorRT, CoreML, OpenVINO und anderen Ausführungsanbietern vorgesehen. Version 0.0.57 übernimmt denselben Kachelansatz wie Python: 20 % Basisüberlappung der Ausschnitte, Übertragung der Ergebnisse zurück auf das Quellbild und klassenweise Entfernung von Duplikaten.

Zur Veranschaulichung. Eine Straßenkamera mit Edge-Computer – eine typische Bereitstellung ohne Python, auf die die Rust-Bibliothek ausgerichtet ist.

Das Team verglich gekachelte Ausgaben mit Ultralytics Python unter ONNX Runtime CPU, OpenVINO CPU, GPU und NPU, CUDA und TensorRT sowie mit Bildern, Videos und Webcams. Unterstützt werden Modelle für Objekterkennung, Segmentierung, semantische Segmentierung, Tiefenschätzung, Klassifikation, Pose und OBB.

Füge in der CLI --tile mit einer Ausschnittgröße hinzu oder übergib es ohne Wert, um --imgsz zu verwenden. Der Modell-Export ist ein einmaliger Schritt in Python; für die Inferenz selbst wird nur die Rust-Binärdatei benötigt:

# One-time export in Python: a dynamic-batch ONNX model so several windows run per call
pip install -U "ultralytics[export-base]>=8.4.204"
yolo export model=yolo26s.pt format=onnx dynamic=True

# Install the Rust CLI
cargo install ultralytics-inference

# Tiled inference on a large image: 640-pixel windows, 8 per batch
ultralytics-inference predict --model yolo26s.onnx --source aerial.jpg --tile 640 --batch 8

Als Bibliothek richtest du die Kachelung einmal in InferenceConfig ein, und jeder Aufruf von predict wird gekachelt ausgeführt. with_tile(0) verwendet die Inferenzgröße:

use ultralytics_inference::{InferenceConfig, YOLOModel};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = InferenceConfig::new().with_tile(640);
    let mut model = YOLOModel::load_with_config("yolo26s.onnx", config)?;
    let results = model.predict("aerial.jpg")?;
    if let Some(ref boxes) = results[0].boxes {
        println!("{} detections", boxes.len());
    }
    Ok(())
}

Doppelte Begrenzungsrahmen in überlappenden Ausschnitten werden mit klassenweisem NMS und dem festgelegten --iou entfernt. Seit derselben Version ist der Standardwert 0.5 und entspricht damit den Ultralytics-Standardwerten für Vorhersagen. Kachelung ist standardmäßig deaktiviert, da jeder Ausschnitt eine weitere Modelleingabe bedeutet. Aktiviere sie dort, wo Details wichtig sind, miss die Inferenzlatenz auf dem Zielgerät und wähle den passenden Ausführungsanbieter. Unser Vergleich von ONNX und TensorRT hilft bei NVIDIA-Hardware, und der Leitfaden zu NVIDIA Jetson erläutert die Einrichtung auf dem Gerät.

SAHI-Nutzer können zum integrierten tile-Argument wechseln#

Wenn du bereits mit der SAHI-Bibliothek Bilder in Ausschnitte aufteilst, erledigt das integrierte Argument dieselbe Aufgabe direkt in Ultralytics – ohne zusätzliches Paket oder separates Ergebnisformat. Unser Leitfaden zur SAHI-Integration ist jetzt veraltet und wurde durch tile ersetzt.

Für die Umstellung eines SAHI-Skripts müssen meist nur die Argumente geändert werden:

Die Ausschnitte sind quadratisch. Überlappung und Zusammenführung folgen den oben beschriebenen Regeln statt der konfigurierbaren Nachbearbeitung von SAHI. Erwarte daher ähnliche, aber nicht identische Begrenzungsrahmen. Überprüfe deine Schwellenwerte nach dem Wechsel erneut anhand eines Validierungssatzes.

Der praktische Unterschied liegt in der Integration. tile lässt sich mit demselben Argument in das Training, die Validierung, die Vorhersage und das Tracking von Ultralytics einbinden, gibt standardmäßige Results-Objekte zurück und bietet eine entsprechende Option in der Rust-Bibliothek. So kannst du eine in einem Notebook validierte Kachelgröße auch in einer Rust-Binärdatei am Edge-Gerät verwenden.

Für wen sich die Kachelung eignet#

Aktiviere die Kachelung, wenn du Ultralytics YOLO auf Bildern ausführst, die um ein Mehrfaches größer als die Modelleingabe sind, und deine Validierung zeigt, dass kleine Objekte übersehen werden. Das betrifft Drohnen- und Satellitenteams, Anbieter von Verkehrs- und Sicherheitslösungen mit Weitwinkelkameras sowie Inspektionsteams, die ganze Platinen, Schalttafeln oder Regale fotografieren. Rust-Nutzer erhalten denselben Kachelansatz auf Edge-Hardware ohne Python-Laufzeitumgebung.

Lass die Kachelung deaktiviert, wenn Objekte im Verhältnis zum Bild groß sind, eine größere imgsz sie bereits in einem Durchlauf erkennt oder das Latenzbudget nicht mehrere Kacheleingaben pro Bild zulässt. Vergleiche in jedem Fall gekachelte Ergebnisse und Ergebnisse für das gesamte Bild anhand derselben Validierungsaufteilung und desselben Konfidenzschwellenwerts. Achte dabei auf Recall, falsch positive Ergebnisse und Latenz, und verwende Kachelung nur, wenn der Zugewinn den zusätzlichen Aufwand rechtfertigt.

Ultralytics Platform fasst diesen Vergleich an einem Ort zusammen: Beschrifte deine eigenen hochauflösenden Bilder oder beginne mit VisDrone, trainiere eine Basisversion für das gesamte Bild auf Cloud-GPUs, trainiere eine weitere Basisversion mit einer größeren imgsz und protokolliere einen gekachelten Lauf von deinem eigenen Rechner im selben Projekt. Der Leitfaden zur Kachelung hochauflösender Bilder erläutert die Kacheloptionen, und die Dokumentation zu Ultralytics Inference behandelt die Bereitstellung mit Rust.

Das Python-Paket und die Rust-Bibliothek sind unter AGPL-3.0 verfügbar. Wenn du gekachelte Erkennung in ein Closed-Source-Produkt oder ein Edge-Gerät integrierst, das du an Kunden auslieferst, erlaubt eine Ultralytics-Unternehmenslizenz die kommerzielle Nutzung der abgedeckten Ultralytics-Software ohne die Offenlegungspflichten des AGPL-3.0, vorbehaltlich der Lizenzbedingungen.