Rastreamento de Múltiplos Objetos com Ultralytics YOLO#

O rastreamento de objetos no domínio da análise de vídeo é uma tarefa crítica que não apenas identifica a localização e a classe dos objetos dentro do quadro, mas também mantém um ID único para cada objeto detectado à medida que o vídeo progride. As aplicações são ilimitadas — variando de vigilância e segurança a análises esportivas em tempo real.

Por que escolher o Ultralytics YOLO para Rastreamento de Objetos?#

A saída dos rastreadores do Ultralytics é consistente com a detecção de objetos padrão, mas traz o valor adicional de IDs de objetos. Isso facilita o rastreamento de objetos em fluxos de vídeo e a realização de análises subsequentes. Eis por que deves considerar usar o Ultralytics YOLO para as tuas necessidades de rastreamento de objetos:

• Eficiência: Processa fluxos de vídeo em tempo real sem comprometer a precisão.
• Flexibilidade: Suporta múltiplos algoritmos e configurações de rastreamento.
• Facilidade de Uso: API Python simples e opções de CLI para integração e implantação rápidas.
• Customização: Fácil de usar com modelos YOLO treinados de forma personalizada, permitindo a integração em aplicações de domínio específico.

Aplicações do mundo real#

Início Rápido#

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

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

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

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

Para executar o rastreador em fluxos de vídeo, usa um modelo treinado de Detect, Segment, Pose ou OBB, como YOLO26n, YOLO26n-seg, YOLO26n-pose ou YOLO26n-obb. Podes treinar modelos personalizados localmente ou com o treinamento na nuvem do Ultralytics Platform.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolo26n.pt")  # Load an official Detect model
model = YOLO("yolo26n-seg.pt")  # Load an official Segment model
model = YOLO("yolo26n-pose.pt")  # Load an official Pose model
model = YOLO("path/to/best.pt")  # Load a custom-trained model

# Perform tracking with the model
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # with ByteTrack

Rastreadores Suportados#

O Ultralytics YOLO vem com seis rastreadores integrados. Ativa um deles passando o seu arquivo de configuração YAML para o argumento tracker.

Qual Rastreador Devo Usar?#

Usa este fluxo para escolheres um ponto de partida; o tracktrack.yaml é utilizado quando não passas nenhum tracker:

1. Precisa da base mais rápida e simples? → ByteTrack (sem ReID, sem compensação de movimento de câmera, sobrecarga mínima).
2. Imagens de câmara portátil, drone ou em movimento? → BoT-SORT (adiciona compensação de movimento da câmara e ReID opcional).
3. Movimento não linear (esportes, dança, curvas bruscas) e sem ReID? → OC-SORT (correções centradas na observação sem custo de aparência).
4. Cenas lotadas com câmara em movimento onde as trocas de ID são o principal problema? → Deep OC-SORT ou TrackTrack (ambos suportam correspondência de aparência opcional; o TrackTrack também adiciona associação de múltiplos sinais e supressão de IDs duplicados).
5. Sobreposição parcial frequente em tempo real, sem orçamento de ReID? → FastTracker (variante do ByteTrack consciente de oclusão com reversão Kalman).

Alternando Rastreadores#

Passa o nome do arquivo de configuração do rastreador para tracker=. Todo o restante código permanece igual.

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 partilha propriedades com o modo Predict, tais como conf, iou e show. Para mais configurações, consulta a página do modelo Predict.

from ultralytics import YOLO

# Configure the tracking parameters and run the tracker
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.7, show=True)

Configuração de Rastreador Personalizado#

O Ultralytics também permite usar um arquivo de configuração de rastreador modificado. Para isso, basta fazeres uma cópia de um arquivo de configuração de rastreador (por exemplo, custom_tracker.yaml) em ultralytics/cfg/trackers e modificar quaisquer configurações (exceto o tracker_type) de acordo com as tuas necessidades.

from ultralytics import YOLO

# Load the model and run the tracker with a custom configuration file
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Argumentos Compartilhados do Rastreador#

Os seguintes parâmetros são comuns à maioria dos arquivos YAML de rastreador; nem todo parâmetro aparece em todas as configurações:

Argumentos específicos do rastreador#

Cada algoritmo expõe botões adicionais além dos parâmetros compartilhados. Consulte as seções por rastreador abaixo para obter descrições e dicas de ajuste, ou consulte diretamente os arquivos de configuração:

• botsort.yaml
• bytetrack.yaml
• ocsort.yaml
• deepocsort.yaml
• fasttrack.yaml
• tracktrack.yaml

Habilitando a Reidentificação (ReID)#

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

Opções de modelo de ReID:

• model: auto — Usa recursos nativos do detector YOLO, adicionando sobrecarga mínima. Ideal quando precisas de algum ReID sem um grande impacto no desempenho. Recorre a yolo26n-cls.pt se o detector não expuser recursos compatíveis.
• Modelo ReID personalizado — Aponta model: para um ponto de controlo (checkpoint) .pt ou para um modelo de embedding exportado compatível, tal como .torchscript, .onnx, .engine, ou um diretório de modelo OpenVINO. Os modelos exportados são carregados através de AutoBackend e devem produzir um tensor de embedding diretamente.

Codificadores ONNX prontos a usar são publicados para cada tamanho de modelo. Define model: para um destes nomes e o arquivo é baixado automaticamente na primeira vez que o rastreador é executado (da mesma forma que os pesos do YOLO são obtidos) — sem necessidade de etapas manuais de exportação ou download:

# 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

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

from torch import nn

from ultralytics import YOLO

# Load the classification model
model = YOLO("yolo26n-cls.pt")

# Add average pooling layer
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

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

Uma vez exportado, aponte para o caminho do modelo TensorRT na sua configuração de rastreador.

Detalhes do rastreador#

Expanda as seções abaixo para ver o design, os parâmetros específicos e as dicas de ajuste de cada rastreador.

BoT-SORT#

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

• Compensação de Movimento da Câmera (CMC): uma transformação afim estimada a cada quadro (fluxo óptico esparso por padrão; ORB / ECC também estão disponíveis) é aplicada aos estados de Kalman antes da correspondência de IoU.
• ReID Opcional: os embeddings de aparência podem ser fundidos na matriz de custos. Desativado por padrão; ativa com with_reid: True.

Melhor para: rastreamento de propósito geral, especialmente com câmeras em movimento. Adicione ReID apenas quando multidões semelhantes causarem trocas de ID.

Argumentos específicos do BoT-SORT:

Dicas de ajuste:

• Câmara estática: define gmc_method: none para poupar alguns ms/quadro.
• Movimento intenso da câmara: mantém sparseOptFlow; ecc é mais preciso, mas mais lento.
• Multidões semelhantes: ativa with_reid: True e aumenta appearance_thresh (por exemplo, 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) é a linha de base leve. Ele usa Kalman linear + IoU com uma associação em duas etapas:

• Estágio 1: faz a correspondência de detecções de alta pontuação com trilhas ativas.
• Estágio 2: tenta novamente a correspondência de trilhas não correspondidas com detecções de baixa pontuação para recuperar através de uma breve oclusão parcial.

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

Melhor para: câmeras estáticas ou quase estáticas onde o custo do detector domina e você deseja o mínimo de sobrecarga de rastreador.

Argumentos específicos do ByteTrack: Nenhum além dos argumentos de rastreador partilhados.

Dicas de ajuste:

• Detector ruidoso: reduz track_low_thresh para que a segunda etapa tenha mais candidatos.
• Detector de alta recuperação (high-recall): aumenta track_high_thresh para reduzir IDs fragmentados.
• Frequente oscilação de ID: aumenta track_buffer para que os rastreamentos perdidos brevemente sobrevivam.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) é uma extensão centrada na observação do SORT. Mantém o design 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 reparar a velocidade com desvio.
• Momento Centrado na Observação (OCM): penaliza detecções que se movem na direção errada através de um termo de consistência de velocidade.
• Recuperação Centrada na Observação (OCR): verifica novamente detecções não correspondidas contra trilhas perdidas recentemente usando sua última observação em vez do estado previsto.

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

Argumentos específicos do OC-SORT:

Dicas de ajuste:

• Movimento não linear: aumenta inertia (por exemplo, 0.3-0.4).
• Detecções esparsas: ativa use_byte: True.
• Oclusões longas: aumenta track_buffer para que o OCR tenha mais rastreamentos perdidos para reassociar.

Com os modelos OBB, o OCR utiliza a caixa orientada prevista pelo Kalman, uma vez que não é retido um histórico de última observação orientado.

Deep OC-SORT#

Deep OC-SORT complementa o OC-SORT com informações de aparência e compensação de movimento de câmara:

• Correspondência de aparência: a distância de embedding de cosseno é limitada por sobreposição e fundida com o custo de movimento.
• EMA de aparência dinâmica: embeddings de trilha são atualizados com um EMA cujo fator de suavização se adapta à confiança da detecção.
• Compensação de Movimento da Câmera: estados de Kalman são deformados quadro a quadro via fluxo óptico esparso, ORB ou ECC.

Melhor para: cenas lotadas ou com câmera em movimento onde trocas de ID entre objetos visualmente diferentes mas espacialmente próximos são comuns.

Argumentos específicos do Deep OC-SORT:

Dicas de ajuste:

• Trocas de identidade em multidões: aumenta appearance_thresh (por exemplo, 0.92-0.95) e aumenta alpha_fixed_emb para que os embeddings se adaptem mais lentamente.
• Câmara em movimento: define gmc_method: sparseOptFlow (o Deep OC-SORT assume none por padrão).
• Menor latência: mantém with_reid: False (padrão) apenas para movimento + CMC; ativa o ReID apenas quando as trocas de ID dominam os erros.

FastTracker#

FastTracker é uma variante do ByteTrack ciente de oclusão, sem modelo de aparência:

• Detecção de oclusão: sinaliza rastreamentos como ocluídos quando a cobertura por outros rastreamentos ativos excede occ_cover_thresh.
• Rollback de Kalman na oclusão: reverte o estado de Kalman para um quadro pré-oclusão usando histórico de buffer circular.
• Amortecimento de movimento e expansão de busca: a velocidade é amortecida e a bbox prevista é ampliada enquanto ocluída.
• Supressão de Init-IoU: evita que novas trilhas surjam sobre trilhas ativas.

Melhor para: pipelines de detecção em tempo real com sobreposição frequente de alvo-em-alvo (multidões, filas, esportes).

Argumentos específicos do FastTracker:

Dicas de ajuste:

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

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) é o tracker predefinido. Raciocina a partir da perspetiva de cada rasto com associação iterativa de múltiplos indícios:

• Associação Baseada na Perspetiva do Rastreio (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 limite flexível.
• Inicialização com reconhecimento de rastreamento (TAI): suprime gerações duplicadas antes que um novo ID seja criado.

Melhor para: cenas lotadas com oclusão frequente onde IDs duplicados são um problema.

Argumentos específicos do TrackTrack:

Dicas de ajuste:

• Pedestres aglomerados: reduz tai_thr (por exemplo, 0.45) para suprimir mais gerações duplicadas; aumenta track_buffer para oclusões mais longas.
• Movimento rápido da câmara: mantém gmc_method: sparseOptFlow ativado.
• Objetos pequenos/rápidos: aumenta ligeiramente angle_weight e reduz min_track_len.
• Ative o ReID apenas quando necessário: ele aumenta o custo de inferência; para oclusões curtas, o custo multicanal padrão geralmente é suficiente.

Com os modelos Segment e Pose, o TrackTrack ignora a recuperação de deteção por NMS solto para que as máscaras e os pontos-chave permaneçam alinhados com as respetivas deteções.

Exemplos em Python#

Loop de persistência de rastreamentos#

Aqui está um script em Python que usa o OpenCV (cv2) e o YOLO26 para executar o rastreamento de objetos em quadros de vídeo. Este script assume que os pacotes necessários (opencv-python e ultralytics) já estão instalados. O argumento persist=True diz ao rastreador que a imagem ou quadro atual é o seguinte em uma sequência e para esperar rastreamentos da imagem anterior na imagem atual.

import cv2

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO26 tracking on the frame, persisting tracks between frames
        # and using the BoT-SORT tracker backend
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

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

Plotando rastreamentos ao longo do tempo#

Visualizar rastreamentos de objetos ao longo de quadros consecutivos pode fornecer insights valiosos sobre os padrões de movimento e o comportamento dos objetos detectados dentro de um vídeo. Com o Ultralytics YOLO26, plotar esses rastreamentos é um processo contínuo e eficiente.

No exemplo a seguir, demonstramos como utilizar os recursos de rastreamento do YOLO26 para plotar o movimento de objetos detectados em vários quadros de vídeo. Este script envolve abrir um arquivo de vídeo, lê-lo quadro a quadro e utilizar o modelo YOLO para identificar e rastrear vários objetos. Ao reter os pontos centrais das caixas delimitadoras detectadas e conectá-los, podemos desenhar linhas que representam os caminhos seguidos pelos objetos rastreados.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Store the track history
track_history = defaultdict(list)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO26 tracking on the frame, persisting tracks between frames
        result = model.track(frame, persist=True)[0]

        # Get the boxes and track IDs
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Visualize the result on the frame
            frame = result.plot()

            # Plot the tracks
            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)))  # x, y center point
                if len(track) > 30:  # retain 30 tracks for 30 frames
                    track.pop(0)

                # Draw the tracking lines
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Display the annotated frame
        cv2.imshow("YOLO26 Tracking", frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Rastreamento multithread#

O rastreamento multithread oferece a capacidade de executar o rastreamento de objetos em vários fluxos de vídeo simultaneamente. Isso é particularmente útil ao lidar com múltiplas entradas de vídeo, como de várias câmeras de vigilância, onde o processamento simultâneo pode melhorar muito a eficiência e o desempenho.

No script Python fornecido, utilizamos o módulo threading do Python para executar várias instâncias do rastreador simultaneamente. Cada thread é responsável por executar o rastreador em um arquivo de vídeo, e todas as threads são executadas em simultâneo em segundo plano.

Para garantir que cada thread receba os parâmetros corretos (o arquivo de vídeo, o modelo a ser usado e o índice do arquivo), definimos uma função run_tracker_in_thread que aceita esses parâmetros e contém o loop principal de rastreamento. Esta função lê o vídeo quadro a quadro, executa o rastreador e exibe os resultados.

Dois modelos diferentes são usados neste exemplo: yolo26n.pt e yolo26n-seg.pt, cada um rastreando objetos em um arquivo de vídeo diferente. Os arquivos de vídeo são especificados em SOURCES.

O parâmetro daemon=True em threading.Thread significa que essas 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 esperar até que ambas as threads do rastreador tenham terminado.

Finalmente, após todas as threads concluírem a sua tarefa, as janelas que exibem os resultados são fechadas usando cv2.destroyAllWindows().

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # local video, 0 for 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

# Create and start tracker threads using a for loop
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()

# Wait for all tracker threads to finish
for thread in tracker_threads:
    thread.join()

# Clean up and close windows
cv2.destroyAllWindows()

Este exemplo pode ser facilmente estendido para lidar com mais arquivos de vídeo e modelos criando mais threads e aplicando a mesma metodologia.

Contribua com novos rastreadores#

Tens experiência em rastreamento de múltiplos objetos e implementaste ou adaptaste com sucesso um algoritmo de rastreamento com o Ultralytics YOLO? Convidamos-te a contribuir para a nossa seção Trackers em ultralytics/cfg/trackers! As tuas aplicações e soluções do mundo real podem ser inestimáveis para utilizadores que trabalham em tarefas de rastreamento.

Ao contribuir para esta seção, você ajuda a expandir o escopo de soluções de rastreamento disponíveis na estrutura do Ultralytics YOLO, adicionando outra camada de funcionalidade e utilidade para a comunidade.

Para iniciar a tua contribuição, consulta o nosso Guia de Contribuição para obter instruções abrangentes sobre como enviar um Pull Request (PR) 🛠️. Estamos entusiasmados para ver o que tens para oferecer!

Juntos, vamos melhorar as capacidades de rastreamento do ecossistema Ultralytics YOLO 🙏!

FAQ#