Começar

Rastreamento de múltiplos objetos com Ultralytics YOLO

YOLO multi-object tracking with trajectory paths

O rastreamento de vários objetos em análise de vídeo identifica a localização e a classe dos objetos em cada quadro e também mantém um ID exclusivo para cada objeto detectado à medida que o vídeo avança. As aplicações vão da vigilância e segurança à análise esportiva em tempo real.

Consulta a pré-visualização não lançada do YOLO27 para saber mais sobre o suporte de rastreamento planeado.

Rastreadores: OC-SORT, Deep OC-SORT, FastTracker, TrackTrack

A partir de ultralytics 8.4.63, OC-SORT, Deep OC-SORT, FastTracker e TrackTrack estão disponíveis juntamente com BoT-SORT e ByteTrack.

Porquê escolher Ultralytics YOLO para o rastreamento de objetos?#

A saída dos rastreadores do Ultralytics é consistente com a detecção de objetos padrão, mas inclui IDs dos objetos. Isso facilita rastrear objetos em transmissões de vídeo e realizar análises posteriores. Principais motivos para usar Ultralytics YOLO no rastreamento de objetos:

  • Eficiência: Processa fluxos de vídeo em tempo real sem comprometer a precisão.
  • Flexibilidade: Compatível com vários algoritmos de rastreamento e configurações.
  • Facilidade de utilização: API Python e opções de CLI simples para integração e implementação rápidas.
  • Personalização: Fácil de usar com modelos YOLO treinados de forma personalizada, permitindo a integração em aplicações específicas de cada domínio.


Assista: Como executar rastreamento de múltiplos objetos com Ultralytics YOLO26 | BoT-SORT e ByteTrack | VisionAI 🚀

Aplicações no mundo real#

TransportesRetalhoAquacultura
Rastreamento de veículosRastreamento de pessoasRastreamento de peixes

Início rápido#

Executa o rastreamento num vídeo com o rastreador TrackTrack predefinido. Muda para outro rastreador alterando o argumento tracker.

Exemplo
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Rastreador predefinido (TrackTrack)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

# Mudar para ByteTrack
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

Para executar o rastreador em transmissões de vídeo, usa um modelo treinado Detect, Segment, Pose ou OBB, como YOLO26n, YOLO26n-seg, YOLO26n-pose ou YOLO26n-obb, todos disponíveis na coleção YOLO26 na Ultralytics Platform. Podes treinar modelos personalizados localmente ou usando o treinamento na nuvem da Ultralytics Platform.

Exemplo
from ultralytics import YOLO

# Carrega um modelo oficial ou personalizado
model = YOLO("yolo26n.pt")  # Carrega um modelo oficial de deteção
model = YOLO("yolo26n-seg.pt")  # Carrega um modelo oficial de segmentação
model = YOLO("yolo26n-pose.pt")  # Carrega um modelo oficial de pose
model = YOLO("path/to/best.pt")  # Carrega um modelo treinado de forma personalizada

# Executa o rastreamento com o modelo
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Rastreamento com o rastreador predefinido
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # com ByteTrack

Rastreadores compatíveis#

Ultralytics YOLO inclui seis rastreadores integrados. Ativa um deles indicando o respetivo ficheiro de configuração YAML no argumento tracker.

RastreadorFicheiro de configuraçãoModelo de movimentoAparência / ReIDCompensação do movimento da câmaraGestão de oclusões
BoT-SORTbotsort.yamlKalman linearOpcional (with_reid)Configurável (gmc_method)Buffer de rastreamento + reassociação ReID
ByteTrackbytetrack.yamlKalman linearNenhumNãoRecuperação em duas etapas de deteções com baixa confiança
OC-SORTocsort.yamlKalman centrado na observaçãoNenhumNãoORU, OCM, OCR: atualização a partir da última observação
Deep OC-SORTdeepocsort.yamlKalman centrado na observaçãoOpcional (with_reid)Configurável (gmc_method)OC-SORT + EMA de aparência adaptativa opcional
FastTrackerfasttrack.yamlKalman linear + reversãoNenhumNãoReversão de Kalman + ampliação da bbox durante oclusões
TrackTracktracktrack.yamlKalman linear (NSA)Opcional (with_reid)Configurável (gmc_method)Associação iterativa com múltiplas pistas + TAI

Que rastreador devo usar?#

Usa este fluxo para escolher um ponto de partida; utiliza-se tracktrack.yaml quando não indicas tracker:

  1. Precisas da opção mais rápida e simples? → ByteTrack (sem ReID, sem compensação do movimento da câmara, sobrecarga mínima).
  2. Vídeos captados à mão, por drone ou com câmara em movimento? → BoT-SORT (acrescenta compensação do movimento da câmara e ReID opcional).
  3. Movimento não linear (desporto, dança, mudanças bruscas de direção) e sem ReID? → OC-SORT (correções centradas na observação sem custos de aparência).
  4. Cenas concorridas com câmara em movimento, em que as trocas de ID são o principal problema? → Deep OC-SORT ou TrackTrack (ambos permitem correspondência de aparência opcional; TrackTrack também acrescenta associação com múltiplas pistas e supressão de IDs duplicados).
  5. Sobreposições parciais frequentes em tempo real, sem margem para ReID? → FastTracker (variante do ByteTrack sensível a oclusões, com reversão de Kalman).

Mudar de rastreador#

Indica o nome do ficheiro de configuração do rastreador em tracker=. Todo o restante código permanece igual.

Exemplo
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

results = model.track(source="path/to/video.mp4", tracker="bytetrack.yaml")
results = model.track(source="path/to/video.mp4", tracker="ocsort.yaml")
results = model.track(source="path/to/video.mp4", tracker="tracktrack.yaml")

Configuração#

Argumentos de rastreamento#

A configuração de rastreamento compartilha argumentos de inferência com o modo Predict, como conf, iou e show.

Exemplo
from ultralytics import YOLO

# Configura os parâmetros de rastreamento e executa o rastreador
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.5, show=True)

Configuração personalizada do rastreador#

Para usar uma configuração de rastreador modificada, copia um arquivo de configuração de rastreador (por exemplo, como custom_tracker.yaml) de ultralytics/cfg/trackers e modifica qualquer configuração, exceto tracker_type.

Exemplo
from ultralytics import YOLO

# Carrega o modelo e executa o rastreador com um ficheiro de configuração personalizado
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Argumentos comuns dos rastreadores#

Os parâmetros seguintes são comuns à maioria dos ficheiros YAML dos rastreadores; nem todos aparecem em todas as configurações:

Informações sobre os limiares do rastreador

As deteções com valor igual ou superior a track_high_thresh entram na primeira etapa de associação. As deteções com valores entre track_low_thresh e track_high_thresh podem recuperar rastreamentos existentes quando o rastreador selecionado permite a associação de baixa confiança, mas não iniciam novos rastreamentos. As deteções com valor igual ou inferior a track_low_thresh são ignoradas.

ParâmetroValores ou intervalos válidosDescrição
tracker_typebotsort, bytetrack, ocsort, deepocsort, fasttrack, tracktrackEspecifica o tipo de rastreador.
track_high_thresh0.0-1.0Limiar para a primeira associação. Afeta o grau de confiança com que uma detecção é associada a uma trilha existente.
track_low_thresh0.0-1.0Limite inferior para detecções de recuperação com baixa confiança. OC-SORT e Deep OC-SORT usam essas detecções somente quando use_byte: True; TrackTrack as inclui no conjunto de associações penalizadas.
new_track_thresh0.0-1.0Limiar para inicializar uma nova trilha quando a detecção não corresponde a nenhuma trilha existente.
track_buffer>=0Número de quadros durante os quais trilhas perdidas são mantidas ativas antes da remoção. Um valor maior significa mais tolerância à oclusão.
match_thresh0.0-1.0Limiar para associar trilhas. Valores maiores tornam a associação mais permissiva.
fuse_scoreTrue, FalseIndica se as pontuações de confiança devem ser combinadas com as distâncias de IoU antes da associação.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMétodo de compensação global de movimento. Ajuda a levar em conta o movimento da câmera.
proximity_thresh0.0-1.0IoU mínimo necessário para uma correspondência ReID válida. Garante proximidade espacial antes de usar pistas de aparência.
appearance_thresh0.0-1.0Similaridade mínima de aparência normalizada necessária para ReID.
with_reidTrue, FalseAtiva a associação baseada em aparência para melhorar o rastreamento durante oclusões. Compatível com BoT-SORT, Deep OC-SORT e TrackTrack.
modelauto ou caminho para um modelo ReID compatívelModelo ReID. auto usa recursos nativos do backbone YOLO quando disponíveis; caso contrário, recorre a yolo26n-cls.pt. Um codificador personalizado pode ser um checkpoint .pt ou um modelo exportado, como .torchscript, .onnx, .engine ou um diretório de modelo OpenVINO.

Argumentos específicos do rastreador#

Cada algoritmo oferece parâmetros adicionais além dos parâmetros compartilhados. Consulte as seções de cada rastreador abaixo para ver as descrições e recomendações de ajuste, ou consulte diretamente os arquivos de configuração:

Ativar a reidentificação (ReID)#

O ReID fica desativado por padrão para minimizar a sobrecarga. Ativa-o definindo with_reid: True em um arquivo de configuração de rastreador.

Opções de modelo ReID:

  • model: auto — Usa recursos nativos do detector YOLO, com sobrecarga mínima. Ideal quando você precisa de alguma ReID sem grande impacto no desempenho. Recorre a yolo26n-cls.pt se o detector não disponibilizar recursos compatíveis.
  • Modelo ReID personalizado — Defina model: como um checkpoint .pt ou como um modelo de incorporação exportado compatível, como .torchscript, .onnx, .engine ou um diretório de modelo OpenVINO. Os modelos exportados são carregados por meio de AutoBackend e devem gerar diretamente um tensor de incorporação.

Há codificadores ONNX prontos para uso publicados para todos os tamanhos de modelo. Defina model: como um desses nomes e o arquivo será baixado automaticamente na primeira execução do rastreador (da mesma forma que os pesos YOLO são obtidos) — não é necessário exportar nem baixar manualmente:

# In your tracker config (e.g. tracktrack.yaml)
with_reid: True
model: yolo26n-reid.onnx # downloaded on first use; swap n→s/m/l/x for a larger encoder
Modelotamanho
(pixels)
parâmetros
(M)
FLOPs
(B)
YOLO26n-reid.onnx4482.82.0
YOLO26s-reid.onnx4487.56.6
YOLO26m-reid.onnx44812.420.1
YOLO26l-reid.onnx44815.325.2
YOLO26x-reid.onnx44832.755.9
A ReID é exclusiva do rastreamento

Atualmente, só há codificadores ReID ONNX disponíveis para o ramo de aparência do rastreador. Os modos ReID train, val e predict, assim como receitas dedicadas para exportação ReID, ainda estão em desenvolvimento.

Para obter melhor desempenho com um modelo de classificação separado, exporte-o para um back-end mais rápido, como TensorRT:

Exportar um modelo ReID para TensorRT
from torch import nn

from ultralytics import YOLO

# Carrega o modelo de classificação
model = YOLO("yolo26n-cls.pt")

# Adiciona uma camada de pooling médio
head = model.model.model[-1]
pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(start_dim=1))
pool.f, pool.i = head.f, head.i
model.model.model[-1] = pool

# Exporta para TensorRT
model.export(format="engine", quantize=16, dynamic=True, batch=32)

Depois de exportar, indique o caminho do modelo TensorRT na configuração do rastreador.

Detalhes dos rastreadores#

As seções abaixo descrevem o projeto de cada rastreador, seus parâmetros específicos e dicas de ajuste.



Assista: Qual rastreador de objetos tem melhor desempenho? | Velocidade, FPS e estabilidade de ID | Ultralytics YOLO26 📊

BoT-SORT#

BoT-SORT (Aharon et al., 2022) amplia o ByteTrack com compensação do movimento da câmera e ReID opcional:

  • Compensação do movimento da câmera (CMC): aplica-se aos estados de Kalman, antes da associação por IoU, uma transformação afim estimada a cada quadro (por padrão, fluxo óptico esparso; ORB/ECC também estão disponíveis).
  • ReID opcional: as incorporações de aparência podem ser combinadas na matriz de custos. Desativada por padrão; ative com with_reid: True.

Ideal para: rastreamento de uso geral, especialmente com câmeras em movimento. Adicione ReID somente quando multidões com aparência semelhante causarem trocas de ID.

Argumentos específicos do BoT-SORT:

ParâmetroValores ou intervalos válidosDescrição
gmc_methodsparseOptFlow, orb, sift, ecc, noneBack-end para compensação do movimento da câmera. sparseOptFlow é o padrão. none desativa a CMC.
with_reidTrue, FalseAtiva a associação baseada em aparência. Desativada por padrão.
modelauto ou caminho para um modelo ReID compatívelauto usa recursos nativos do YOLO quando disponíveis; os modelos personalizados podem ser checkpoints .pt ou exportações compatíveis.
proximity_thresh0.0-1.0IoU mínimo para considerar os recursos de aparência.
appearance_thresh0.0-1.0Similaridade mínima de aparência normalizada necessária para uma correspondência ReID. Aumente o valor para tornar a associação mais rigorosa.

Dicas de ajuste:

  • Câmera estática: defina gmc_method: none para economizar alguns ms/quadro.
  • Muito movimento da câmera: mantenha sparseOptFlow; ecc é mais preciso, mas mais lento.
  • Multidões com aparência semelhante: ative with_reid: True e aumente appearance_thresh (por exemplo, 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) é a referência leve. Usa Kalman linear + IoU com uma associação em duas etapas:

  • Etapa 1: associa detecções com pontuações altas às trilhas ativas.
  • Etapa 2: tenta novamente associar as trilhas não associadas às detecções com pontuações baixas para recuperá-las após oclusões parciais breves.

Não há modelo de aparência nem compensação do movimento da câmera.

Ideal para: câmeras estáticas ou quase estáticas, nas quais o custo do detector predomina e você quer minimizar a sobrecarga do rastreador.

Argumentos específicos do ByteTrack: nenhum além dos argumentos compartilhados do rastreador.

Dicas de ajuste:

  • Detector ruidoso: diminua track_low_thresh para que a segunda etapa tenha mais candidatos.
  • Detector com alta cobertura: aumente track_high_thresh para reduzir a fragmentação dos IDs.
  • Oscilações frequentes de ID: aumente track_buffer para que as trilhas perdidas brevemente persistam.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) é uma extensão do SORT centrada nas observações. Mantém o projeto leve do SORT (sem recursos de aparência) e adiciona três correções:

  • Reatualização centrada na observação (ORU): reproduz uma trajetória virtual entre a última observação e a detecção atual, executando novamente a atualização de Kalman para corrigir a velocidade desviada.
  • Momentum centrado na observação (OCM): penaliza detecções que se movem na direção errada por meio de um termo de consistência da velocidade.
  • Recuperação centrada na observação (OCR): verifica novamente as detecções não associadas em relação às trilhas perdidas recentemente, usando a última observação em vez do estado previsto.

Ideal para: movimento não linear sem o custo de um modelo ReID.

Argumentos específicos do OC-SORT:

ParâmetroValores ou intervalos válidosDescrição
delta_t>=1Janela temporal (em quadros) para calcular a direção da velocidade no OCM. Valores maiores suavizam mais.
inertia0.0-1.0Peso do custo de consistência da velocidade. Valores maiores penalizam mudanças bruscas de direção.
use_byteTrue, FalseAtiva uma segunda etapa de associação, no estilo ByteTrack, para detecções com baixa confiança.

Dicas de ajuste:

  • Movimento não linear: aumente inertia (por exemplo, 0.3-0.4).
  • Detecções esparsas: ative use_byte: True.
  • Oclusões longas: aumente track_buffer para que a OCR tenha mais trilhas perdidas para reassociar.

Com modelos OBB, a OCR usa a caixa orientada prevista pelo Kalman, pois o histórico da última observação orientada não é mantido.

Deep OC-SORT#

Deep OC-SORT amplia o OC-SORT com informações de aparência e compensação do movimento da câmera:

  • Associação por aparência: a distância de incorporação por cosseno é limitada pela sobreposição e combinada com o custo de movimento.
  • EMA dinâmica da aparência: as incorporações das trilhas são atualizadas com uma EMA cujo fator de suavização se adapta à confiança da detecção.
  • Compensação do movimento da câmera: os estados de Kalman são transformados entre quadros por meio de fluxo óptico esparso, ORB ou ECC.

Ideal para: cenas lotadas ou com câmeras em movimento, nas quais são comuns trocas de ID entre objetos visualmente diferentes, mas espacialmente próximos.

Argumentos específicos do Deep OC-SORT:

ParâmetroValores ou intervalos válidosDescrição
with_reidTrue, FalseAtiva a associação baseada em aparência. Desativada por padrão.
modelauto ou caminho para um modelo ReID compatívelauto usa recursos nativos do YOLO quando disponíveis; os modelos personalizados podem ser checkpoints .pt ou exportações compatíveis.
proximity_thresh0.0-1.0IoU mínimo para considerar os recursos de aparência.
appearance_thresh0.0-1.0Similaridade mínima de aparência normalizada necessária para uma correspondência ReID.
alpha_fixed_emb0.0-1.0Fator EMA base para atualizações das incorporações das trilhas. Valores maiores preservam por mais tempo a incorporação antiga.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMétodo de compensação global de movimento.
delta_t>=1Janela temporal (em quadros) para calcular a direção da velocidade no OCM (herdada do OC-SORT).
inertia0.0-1.0Peso do custo de consistência da velocidade (herdado do OC-SORT).
use_byteTrue, FalseAtiva uma segunda etapa de associação, no estilo ByteTrack, para detecções com baixa confiança (herdada do OC-SORT).

Dicas de ajuste:

  • Trocas de identidade em multidões: aumente appearance_thresh (por exemplo, 0.92-0.95) e aumente alpha_fixed_emb para que as incorporações se adaptem mais lentamente.
  • Câmera em movimento: defina gmc_method: sparseOptFlow (o padrão do Deep OC-SORT é none).
  • Menor latência: mantenha with_reid: False (padrão) apenas para movimento + CMC; ative ReID somente quando as trocas de ID forem a principal fonte de erros.

FastTracker#

FastTracker é uma variante do ByteTrack que leva as oclusões em conta e não usa modelo de aparência:

  • Detecção de oclusão: sinaliza trilhas como oclusas quando a cobertura por outras trilhas ativas excede occ_cover_thresh.
  • Reversão de Kalman em caso de oclusão: reverte o estado de Kalman para um quadro anterior à oclusão usando um histórico armazenado em buffer circular.
  • Redução do movimento e ampliação da busca: a velocidade é reduzida e a bbox prevista é ampliada enquanto há oclusão.
  • Supressão Init-IoU: impede a criação de novas trilhas sobre trilhas ativas.

Ideal para: pipelines de detecção em tempo real sem rastreamento que apresentam sobreposição frequente entre alvos (multidões, filas, esportes).

Argumentos específicos do FastTracker:

ParâmetroValores ou intervalos válidosDescrição
reset_velocity_offset_occ>=0Número de frames anteriores a recuperar para restaurar a velocidade de Kalman no início da oclusão.
reset_pos_offset_occ>=0Número de frames anteriores a recuperar para restaurar a posição de Kalman no início da oclusão.
enlarge_bbox_occ>=1.0Escala de altura aplicada à bbox prevista durante a oclusão (a largura é escalada pela proporção XYAH).
dampen_motion_occ0.0-1.0Multiplicador de velocidade durante a oclusão. Valores menores fazem o rastreamento "abrandar" durante a oclusão.
active_occ_to_lost_thresh>=1Número máximo de frames consecutivos de oclusão antes de mover um rastreamento ativo para o estado perdido.
occ_cover_thresh0.0-1.0Fração da área de um rastreamento coberta por outro rastreamento ativo para declarar uma oclusão.
occ_reappear_window>=0Número de frames durante os quais um rastreamento perdido recentemente ocluído permanece preferencialmente localizável de novo.
init_iou_suppress0.0-1.0Suprime a inicialização de um novo rastreamento se o IoU dele com qualquer rastreamento ativo exceder este valor. Defina como 1.0 para desativar.

Dicas de ajuste:

  • Oclusões parciais frequentes: reduza occ_cover_thresh (por exemplo, 0.5-0.6).
  • IDs duplicados perto de sobreposições: reduza init_iou_suppress (por exemplo, 0.5).
  • Oclusões longas: aumente occ_reappear_window e track_buffer em conjunto.
  • Alvos em movimento rápido: aumente dampen_motion_occ (aproximando-o de 1.0); aumente enlarge_bbox_occ apenas quando uma região de busca mais ampla melhorar a recuperação.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) é o rastreador padrão. Ele raciocina a partir da perspectiva de cada rastreamento com associação iterativa baseada em múltiplas pistas:

  • Associação baseada na perspectiva do rastreamento (TPA): combina HMIoU, distância ReID de cosseno opcional, distância de projeção de confiança e distância de ângulo de canto. A atribuição é resolvida iterativamente com um limiar que vai sendo relaxado.
  • Inicialização com reconhecimento do rastreamento (TAI): suprime a criação de rastreamentos duplicados antes da criação de um novo ID.

Ideal para: cenas lotadas com oclusões frequentes, nas quais IDs duplicados são um problema.

Argumentos específicos do TrackTrack:

ParâmetroValores ou intervalos válidosDescrição
iou_weight0.0-1.0Peso da distância HMIoU quando o ReID está ativado; caso contrário, o HMIoU é usado diretamente.
reid_weight0.0-1.0Peso da distância ReID de cosseno quando o ReID está ativado; caso contrário, ela é ignorada.
conf_weight0.0-1.0Peso da distância de projeção de confiança.
angle_weight0.0-1.0Peso da distância de ângulo de canto.
penalty_p0.0-1.0Penalidade de custo para detecções de baixa confiança.
penalty_q0.0-1.0Penalidade de custo para detecções recuperadas pelo NMS secundário.
reduce_step0.0-1.0Relaxamento do limiar de correspondência por iteração.
tai_thr0.0-1.0Limiar de IoU para o NMS da inicialização com reconhecimento do rastreamento.
min_track_len>=0Comprimento mínimo do histórico antes de confirmar um novo rastreamento.
lost_match_thr0.0-1.0Limite de custo mais permissivo para a etapa de reassociação de rastreamentos perdidos com limiar relaxado; 0 desativa essa etapa.
with_reidTrue, FalseAtiva a correspondência de aparência com ReID de cosseno (usa as características nativas do YOLO). Desativada por padrão.
modelauto ou caminho para um modelo ReID compatívelauto usa recursos nativos do YOLO quando disponíveis; os modelos personalizados podem ser checkpoints .pt ou exportações compatíveis.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMétodo de compensação global de movimento.

Dicas de ajuste:

  • Pedestres em cenas lotadas: reduza tai_thr (por exemplo, 0.45) para suprimir mais criações duplicadas; aumente track_buffer para oclusões mais longas.
  • Movimento rápido da câmera: mantenha gmc_method: sparseOptFlow ativado.
  • Objetos pequenos/em movimento rápido: aumente ligeiramente angle_weight e reduza min_track_len.
  • Ative o ReID apenas quando necessário: ele aumenta o custo de inferência; para oclusões curtas, o custo padrão baseado em múltiplas pistas costuma ser suficiente.

Com modelos de Segmentação e Pose, o TrackTrack ignora a recuperação de detecções com NMS permissivo para manter as máscaras e os pontos-chave alinhados com as respetivas detecções.

Exemplos em Python#



Assista: Como criar um sistema interativo de rastreamento de objetos com Ultralytics YOLO26: crie em minutos | Python!

Loop para persistir os rastreamentos#

Segue um script Python que usa OpenCV (cv2) e YOLO26 para rastrear objetos em frames de vídeo. Este script pressupõe que os pacotes necessários (opencv-python e ultralytics) já estão instalados. O argumento persist=True informa o rastreador de que a imagem ou o frame atual é o próximo de uma sequência e de que deve esperar encontrar na imagem atual rastreamentos da imagem anterior.

Como persistir rastreamentos e selecionar um rastreador

Use persist=True apenas ao passar frames consecutivos do mesmo fluxo de vídeo para model.track(). Isso permite que o rastreador reutilize o estado de frames anteriores e mantenha IDs de rastreamento consistentes ao longo do tempo. Não use persist=True com imagens não relacionadas ou com outro fluxo, pois o estado anterior do rastreamento pode ser mantido.

Também podes escolher um backend de rastreador passando um ficheiro de configuração do rastreador, como tracker="botsort.yaml", tracker="bytetrack.yaml" ou tracker="tracktrack.yaml".

Loop for com streaming e rastreamento
import cv2

from ultralytics import YOLO

# Carrega o modelo YOLO26
model = YOLO("yolo26n.pt")

# Abre o arquivo de vídeo
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Percorre os quadros do vídeo
while cap.isOpened():
    # Lê um quadro do vídeo
    success, frame = cap.read()

    if success:
        # Executa o rastreamento YOLO26 no frame, persistindo os rastreamentos entre frames
        # e usando o backend de rastreador BoT-SORT
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # Visualiza os resultados no quadro
        annotated_frame = results[0].plot()

        # Exibe o quadro anotado
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # Interrompe o loop se 'q' for pressionado
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrompe o loop se o vídeo chegar ao fim
        break

# Libera o objeto de captura de vídeo e fecha a janela de exibição
cap.release()
cv2.destroyAllWindows()

Observa a alteração de model(frame) para model.track(frame), que ativa o rastreamento de objetos em vez da detecção simples. Este script modificado executará o rastreador em cada quadro do vídeo, visualizará os resultados e os exibirá em uma janela. Podes sair do loop pressionando 'q'.

Representar os rastreamentos ao longo do tempo#

Visualizar as trajetórias dos objetos em quadros consecutivos pode fornecer informações valiosas sobre os padrões de movimento e o comportamento dos objetos detectados em um vídeo. O Ultralytics YOLO26 facilita a plotagem dessas trajetórias.

O exemplo a seguir usa o rastreamento do YOLO26 para plotar o movimento dos objetos detectados em vários quadros de vídeo. O script abre um arquivo de vídeo, lê o conteúdo quadro a quadro e usa o modelo YOLO para identificar e rastrear objetos. Ao guardar os pontos centrais das caixas delimitadoras detectadas e conectá-los, o script desenha linhas que representam os caminhos percorridos pelos objetos rastreados.

Representação dos rastreamentos em vários frames de vídeo
from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Carrega o modelo YOLO26
model = YOLO("yolo26n.pt")

# Abre o arquivo de vídeo
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Armazena o histórico do rastreamento
track_history = defaultdict(list)

# Percorre os quadros do vídeo
while cap.isOpened():
    # Lê um quadro do vídeo
    success, frame = cap.read()

    if success:
        # Executa o rastreamento YOLO26 no frame, persistindo os rastreamentos entre frames
        result = model.track(frame, persist=True)[0]

        # Obtém as caixas e os IDs de rastreamento
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Visualiza o resultado no frame
            frame = result.plot()

            # Representa os rastreamentos
            for box, track_id in zip(boxes, track_ids):
                x, y, w, h = box
                track = track_history[track_id]
                track.append((float(x), float(y)))  # ponto central x, y
                if len(track) > 30:  # mantém 30 rastreamentos durante 30 frames
                    track.pop(0)

                # Desenha as linhas de rastreamento
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Exibe o quadro anotado
        cv2.imshow("YOLO26 Tracking", frame)

        # Interrompe o loop se 'q' for pressionado
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrompe o loop se o vídeo chegar ao fim
        break

# Libera o objeto de captura de vídeo e fecha a janela de exibição
cap.release()
cv2.destroyAllWindows()

Rastreamento multithread#

O rastreamento multithread permite executar o rastreamento de objetos em várias transmissões de vídeo simultaneamente. Isso é especialmente útil ao lidar com várias entradas de vídeo, como as de várias câmeras de vigilância, pois o processamento concorrente aumenta a capacidade de processamento.

O script Python abaixo usa o módulo threading do Python para executar várias instâncias do rastreador simultaneamente. Cada thread executa o rastreador em uma fonte de vídeo, e todas as threads são executadas ao mesmo tempo em segundo plano.

Para garantir que cada thread receba os parâmetros corretos (o modelo a usar e a origem do vídeo), o script define uma função run_tracker_in_thread que aceita esses parâmetros e contém o loop principal de rastreamento. Essa função lê o vídeo quadro a quadro, executa o rastreador e salva os resultados anotados.

Este exemplo usa dois modelos diferentes, yolo26n.pt e yolo26n-seg.pt, cada um rastreando objetos em uma origem diferente: um arquivo de vídeo local e uma webcam. As origens são especificadas em SOURCES.

O parâmetro daemon=True em threading.Thread significa que estas threads serão fechadas assim que o programa principal terminar. Em seguida, iniciamos as threads com start() e usamos join() para fazer a thread principal aguardar até que ambas as threads do rastreador terminem.

Por fim, depois de todas as threads concluírem a tarefa, as janelas que apresentam os resultados são fechadas com cv2.destroyAllWindows().

Implementação de rastreamento multithread
import threading

import cv2

from ultralytics import YOLO

# Define os nomes dos modelos e as fontes de vídeo
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # vídeo local, 0 para webcam

def run_tracker_in_thread(model_name, filename):
    """Run YOLO tracker in its own thread for concurrent processing.

    Args:
        model_name (str): Model checkpoint name or path loaded inside the thread.
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
    """
    model = YOLO(model_name)
    results = model.track(filename, save=True, stream=True)
    for r in results:
        pass

# Cria e inicia threads do rastreador usando um loop for
tracker_threads = []
for video_file, model_name in zip(SOURCES, MODEL_NAMES):
    thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True)
    tracker_threads.append(thread)
    thread.start()

# Aguarda que todas as threads do rastreador terminem
for thread in tracker_threads:
    thread.join()

# Limpa e fecha as janelas
cv2.destroyAllWindows()

Este exemplo pode ser facilmente ampliado para processar mais ficheiros de vídeo e modelos, criando mais threads e aplicando a mesma metodologia.

Contribui com novos rastreadores#

Se você implementou ou adaptou um algoritmo de rastreamento de múltiplos objetos para Ultralytics YOLO, considere contribuir com ele em ultralytics/trackers, incluindo uma configuração correspondente em ultralytics/cfg/trackers. As contribuições ampliam as opções de rastreamento disponíveis para toda a comunidade.

Perguntas frequentes#

  • O rastreamento de vários objetos em análise de vídeo envolve identificar objetos e manter um ID único para cada objeto detetado ao longo dos frames do vídeo. O Ultralytics YOLO suporta esta funcionalidade ao fornecer rastreamento em tempo real juntamente com IDs de objetos, facilitando tarefas como vigilância de segurança e análise desportiva. O sistema usa rastreadores como BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker e TrackTrack, que podem ser configurados através de ficheiros YAML.

  • Não. Os ficheiros padrão .pt do Ultralytics armazenam os pesos do modelo YOLO, enquanto o rastreador é criado no momento da inferência por model.track(). Os IDs de rastreamento dependem do estado do rastreador ao longo de frames consecutivos; por isso, uma única imagem autónoma pode devolver deteções, como caixas, classes e níveis de confiança, mas não pode produzir por si só IDs de rastreamento persistentes com significado.

    Para a implementação, inclui o detetor e o rastreador na tua aplicação e chama model.track() frame a frame com persist=True quando os frames vierem do mesmo fluxo de vídeo. Usa instâncias separadas do modelo ou do rastreador para fluxos não relacionados, para que o estado não transite de um vídeo para outro.

  • Podes configurar um rastreador personalizado copiando um ficheiro de configuração de rastreador existente (por exemplo, custom_tracker.yaml) do diretório de configuração de rastreadores do Ultralytics e modificando os parâmetros conforme necessário, exceto tracker_type. Usa este ficheiro no teu modelo de rastreamento da seguinte forma:

    Exemplo
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")
  • Para executar o rastreamento de objetos em vários fluxos de vídeo em simultâneo, podes usar o módulo threading do Python. Cada thread processa um fluxo de vídeo separado. Segue um exemplo de como podes configurar isto:

    Rastreamento multithread
    import threading
    
    import cv2
    
    from ultralytics import YOLO
    
    # Define os nomes dos modelos e as fontes de vídeo
    MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
    SOURCES = ["path/to/video.mp4", "0"]  # vídeo local, 0 para webcam
    
    def run_tracker_in_thread(model_name, filename):
        """Run YOLO tracker in its own thread for concurrent processing.
    
        Args:
            model_name (str): Model checkpoint name or path loaded inside the thread.
            filename (str): The path to the video file or the identifier for the webcam/external camera source.
        """
        model = YOLO(model_name)
        results = model.track(filename, save=True, stream=True)
        for r in results:
            pass
    
    # Cria e inicia threads do rastreador usando um loop for
    tracker_threads = []
    for video_file, model_name in zip(SOURCES, MODEL_NAMES):
        thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True)
        tracker_threads.append(thread)
        thread.start()
    
    # Aguarda que todas as threads do rastreador terminem
    for thread in tracker_threads:
        thread.join()
    
    # Limpa e fecha as janelas
    cv2.destroyAllWindows()
  • O rastreamento de vários objetos com o Ultralytics YOLO tem inúmeras aplicações, incluindo:

    • Transportes: rastreamento de veículos para gestão de tráfego e condução autónoma.
    • Retalho: rastreamento de pessoas para análise em lojas e segurança.
    • Aquacultura: rastreamento de peixes para monitorizar ambientes aquáticos.
    • Análise desportiva: rastreamento de jogadores e equipamento para análise de desempenho.
    • Sistemas de segurança: monitorização de atividades suspeitas e criação de alarmes de segurança.

    Essas aplicações se beneficiam da capacidade do Ultralytics YOLO de processar vídeos com alta taxa de quadros em tempo real e com alta precisão.

  • Para visualizar os rastreamentos de objetos ao longo de vários frames de vídeo, podes usar os recursos de rastreamento do modelo YOLO juntamente com OpenCV para desenhar os percursos dos objetos detetados. Segue um script de exemplo que demonstra como fazer isso:

    Representação dos rastreamentos em vários frames de vídeo
    from collections import defaultdict
    
    import cv2
    import numpy as np
    
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    video_path = "path/to/video.mp4"
    cap = cv2.VideoCapture(video_path)
    track_history = defaultdict(list)
    
    while cap.isOpened():
        success, frame = cap.read()
        if success:
            result = model.track(frame, persist=True)[0]
            annotated_frame = result.plot()
            if result.boxes and result.boxes.is_track:
                boxes = result.boxes.xywh.cpu()
                track_ids = result.boxes.id.int().cpu().tolist()
                for box, track_id in zip(boxes, track_ids):
                    x, y, w, h = box
                    track = track_history[track_id]
                    track.append((float(x), float(y)))
                    if len(track) > 30:
                        track.pop(0)
                    points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                    cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
            cv2.imshow("YOLO26 Tracking", annotated_frame)
            if cv2.waitKey(1) & 0xFF == ord("q"):
                break
        else:
            break
    cap.release()
    cv2.destroyAllWindows()

    Este script representa as linhas de rastreamento que mostram os percursos de movimento dos objetos rastreados ao longo do tempo, fornecendo informações valiosas sobre o comportamento e os padrões dos objetos.

Comentários679

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  1. bhaskar2443053GitHub

    I’m using YOLO-Pose to detect and track people throughout ~1-hour videos and need each person to keep the same ID. I already have high-quality ground-truth tracks from a SAM-based tracker.

    Do you have a script that can fine-tune YOLO-Pose (and its tracker/Re-ID parameters) against this ground truth to squeeze out the best IDF1 or HOTA scores ?

    1
    1. maxexplorerGitHub

      Hi!

      Thank you for your great work on YOLO and tracking integration. We are using YOLO with ByteTrack/BoT-SORT for object counting and tracking and want to improve ID stability.

      1. We notice that sometimes, even when the object visually looks the same and the scene and motion are stable, the track_id changes. What parameters or reasons should we check to understand why the ID changes unexpectedly?

      2. Is the match_thresh parameter based on IoU, and is it possible to print or visualize the IoU used during matching for debugging?

      3. Is there a way to output Kalman-predicted boxes of lost tracks so we can analyze them?

      4. Could increasing the video FPS improve tracking and IoU consistency, or is this mainly related to detection stability and parameter tuning?

      5. Does ByteTrack or BoT-SORT use a min_hits parameter before confirming tracks, or are tracks confirmed immediately after creation?

      6. If a track is lost, can a new ID only be assigned on the second frame after reappearance if conf > new_track_thresh and then conf > track_high_thresh, or can it happen immediately on the first detection?

      7. Is the track_buffer parameter the number of frames a track is kept using Kalman prediction after it is lost before being deleted?

      8. Do you have any tips to improve tracking stability and avoid unnecessary ID switches?

      Thank you for your support!

    2. Glenn JocherUltralytics

      @bhaskar2443053 currently there isn't a built-in script for fine-tuning YOLO-Pose tracking parameters against ground truth. You would need to implement custom evaluation using libraries like TrackEval or MOTChallenge to compute IDF1/HOTA scores and optimize tracker parameters iteratively.

      @maxexplorer great questions about tracking stability! Here are the key points:

      1. ID changes typically occur due to low IoU between predicted and detected boxes, occlusions, or threshold mismatches. Check track_high_thresh and match_thresh in your tracker config.

      2. match_thresh is indeed IoU-based. For debugging, you can add logging to the tracker code, but there's no built-in visualization.

      3. Kalman predictions aren't directly exposed, but you can access them by modifying the tracker implementation.

      4. Higher FPS generally improves tracking by reducing inter-frame motion, making associations more reliable.

      5. Both trackers use confirmation logic - tracks need to meet certain criteria before being confirmed as valid tracks.

      6. New tracks can be assigned immediately if detection confidence exceeds new_track_thresh.

      7. Correct - track_buffer maintains lost tracks for that many frames using prediction.

      8. For stability: increase track_buffer, adjust match_thresh based on your scenario, and ensure consistent detection quality with appropriate conf thresholds.

      For detailed parameter tuning, refer to the tracker configuration files and our tracking documentation.

  2. rohith-aiunikaGitHub(editado)

    Hi YOLO Team, I've been using the following Python script to track objects with my YOLOv8 model: from ultralytics import YOLO

    model = YOLO(r"/home/best_pt_files/v1.0.2.pt") results = model.track(r"/home/video.MP4", save=False, stream=False)

    However, I noticed that my GPU memory usage gradually increases, leading to an "out of memory" error before the video finishes processing. Interestingly, when I use the following command from the terminal, the entire video tracks successfully without excessive GPU memory consumption: yolo track model=/home/best_pt_files/1.0.2.pt source=/home/video.MP4

    Previously, the Python script worked without any issues. The memory issue has only recently started occurring. Could you please help me understand the possible reasons for this memory increase and how to address it?

    i have experimented with persist= True and False,stream = true and false, show = true and false also but the issue is still there

    1
    1. Glenn JocherUltralytics

      @rohith-aiunika thanks for reporting this. The memory buildup in Python scripts (but not CLI) typically occurs when not using streaming mode. To match the CLI's memory behavior, modify your Python script to process frames iteratively using stream=True:

      from ultralytics import YOLO
      
      model = YOLO("/home/best_pt_files/v1.0.2.pt")
      for result in model.track("/home/video.MP4", stream=True):  # Process frames iteratively
          pass  # Add your frame processing logic here

      This streams frames sequentially like the CLI, preventing memory accumulation. For more details, see the streaming implementation in our Tracking documentation. Let us know if this resolves the issue!

    2. Glenn JocherUltralytics

      @rohith-aiunika thanks for the update. Let's ensure you're properly iterating through streaming results. Try adding a processing loop like this:

      for result in model.track(source=video_path, stream=True):
          annotated_frame = result[0].plot()
          cv2.imshow('Tracking', annotated_frame)
          if cv2.waitKey(1) == ord('q'):
              break

      This actively processes each frame and displays tracking annotations. If issues persist, you might need to verify your video source format using our supported inference sources documentation.

  3. mwaselaGitHub

    Hello, Made a custom model that i can successfully run and with a well tweaked confidence filter, am getting good results.

    Now Ive wrapped the classification and tracking functionality into a flask app, that returns the count ID's when accessed by a REST call like get, meaning it can be accessed by a separate app for processing and stuff. I want to be able to reset the counting through some other request. My camera feed is always live, i need a way to reset the track id's to zero when neccessary, they just keep counting until i exit the program.

    1
    1. Glenn JocherUltralytics

      @mwasela hello,

      It's great to hear that your custom model is performing well. To reset the tracking IDs in your Flask app, you can implement a mechanism to reinitialize the tracker state upon receiving a specific request. This can be done by resetting the tracker object or reloading the model within your tracking function.

      For more detailed guidance on configuring and using trackers, please refer to our documentation: Multi-Object Tracking with Ultralytics YOLO.

  4. Orziqulov-JavohirGitHub

    I really need help to do this programm: I wanna select region via mouse "dangerous zone" Track detected person, If person enters this zone crop and save person's photo Can you show me pls how to do it for 10 cameras, my gpu is RTX 3080TI

    1
    1. Orziqulov-JavohirGitHub

      import cv2 from ultralytics import YOLO import time

      Load the YOLOv8 model

      model = YOLO("yolov8n.pt") # pretrained YOLOv8n model

      Initialize video capture for multiple cameras

      camera_ids = [

      'rtsp://admin:admin12345@172.17.67.20:554',

      'rtsp://admin:admin12345@172.17.67.16:554', 'rtsp://admin:admin12345@172.17.67.18:554', 'rtsp://admin:admin12345@172.17.67.19:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554',
      ]

      caps = [cv2.VideoCapture(camera_id) for camera_id in camera_ids]

      Open the video file

      roi_start = [(0, 0)] * len(caps) roi_end = [(0, 0)] * len(caps) drawing = [False] * len(caps)

      tracked_persons = [[] for _ in range(len(caps))] # List to track persons in dangerous zones

      def draw_rectangle(event, x, y, flags, param): global roi_start, roi_end, drawing idx = param # Use param to identify the camera index if event == cv2.EVENT_LBUTTONDOWN: drawing[idx] = True roi_start[idx] = (x, y) roi_end[idx] = (x, y) print(f"Camera {idx}: Started drawing rectangle at: {roi_start[idx]}") elif event == cv2.EVENT_MOUSEMOVE: if drawing[idx]: roi_end[idx] = (x, y) print(f"Camera {idx}: Updated rectangle end to: {roi_end[idx]}") elif event == cv2.EVENT_LBUTTONUP: drawing[idx] = False roi_end[idx] = (x, y) print(f"Camera {idx}: Finished drawing rectangle at: {roi_end[idx]}")

      Create a window and set mouse callback for each camera

      for idx in range(len(caps)): window_name = f'Video {idx}' cv2.namedWindow(window_name) cv2.setMouseCallback(window_name, draw_rectangle, idx)

      def is_inside_roi(x, y, roi_start, roi_end): x1, y1 = roi_start x2, y2 = roi_end return min(x1, x2) <= x <= max(x1, x2) and min(y1, y2) <= y <= max(y1, y2)

      while True: frames = [] for cap in caps: ret, frame = cap.read() if not ret: continue # frame = cv2.resize(frame, (640, 480)) frames.append(frame)

      for idx, frame in enumerate(frames):
          window_name = f'Video {idx}'
          
          # Draw the ROI rectangle on the frame
          if drawing[idx] or roi_start[idx] != roi_end[idx]:
              cv2.rectangle(frame, roi_start[idx], roi_end[idx], (0, 255, 0), 2)
              cv2.putText(frame, "Dangerous Zone", (roi_start[idx][0], roi_start[idx][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
      
          # Run YOLOv8 tracking on the frame, persisting tracks between frames
          results = model.track(frame, tracker="bytetrack.yaml", persist=True)
      
          for result in results:
              boxes = result.boxes
      
              for box in boxes:
                  x1, y1, x2, y2 = box.xyxy.tolist()[0][:4]
                  cls = box.cls.tolist()[0]
                  if cls == 0:  # Person class in COCO dataset
                      # Check if the center of the person is inside the ROI
                      cx, cy = int((x1 + x2) / 2), int((y1 + y2) / 2)
                      if is_inside_roi(cx, cy, roi_start[idx], roi_end[idx]):
                          # Check if this person is already tracked
                          person_id = box.id.tolist()[0] if box.id is not None else None
                          
                          if person_id not in tracked_persons[idx]:
                              tracked_persons[idx].append(person_id)
                              # Crop and save the frame
                              crop = frame[int(y1):int(y2), int(x1):int(x2)]
                              cv2.imwrite(f"cropped_camera{idx}_person{person_id}_{int(time.time())}.jpg", crop)
                              # Draw a label on the person
                              cv2.putText(frame, "Person in Dangerous Zone", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
                              cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
      
          cv2.imshow(window_name, frame)
      
      if cv2.waitKey(1) & 0xFF == ord('q'):
          break

      Release all video captures

      for cap in caps: cap.release() cv2.destroyAllWindows()

    2. Glenn JocherUltralytics

      Your approach looks solid for setting up a security program to track and save images of individuals entering a designated "dangerous zone" across multiple cameras. To enhance your implementation, ensure you're using the latest versions of the Ultralytics package for optimal performance and bug fixes. For more detailed guidance on tracking configurations and additional features, you can refer to the Ultralytics tracking documentation. If you encounter any specific issues or need further assistance, feel free to ask!

    3. mariem158GitHub

      File "", line 91 results = model.track(frame, persist=True, tracker="botsort.yaml") ^ IndentationError: unexpected indent COMMENT CORRIGER CETTE ERREUR

    4. Glenn JocherUltralytics

      The error you're encountering is due to an unexpected indent in your code. Ensure that the indentation is consistent throughout your script. If the issue persists, please verify it with the latest version of the Ultralytics package. For more details on tracking configurations, you can refer to the Ultralytics tracking documentation.

    1. GKYofficeGitHub

      Can I set the parameter ''save_txt'' to True in the track function, and then write code to evaluate the tracking data?

    2. Paula DerrengerUltralytics

      Currently, the Ultralytics YOLO framework doesn't provide built-in functionality for computing tracking metrics like MOTA or IDF1 directly through the API or command line. However, you can utilize external libraries such as MOTChallenge eval for calculating these metrics.

      After running your tracking with YOLOv8, you'd typically export your tracking results in a format compatible with these libraries (usually a .txt format with frame ID, object ID, bounding boxes, etc.). Then, use the external library to compute the desired metrics by providing it with both the ground truth and your results file.

      Here's a generic example on how you might save tracking results (modify based on your actual use case):

      from ultralytics import YOLO
      
      # Initialize and load your model
      model = YOLO("path/to/your/model.pt")
      
      # Tracking
      results = model.track(source='path/to/video.mp4', save_txt=True, project='runs/track', name='exp')
      
      # results are saved in 'runs/track/exp' in a format that can be used with MOTChallenge eval tools

      Afterwards, follow the documentation of the MOTChallenge eval toolkit to compute the metrics using the outputs stored in 'runs/track/exp'.

      If you encounter any specific issues while implementing this, feel free to ask!🛠️

  5. AdadAlShababGitHub

    Can I run two models simultaneously in one video? Ex: model = YOLO('E:/Ultralytics/best.pt') model = YOLO('yolov8m-pose.pt') results = model.track(source="file.mp4", show=True, conf=0.3, save=False) results = model.track(source="file.mp4", show=True, conf=0.3, save=False)

    I want that two models will works simultaneously with cumulative results? Is it possible? Please let me know. Thanks in advance!!

    1
    1. Paula DerrengerUltralytics

      @AdadAlShabab yes, you can run two models simultaneously on one video, but you'll need to manage the inference in a way that allows both models to process the video frames concurrently. Here's a simplified example using threading to achieve this:

      import threading
      from ultralytics import YOLO
      
      # Load the models
      model1 = YOLO('E:/Ultralytics/best.pt')
      model2 = YOLO('yolov8m-pose.pt')
      
      # Function to run tracking
      def track_video(model, source, conf, show, save):
          results = model.track(source=source, show=show, conf=conf, save=save)
          # Process results here or return them
      
      # Create threads for each model
      thread1 = threading.Thread(target=track_video, args=(model1, "file.mp4", 0.3, True, False))
      thread2 = threading.Thread(target=track_video, args=(model2, "file.mp4", 0.3, True, False))
      
      # Start the threads
      thread1.start()
      thread2.start()
      
      # Wait for both threads to finish
      thread1.join()
      thread2.join()

      This script will run both models in separate threads. If you want to combine the results from both models, you'll need to implement a mechanism to synchronize and merge the results from both threads. Keep in mind that displaying the results (show=True) from two threads might not work as expected, and you might need to handle the visualization separately.

      Remember to handle the GPU memory usage carefully, as running two models simultaneously will require more memory. If you encounter any issues, consider running the models sequentially or on separate GPUs if available.

      4
  6. Journey2-20GitHub

    Hello I'm newer to Opencv and I'm trying to run a tracking camera for airsoft. How would i select specific bounding boxes?

    1. Paula DerrengerUltralytics

      Use model.track(frame, persist=True) and inspect results[0].boxes.xyxy with results[0].boxes.id; select the box containing your OpenCV mouse-click coordinates, store its track ID, then process or draw only boxes whose boxes.id matches that ID. Feel free to continue posting questions here so the Ultralytics team can help.

  7. yashpatel2010GitHub

    In my jetson orin nano super developer kit with jetpack6.1 and deepstream7.1 i want to do cross camera person tracking. Is there any default way in deepstream configs to do it? Or any other lightweight thing that can be easily doable in jetson orin nano 8 gb super dev kit.

    1. Glenn JocherUltralytics

      Ultralytics track is single-camera MOT, so cross-camera person IDs are not built in; on DeepStream 7.1 the practical Orin Nano path is NvDeepSORT/ReID per stream plus downstream association from the exported embeddings described in the DeepStream gst-nvtracker docs, or NVIDIA’s separate Multi-Camera Tracking workflow for full MTMC. Please keep the details here in Discussions and share your current tracker config if you want a minimal setup suggestion. (docs.nvidia.com)

  8. anvi97GitHub(editado)

    Hi @glenn-jocher,

    I am building a road surface detection system using YOLO segmentation.

    My pipeline:

    Apply bird eye view using cv2.getPerspectiveTransform()

    Mask only road area

    Detect potholes, zebra crossings, and speed bumps

    I am facing the following issues:

    1️⃣ Overlapping Potholes Not Merging Properly

    I want overlapping potholes to merge into one bounding box.

    In many cases it works, but sometimes:

    Two boxes are still shown for the same pothole

    Even when they overlap visually

    I am using YOLO with:

    results = model(frame, conf=0.45, iou=0.4)

    Is YOLO’s internal NMS preventing full merging? Should I apply custom merging after inference? Is segmentation-based merging better than bounding box merging for potholes?

    2️⃣ Object Size Changing After Bird Eye View

    I calculate pothole size using:

    pixels_per_foot = 220

    But I selected this value randomly (no real-world measurement).

    Because of this:

    Object size changes depending on frame position

    Same pothole appears different size

    Is it correct that without real-world calibration, size cannot be accurate? What is the correct method to calculate real-world size in a monocular dashcam setup?

    3️⃣ Zebra Crossing vs Black–White Speed Bump Confusion

    Black–white speed bumps are getting confused with zebra crossings because both have parallel white-black stripes.

    Currently I am detecting only yellow speed bumps to avoid confusion.

    What is the better approach to separate them?

    Use segmentation instead of boxes?

    Add geometry-based filtering?

    Train with more hard-negative examples?

    1. anvi97GitHub

      this is my code ..... from ultralytics import YOLO import cv2 import numpy as np

      model = YOLO("runs/segment/pothole_seg_model3/weights/best.pt") pixels_per_foot = 220

      video_path = "sample_video.mp4" cap = cv2.VideoCapture(video_path)

      if not cap.isOpened(): print(" Cannot open video") exit()

      width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = cap.get(cv2.CAP_PROP_FPS) or 25.0

      fourcc = cv2.VideoWriter_fourcc(*'avc1') out = cv2.VideoWriter("pothole5.mp4", fourcc, fps, (width, height))

      STRETCH_AMOUNT = 50

      src = np.float32([ [0, height],
      [width, height],
      [922, 183],
      [265, 183]
      ])

      dst = np.float32([ [0, height], [width, height], [width + STRETCH_AMOUNT, 0], [0 - STRETCH_AMOUNT, 0] ])

      matrix = cv2.getPerspectiveTransform(src, dst) def compute_iou(box1, box2): x1 = max(box1[0], box2[0]) y1 = max(box1[1], box2[1]) x2 = min(box1[2], box2[2]) y2 = min(box1[3], box2[3])

      inter_area = max(0, x2 - x1) * max(0, y2 - y1)
      
      box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
      box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
      
      union = box1_area + box2_area - inter_area
      
      if union == 0:
          return 0
      
      return inter_area / union

      def should_merge(box1, box2, iou_thresh=0.1, dist_thresh=150): # Containment check - if one box is inside the other if (box1[0] >= box2[0] and box1[1] >= box2[1] and box1[2] <= box2[2] and box1[3] <= box2[3]): return True if (box2[0] >= box1[0] and box2[1] >= box1[1] and box2[2] <= box1[2] and box2[3] <= box1[3]): return True

      iou = compute_iou(box1, box2)
      if iou > iou_thresh:
          return True
      
      cx1, cy1 = (box1[0]+box1[2])/2, (box1[1]+box1[3])/2
      cx2, cy2 = (box2[0]+box2[2])/2, (box2[1]+box2[3])/2
      
      if np.sqrt((cx1-cx2)**2 + (cy1-cy2)**2) < dist_thresh:
          return True
      
      return False

      while True: ret, frame = cap.read() if not ret: break

      bird_eye = cv2.warpPerspective(frame, matrix, (width, height))
      
      results = model(bird_eye, conf=0.45, iou=0.4)[0]
      annotated = results.plot()
      
      if results.boxes is not None:
          for box in results.boxes:
              cls_id = int(box.cls.item())
      
              if cls_id == 0:  # pothole only
                  x1, y1, x2, y2 = map(int, box.xyxy.cpu().numpy()[0])
      
                  w_px = x2 - x1
                  h_px = y2 - y1
      
                  w_ft = w_px / pixels_per_foot
                  h_ft = h_px / pixels_per_foot
      
                  label = f"{w_ft:.2f}ft x {h_ft:.2f}ft"
      
                  cv2.putText(
                      annotated,
                      label,
                      (x1, y1 - 15),
                      cv2.FONT_HERSHEY_SIMPLEX,
                      0.6,
                      (0, 255, 255),
                      2
                  )
      
      cv2.imshow("Bird Eye + Pothole Detection", annotated)
      out.write(annotated)
      
      if cv2.waitKey(1) & 0xFF == 27:
          break

      cap.release() out.release() cv2.destroyAllWindows()

    2. Glenn JocherUltralytics

      For (1), YOLO’s NMS will only suppress duplicate detections based on iou=...—it won’t “merge” two overlapping detections into a larger union box, and in your snippet compute_iou() / should_merge() aren’t actually applied to results.boxes, so you’re still visualizing the raw post-NMS output; since you’re using a Segment model, the most robust way to merge “split” potholes is to union the pothole masks and re-extract connected components (then box/measure those) rather than trying to union boxes.

      import cv2
      import numpy as np
      
      r = model(bird_eye, conf=0.45, iou=0.4)[0]
      
      if r.masks is not None and r.boxes is not None:
          cls = r.boxes.cls.int().cpu().numpy()
          pothole_idx = np.where(cls == 0)[0]
          if pothole_idx.size:
              m = r.masks.data[pothole_idx].cpu().numpy()  # (N,H,W), 0/1
              union = (m.sum(0) > 0).astype(np.uint8) * 255
              n, labels = cv2.connectedComponents(union)
              for k in range(1, n):
                  ys, xs = np.where(labels == k)
                  x1, y1, x2, y2 = xs.min(), ys.min(), xs.max(), ys.max()
                  cv2.rectangle(bird_eye, (x1, y1), (x2, y2), (0, 255, 255), 2)

      For (2), yes—without real-world calibration (and a valid “road plane” assumption), pixels_per_foot=220 can’t be physically meaningful, and even with a BEV warp you only get consistent scale if your homography is tied to metric coordinates; the usual monocular approach is: calibrate camera intrinsics, estimate the road plane, build a homography to a top-down plane in real units (or derive scale from at least one known road-plane measurement like lane width/stripe spacing), then measure in the BEV plane.

      For (3), the best fix is usually data: train both classes explicitly with lots of “hard negatives” (zebra crossings that look like bumps and vice versa) and keep labels consistent; segmentation often helps because you can then add simple shape/location constraints on the mask (zebra = large repeated pattern region, bump = single narrow band across lane) and optionally smooth decisions over time (if you’re doing video, using model.track(..., persist=True) from the Track mode docs can help stabilize per-frame flicker, even though it won’t merge instances within a frame).

      If you can paste !yolo checks output and one representative frame (plus what you consider the “correct” merged result), I can suggest concrete thresholds/post-processing for your exact outputs.

    3. anvi97GitHub

      Representative frame In the attached frame:

      The large water-filled pothole on the left should be treated as a single instance.

      The small region in the top-left corner (currently detected as separate) should be merged with the large region.

      Essentially, all visually continuous damaged area should result in one bounding box / one connected component.

      Currently:

      Mask union + connected components splits them due to small segmentation gaps

      Goal:

      Treat visually continuous pothole surface as one instance for measurement stability.

    4. Glenn JocherUltralytics

      That split is expected because connectedComponents() treats any 1–2 px “mask hole” as a hard break, so add a small gap-closing step on the union mask (morphological close / dilate→erode) before components, with the kernel sized to the largest gap you still consider “visually continuous” (see Ultralytics YOLO segmentation docs for more mask/seg usage details):

      # union: uint8 {0,255}
      union = (m.sum(0) > 0).astype(np.uint8) * 255
      
      # bridge small gaps (tune kernel size to your expected mask discontinuities)
      k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (25, 25))
      union_closed = cv2.morphologyEx(union, cv2.MORPH_CLOSE, k_close, iterations=1)
      
      # optional: remove tiny speckles after closing
      k_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
      union_closed = cv2.morphologyEx(union_closed, cv2.MORPH_OPEN, k_open, iterations=1)
      
      n, labels = cv2.connectedComponents(union_closed)
    1. Glenn JocherUltralytics(editado)

      @mslabdelhak29 ReID is only supported by some trackers (for example BoT-SORT), not ByteTrack, and it’s enabled via the tracker YAML you pass at runtime. Copy the default config, enable ReID explicitly, and point track() to your copy:

      # custom_botsort.yaml
      tracker_type: botsort
      with_reid: True
      model: yolo26n-cls.pt  # or another YOLO classification weight you have locally
      from ultralytics import YOLO
      model = YOLO("yolo26n.pt")  # any YOLO detector
      results = model.track(source="path/to/video.mp4", tracker="custom_botsort.yaml", persist=True, show=False)

      If it still doesn’t work, you’re likely editing a different YAML than the one being loaded; always pass the path as above. Also share the output of yolo checks and the exact custom_botsort.yaml you used so we can verify your environment and keys. See the ReID section in the tracking guide and the BoT-SORT config for details: Multi‑Object Tracking docs and botsort.yaml config.