Thread-sichere Inferenz mit YOLO-Modellen#

Um Ultralytics YOLO sicher auszuführen, erzeuge innerhalb jedes Python-Threads ein eigenes YOLO-Modell, anstatt eine Instanz threadübergreifend gemeinsam zu verwenden. Die gemeinsame Nutzung eines einzelnen Modells führt zu Race-Conditions, die seinen internen Zustand beschädigen und unvorhersehbare Ergebnisse erzeugen, weil Pythons Modul threading die Threads gleichzeitig auf demselben Objekt ausführt. Dieser Leitfaden erklärt, warum die gemeinsame Nutzung fehlschlägt, zeigt das sichere Muster mit einer Instanz pro Thread und behandelt den Decorator ThreadingLocked für Fälle, in denen du eine Instanz gemeinsam verwenden musst.

Springe zu warum die gemeinsame Nutzung eines Modells fehlschlägt, zum thread-sicheren Muster oder zum [Decorator ThreadingLocked].

Python-Threading verstehen#

Python-Threads sind eine Form der Parallelisierung, mit der dein Programm mehrere Vorgänge gleichzeitig ausführen kann. Pythons globale Interpretersperre (GIL) bedeutet jedoch, dass immer nur ein Thread Python-Bytecode ausführen kann.

Auch wenn dies nach einer Einschränkung klingt, können Threads weiterhin Nebenläufigkeit ermöglichen, insbesondere bei E/A-gebundenen Vorgängen oder bei Vorgängen, die den GIL freigeben, etwa bei solchen, die von den zugrunde liegenden C-Bibliotheken von YOLO ausgeführt werden.

Die Gefahr gemeinsam genutzter Modellinstanzen#

Wenn du ein YOLO-Modell außerhalb deiner Threads erzeugst und diese Instanz von mehreren Threads gemeinsam verwendet wird, kann dies zu Race-Conditions führen. Dabei wird der interne Zustand des Modells durch gleichzeitige Zugriffe inkonsistent verändert. Das ist besonders problematisch, wenn das Modell oder seine Komponenten einen Zustand halten, der nicht für die Verwendung durch mehrere Threads ausgelegt ist.

Nicht thread-sicheres Beispiel: einzelne Modellinstanz#

Bei der Verwendung von Threads in Python ist es wichtig, Muster zu erkennen, die zu Problemen mit der Nebenläufigkeit führen können. Folgendes solltest du vermeiden: die gemeinsame Nutzung einer einzelnen YOLO26-Modellinstanz durch mehrere Threads.

# Unsafe: Sharing a single model instance across threads
from threading import Thread

from ultralytics import YOLO

# Instantiate the model outside the thread
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)
    # Process results

# Starting threads that share the same model instance
Thread(target=predict, args=("image1.jpg",)).start()
Thread(target=predict, args=("image2.jpg",)).start()

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

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 erzeugt werden – das einzige unsichere Muster ist die gemeinsame Nutzung einer Instanz durch mehrere Threads:

# Safe: each thread uses its own dedicated model instance
from threading import Thread

from ultralytics import YOLO

# Instantiate one model per thread
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)
    # Process results

# Each thread uses a separate, dedicated model instance
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 innerhalb jedes Threads zu erzeugen, wie im Folgenden gezeigt, ist einfach die zuverlässigste Methode, um sicherzustellen, dass eine Instanz niemals versehentlich gemeinsam verwendet wird.

Thread-sichere Inferenz#

Um eine thread-sichere Inferenz durchzuführen, solltest du innerhalb jedes Threads ein eigenes YOLO-Modell erzeugen. Dadurch hat jeder Thread seine eigene isolierte Modellinstanz, wodurch das Risiko von Race-Conditions entfällt.

Thread-sicheres Beispiel#

So erzeugst du für eine sichere parallele Inferenz ein YOLO-Modell innerhalb jedes Threads:

# Safe: Instantiating a single model inside each thread
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)
    # Process results

# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

In diesem Beispiel erzeugt jeder Thread seine eigene YOLO-Instanz. Dadurch kann kein Thread den Modellzustand eines anderen Threads beeinflussen. Somit führt jeder Thread die Inferenz sicher und ohne unerwartete Wechselwirkungen mit den anderen Threads aus.

Verwendung des Decorators ThreadingLocked#

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

from ultralytics import YOLO
from ultralytics.utils import ThreadingLocked

# Create a model instance
model = YOLO("yolo26n.pt")

# Decorate the prediction function to make it thread-safe
@ThreadingLocked()
def thread_safe_predict(image_path):
    """Thread-safe prediction using a shared model instance."""
    results = model.predict(image_path)
    return results

# Now you can safely call this function from multiple threads

Der Decorator ThreadingLocked ist besonders nützlich, wenn du eine Modellinstanz von mehreren Threads gemeinsam verwenden musst, aber sicherstellen möchtest, dass immer nur ein Thread darauf zugreifen kann.

Fazit#

Bei der Verwendung von YOLO-Modellen mit Pythons threading solltest du jedem Thread eine eigene Modellinstanz zuweisen und niemals eine Instanz threadübergreifend gemeinsam verwenden. Das Modell innerhalb des Threads zu erzeugen, der es verwendet, ist die einfachste Methode, dies sicherzustellen, Race-Conditions zu vermeiden und deine Inferenzaufgaben zuverlässig auszuführen.

Für fortgeschrittenere Szenarien und zur weiteren Optimierung der Leistung deiner Inferenz mit mehreren Threads kannst du eine prozessbasierte Parallelisierung mit multiprocessing oder eine Aufgabenwarteschlange mit dedizierten Worker-Prozessen verwenden.

FAQ#