Inferência segura para threads com modelos YOLO#

Para executar inferências do Ultralytics YOLO com segurança em threads Python, instancia um modelo YOLO separado dentro de cada thread, em vez de partilhar 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, pois o módulo threading do Python executa as threads em simultâneo sobre o mesmo objeto. Este guia explica por que motivo a partilha falha, mostra o padrão seguro com uma instância por thread e aborda o decorador ThreadingLocked para os casos em que é necessário partilhar uma instância.

Vai diretamente para o motivo pelo qual a partilha de um modelo falha, o padrão seguro para threads ou 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, sobretudo em operações limitadas por E/S ou quando se usam operações que libertam o GIL, como as executadas pelas bibliotecas C subjacentes ao YOLO.

O perigo de partilhar instâncias de modelos#

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 é especialmente 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: uma única instância de modelo#

Ao usar threads em 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.

# Inseguro: partilhar uma única instância de modelo entre threads
from threading import Thread

from ultralytics import YOLO

# Instanciar o modelo fora da 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)
    # Processa os resultados

# Iniciar threads que partilham a mesma instância de modelo
Thread(target=predict, args=("image1.jpg",)).start()
Thread(target=predict, args=("image2.jpg",)).start()

No exemplo acima, várias threads usam shared_model, o que pode produzir resultados imprevisíveis, pois predict pode ser executado simultaneamente por várias threads.

Exemplo seguro: uma instância dedicada por thread#

É seguro ter várias instâncias de modelo separadas, desde que cada thread seja proprietária da sua instância e nunca a partilhe com outra thread. Não importa que as instâncias abaixo sejam criadas antes de as threads começarem — o único padrão inseguro é partilhar uma instância entre threads:

# Seguro: cada thread usa a sua própria instância de modelo dedicada
from threading import Thread

from ultralytics import YOLO

# Instanciar um modelo por 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)
    # Processa os resultados

# Cada thread usa uma instância de modelo separada e dedicada
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 há estado de modelo partilhado 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 é partilhada acidentalmente.

Inferência segura para threads#

Para executar inferências seguras para threads, deves instanciar um modelo YOLO separado dentro de cada thread. Assim, cada thread terá a sua própria instância de modelo isolada, eliminando o risco de condições de corrida.

Exemplo seguro para threads#

Eis como instanciar um modelo YOLO dentro de cada thread para executar inferências paralelas com segurança:

# Seguro: instanciar um único modelo dentro de cada 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)
    # Processa os resultados

# Inicia threads, cada uma com sua própria instância do modelo
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 uma thread interfira com o estado do modelo de outra e garante que cada thread executa inferências com segurança e sem interações inesperadas com as outras threads.

Usar o decorador ThreadingLocked#

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

from ultralytics import YOLO
from ultralytics.utils import ThreadingLocked

# Criar uma instância de modelo
model = YOLO("yolo26n.pt")

# Aplicar o decorador à função de previsão para a tornar segura para threads
@ThreadingLocked()
def thread_safe_predict(image_path):
    """Thread-safe prediction using a shared model instance."""
    results = model.predict(image_path)
    return results

# Agora podes chamar esta função com segurança a partir de várias threads

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

Conclusão#

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

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

Perguntas frequentes#