Thread-sichere Inferenz mit YOLO-Modellen#

Um Ultralytics YOLO-Inferenz sicher über Python-Threads hinweg auszuführen, erstelle in jedem Thread ein eigenes YOLO-Modell, statt eine Instanz gemeinsam zu verwenden. Die gemeinsame Verwendung eines einzelnen Modells führt zu Wettlaufsituationen, die seinen internen Zustand beschädigen und unvorhersehbare Ergebnisse verursachen, da das Python-Modul threading die Threads gleichzeitig auf dasselbe Objekt zugreifen lässt. Diese Anleitung erklärt, warum die gemeinsame Nutzung fehlschlägt, zeigt das sichere Muster mit einer Instanz pro Thread und behandelt den Dekorator ThreadingLocked für Fälle, in denen du eine Instanz gemeinsam verwenden musst.

Springe zu den Gründen, warum die gemeinsame Nutzung eines Modells fehlschlägt, zum thread-sicheren Muster oder zum ThreadingLocked-Dekorator.

Python-Threading verstehen#

Python-Threads sind eine Form der Parallelverarbeitung, mit der dein Programm mehrere Vorgänge gleichzeitig ausführen kann. Allerdings sorgt Pythons Global Interpreter Lock (GIL) dafür, dass immer nur ein Thread gleichzeitig Python-Bytecode ausführen kann.

Auch wenn das nach einer Einschränkung klingt, können Threads weiterhin gleichzeitige Verarbeitung ermöglichen, insbesondere bei E/A-gebundenen Vorgängen oder bei Vorgängen, die den GIL freigeben, wie etwa bei den zugrunde liegenden C-Bibliotheken von YOLO.

Die Gefahr gemeinsam genutzter Modellinstanzen#

Wenn du ein YOLO-Modell außerhalb deiner Threads instanziierst und diese Instanz in mehreren Threads gemeinsam verwendest, kann es zu Wettlaufsituationen kommen. Dabei wird der interne Zustand des Modells durch gleichzeitige Zugriffe uneinheitlich verändert. Besonders problematisch ist dies, wenn das Modell oder seine Komponenten Zustände enthalten, die nicht für die Thread-Sicherheit ausgelegt sind.

Nicht thread-sicheres Beispiel: einzelne Modellinstanz#

Bei der Verwendung von Threads in Python solltest du Muster erkennen, die zu Problemen bei der gleichzeitigen Verarbeitung führen können. Folgendes solltest du vermeiden: die gemeinsame Nutzung einer einzelnen YOLO26-Modellinstanz in mehreren Threads.

# Unsicher: Eine einzelne Modellinstanz wird von mehreren Threads gemeinsam verwendet
from threading import Thread

from ultralytics import YOLO

# Das Modell außerhalb des Threads instanziieren
shared_model = YOLO("yolo26n.pt")

def predict(image_path):
    """Predicts objects in an image using a preloaded YOLO model, take path string to image as argument."""
    results = shared_model.predict(image_path)
    # Ergebnisse verarbeiten

# Threads starten, die dieselbe Modellinstanz verwenden
Thread(target=predict, args=("image1.jpg",)).start()
Thread(target=predict, args=("image2.jpg",)).start()

Im obigen Beispiel wird shared_model von mehreren Threads verwendet. Das kann zu unvorhersehbaren Ergebnissen führen, weil predict gleichzeitig von mehreren Threads ausgeführt werden kann.

Sicheres Beispiel: eine eigene Instanz pro Thread#

Mehrere separate Modellinstanzen sind unproblematisch, solange jeder Thread seine eigene Instanz besitzt und sie niemals mit einem anderen Thread teilt. Es spielt keine Rolle, dass die folgenden Instanzen vor dem Start der Threads erstellt werden – unsicher ist nur, eine einzelne Instanz über mehrere Threads hinweg gemeinsam zu verwenden:

# Sicher: Jeder Thread verwendet eine eigene Modellinstanz
from threading import Thread

from ultralytics import YOLO

# Ein Modell pro Thread instanziieren
model_1 = YOLO("yolo26n.pt")
model_2 = YOLO("yolo26n.pt")

def predict(model, image_path):
    """Runs prediction on an image using a specified YOLO model, returning the results."""
    results = model.predict(image_path)
    # Ergebnisse verarbeiten

# Jeder Thread verwendet eine separate, eigene Modellinstanz
Thread(target=predict, args=(model_1, "image1.jpg")).start()
Thread(target=predict, args=(model_2, "image2.jpg")).start()

Da jeder Thread mit seiner eigenen Instanz arbeitet, gibt es keinen gemeinsamen Modellzustand, den die Threads beschädigen könnten. Das Modell wie im nächsten Beispiel innerhalb jedes Threads zu instanziieren, ist einfach der leichteste Weg, um sicherzustellen, dass eine Instanz nicht versehentlich gemeinsam verwendet wird.

Threadsichere Inferenz#

Für eine thread-sichere Inferenz solltest du in jedem Thread ein eigenes YOLO-Modell instanziieren. So erhält jeder Thread eine isolierte Modellinstanz und das Risiko von Wettlaufsituationen entfällt.

Thread-sicheres Beispiel#

So instanziierst du für eine sichere parallele Inferenz in jedem Thread ein YOLO-Modell:

# Sicher: Eine einzelne Modellinstanz in jedem Thread instanziieren
from threading import Thread

from ultralytics import YOLO

def thread_safe_predict(image_path):
    """Predict on an image using a new YOLO model instance in a thread-safe manner; takes image path as input."""
    local_model = YOLO("yolo26n.pt")
    results = local_model.predict(image_path)
    # Ergebnisse verarbeiten

# Threads starten, die jeweils eine eigene Modellinstanz haben
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

In diesem Beispiel erstellt jeder Thread eine eigene YOLO-Instanz. Dadurch kann kein Thread den Modellzustand eines anderen Threads beeinflussen. So führt jeder Thread sicher Inferenz aus, ohne unerwartete Wechselwirkungen mit den anderen Threads.

Den ThreadingLocked-Dekorator verwenden#

Ultralytics stellt einen ThreadingLocked-Dekorator bereit, mit dem sich die thread-sichere Ausführung von Funktionen sicherstellen lässt. Der Dekorator verwendet eine Sperre, damit immer nur ein Thread gleichzeitig die dekorierte Funktion ausführen kann.

from ultralytics import YOLO
from ultralytics.utils import ThreadingLocked

# Eine Modellinstanz erstellen
model = YOLO("yolo26n.pt")

# Die Vorhersagefunktion dekorieren, damit sie thread-sicher ist
@ThreadingLocked()
def thread_safe_predict(image_path):
    """Thread-safe prediction using a shared model instance."""
    results = model.predict(image_path)
    return results

# Jetzt kannst du diese Funktion sicher aus mehreren Threads aufrufen

Der Dekorator ThreadingLocked ist besonders nützlich, wenn du eine Modellinstanz über mehrere Threads hinweg gemeinsam verwenden musst, aber sicherstellen möchtest, dass immer nur ein Thread gleichzeitig darauf zugreifen kann.

Fazit#

Wenn du YOLO-Modelle mit Pythons threading verwendest, gib jedem Thread eine eigene Modellinstanz und verwende niemals dieselbe Instanz in mehreren Threads. Das Modell in dem Thread zu instanziieren, der es verwendet, ist der einfachste Weg, dies sicherzustellen. So vermeidest du Wettlaufsituationen und sorgst für zuverlässige Inferenzaufgaben.

Für anspruchsvollere Anwendungsfälle und zur weiteren Optimierung der Leistung deiner parallelen Inferenz kannst du die prozessbasierte Parallelverarbeitung mit multiprocessing oder eine Aufgabenwarteschlange mit eigenen Worker-Prozessen nutzen.

Häufig gestellte Fragen#