Inferência segura para threads com modelos YOLO#

Para executar a inferência do Ultralytics YOLO com segurança em threads Python, instancia um modelo YOLO separado dentro de cada thread, em vez de partilhares uma única instância entre elas. Partilhar um único modelo causa condições de corrida que corrompem o seu estado interno e produzem resultados imprevisíveis, porque o módulo threading do Python executa as threads em simultâneo no mesmo objeto. Este guia explica por que motivo a partilha falha, mostra o padrão seguro por thread e aborda o decorador ThreadingLocked para os casos em que tens de partilhar uma instância.

Avança para por que motivo a partilha de um modelo falha, para o padrão seguro para threads ou para o decorador ThreadingLocked.

Compreender as threads do Python#

As threads do Python são uma forma de paralelismo que permite ao teu programa executar várias operações ao mesmo tempo. No entanto, o Bloqueio Global do Interpretador (GIL) do Python significa que apenas uma thread pode executar bytecode Python de cada vez.

Embora isto pareça uma limitação, as threads ainda podem proporcionar concorrência, especialmente em operações limitadas por E/S ou ao utilizar operações que libertam o GIL, como as executadas pelas bibliotecas C subjacentes do YOLO.

O perigo de instâncias de modelos partilhadas#

Instanciar um modelo YOLO fora das tuas threads e partilhar essa instância entre várias threads pode causar condições de corrida, nas quais o estado interno do modelo é modificado de forma inconsistente devido a acessos simultâneos. Isto é particularmente problemático quando o modelo ou os seus componentes mantêm um estado que não foi concebido para ser seguro para threads.

Exemplo não seguro para threads: instância única do modelo#

Ao utilizar threads no Python, é importante reconhecer os padrões que podem causar problemas de concorrência. Eis o que deves evitar: partilhar uma única instância do modelo YOLO26 entre várias 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()

No exemplo acima, shared_model é utilizado por várias threads, o que pode causar resultados imprevisíveis porque predict pode ser executado simultaneamente por várias threads.

Exemplo seguro: uma instância dedicada por thread#

É perfeitamente aceitável ter várias instâncias de modelos separadas, desde que cada thread seja proprietária da sua instância e nunca a partilhe com outra thread. O facto de as instâncias abaixo serem criadas antes do início das threads não é relevante — o único padrão inseguro é partilhar uma instância entre 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()

Como cada thread trabalha com a sua própria instância dedicada, não existe estado partilhado do modelo que as threads possam corromper. Instanciar o modelo dentro de cada thread, como mostrado a seguir, é simplesmente a forma mais fácil de garantir que uma instância nunca seja partilhada acidentalmente.

Inferência segura para threads#

Para executar inferência de forma segura para threads, deves instanciar um modelo YOLO separado dentro de cada thread. Isto garante que cada thread tem a sua própria instância isolada do modelo, eliminando o risco de condições de corrida.

Exemplo seguro para threads#

Eis como instanciar um modelo YOLO dentro de cada thread para realizar inferência paralela com segurança:

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

Neste exemplo, cada thread cria a sua própria instância YOLO. Isto impede que qualquer thread interfira com o estado do modelo de outra, garantindo assim que cada thread realiza a inferência com segurança e sem interações inesperadas com as outras threads.

Utilizar o decorador ThreadingLocked#

A Ultralytics fornece um decorador ThreadingLocked que pode ser utilizado para garantir a execução segura para threads das funções. Este decorador utiliza um bloqueio para garantir que apenas uma thread de cada vez possa executar a função decorada.

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

O decorador ThreadingLocked é particularmente útil quando precisas de partilhar uma instância de modelo entre threads, mas queres garantir que apenas uma thread lhe possa aceder de cada vez.

Conclusão#

Ao utilizar modelos YOLO com threading do Python, atribui a cada thread a sua própria instância dedicada do modelo e nunca partilhes uma instância entre threads. Instanciar o modelo dentro da thread que o utiliza é a forma mais simples de garantir isto, evitando condições de corrida e mantendo a fiabilidade das tuas tarefas de inferência.

Para cenários mais avançados e para otimizar ainda mais o desempenho da inferência multithread, considera utilizar paralelismo baseado em processos com multiprocessing ou uma fila de tarefas com processos de trabalho dedicados.

Perguntas frequentes#