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 exclusivo para cada objeto detectado à medida que o vídeo progride. As aplicações são ilimitadas — indo desde vigilância e segurança até análises esportivas em tempo real.

Consulta a prévia do YOLO27 não lançada para ver o suporte a rastreamento planejado.

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

A saída dos rastreadores Ultralytics é consistente com a detecção de objetos padrão, mas tem o valor agregado 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.
• Personalizabilidade: Fácil de usar com modelos YOLO treinados de forma personalizada, permitindo a integração em aplicações específicas de domínio.

Aplicações no mundo real#

Início rápido#

Executa o rastreamento em um vídeo com o rastreador padrão TrackTrack. Troca para outro rastreador 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 Detecção (Detect), Segmentação (Segment), Pose (Pose) ou OBB (OBB), tal como YOLO26n, YOLO26n-seg, YOLO26n-pose ou YOLO26n-obb. Podes treinar modelos personalizados localmente ou com o treinamento em nuvem da 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 passando o seu arquivo de configuração YAML para o argumento tracker.

Qual Rastreador Devo Usar?#

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

1. Precisas 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âmera portátil, drone ou em movimento? → BoT-SORT (adiciona compensação de movimento de câmera e ReID opcional).
3. Movimento não linear (esportes, dança, curvas abruptas) e sem ReID? → OC-SORT (correções centradas na observação sem custo de aparência).
4. Cenas lotadas com câmera 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 ID duplicado).
5. Sobreposição parcial frequente em tempo real, sem orçamento para ReID? → FastTracker (variante do ByteTrack sensível a oclusão com reversão de Kalman).

Alternando Rastreadores#

Passa o nome do arquivo de configuração do rastreador para tracker=. Todo o resto do 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 compartilha propriedades com o modo de predição (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 que uses um arquivo de configuração de rastreador modificado. Para fazer isso, basta criar uma cópia de um arquivo de configuração de rastreador (por exemplo, custom_tracker.yaml) a partir de ultralytics/cfg/trackers e modificar quaisquer configurações (exceto o tracker_type) conforme 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 rastreadores; nem todo parâmetro aparece em todas as configurações:

Argumentos Específicos do Rastreador#

Cada algoritmo expõe botões (knobs) adicionais além dos parâmetros compartilhados. Vê as seções por rastreador abaixo para descrições e conselhos de ajuste, ou consulta diretamente os arquivos de configuração:

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

Ativando a Reidentificação (ReID)#

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

Opções de modelo 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. Retorna a yolo26n-cls.pt se o detector não expuser recursos compatíveis.
• Modelo ReID personalizado — Aponta model: para um ponto de verificação (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 gerar um tensor de embedding diretamente.

Codificadores ONNX prontos para uso são publicados para cada tamanho de modelo. Define model: para um desses nomes e o arquivo é baixado automaticamente na primeira vez que o rastreador é executado (da mesma forma que os pesos YOLO são obtidos) — nenhuma etapa manual de exportação ou download é necessária:

# 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 melhor desempenho com um modelo de classificação separado, exporta-o para um backend mais rápido como 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, aponta para o caminho do modelo TensorRT na tua configuração de rastreador.

Detalhes do Rastreador#

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

BoT-SORT#

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

• Compensação de Movimento de Câmera (CMC): uma distorçã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: embeddings de aparência podem ser fundidos na matriz de custo. Desativado por padrão; ativa-o com with_reid: True.

Ideal para: rastreamento de uso geral, especialmente com câmeras em movimento. Adiciona ReID apenas quando multidões semelhantes causam trocas de ID.

Argumentos específicos do BoT-SORT:

Dicas de ajuste:

• Câmera estática: defina gmc_method: none para economizar alguns ms/quadro.
• Movimento intenso da câmera: mantenha sparseOptFlow; ecc é mais preciso, porém mais lento.
• Multidões semelhantes: ative with_reid: True e aumente 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 dois estágios:

• Estágio 1: corresponde detecções de alta pontuação com rastreamentos ativos.
• Estágio 2: tenta novamente rastreamentos sem correspondência contra detecções de baixa pontuação para recuperar através de oclusão parcial breve.

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

Ideal para: câmeras estáticas ou quase estáticas onde o custo do detector domina e tu queres sobrecarga mínima do rastreador.

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

Dicas de ajuste:

• Detector ruidoso: reduza track_low_thresh para que o segundo estágio tenha mais candidatos.
• Detector de alta revocação: aumente track_high_thresh para reduzir IDs fragmentados.
• Frequente oscilação de ID: aumente track_buffer para que rastreamentos perdidos brevemente sobrevivam.

OC-SORT#

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

• Atualização baseada 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 desviada.
• Momento centrado na observação (OCM): penaliza detecções que se movem na direção errada por meio de um termo de consistência de velocidade.
• Recuperação centrada na observação (OCR): verifica novamente detecções sem correspondência em relação a rastreamentos perdidos recentemente usando sua ú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:

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 o OCR tenha mais rastreamentos perdidos para reassociar.

Com modelos OBB, o OCR usa a caixa orientada prevista por Kalman porque um histórico de última observação orientado não é retido.

Deep OC-SORT#

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

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

Ideal 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: 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 Deep OC-SORT usa por padrão none).
• Menor latência: mantenha with_reid: False (padrão) apenas para movimento + CMC; ative ReID apenas quando as trocas de ID dominarem os erros.

FastTracker#

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

• Detecção de oclusão: sinaliza rastreamentos ocluídos quando a cobertura por outros rastreamentos ativos excede occ_cover_thresh.
• Reversão de Kalman na oclusão: reverte o estado de Kalman para um quadro pré-oclusão usando histórico armazenado em buffer circular.
• Atenuação de movimento e expansão de busca: a velocidade é atenuada e a caixa delimitadora prevista é ampliada enquanto ocluída.
• Supressão de Init-IoU: evita que novos rastreamentos apareçam em cima de rastreamentos ativos.

Ideal para: dutos baseados apenas em detecção em tempo real com sobreposição frequente entre alvos (multidões, filas, esportes).

Argumentos específicos do FastTracker:

Dicas de ajuste:

• Oclusões parciais frequentes: reduza occ_cover_thresh (por exemplo, 0.5-0.6).
• IDs duplicados em torno da sobreposição: reduza init_iou_suppress (por exemplo, 0.5).
• Oclusões longas: aumente occ_reappear_window e track_buffer juntos.
• Alvos em movimento rápido: aumente dampen_motion_occ (mais próximo 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 de múltiplos sinais:

• Associação baseada na perspectiva de rastreamento (TPA): combina HMIoU, distância de ReID por 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 ciente do rastreamento (TAI): suprime gerações duplicadas antes que um novo ID seja criado.

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

Argumentos específicos do TrackTrack:

Dicas de ajuste:

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

Com modelos Segment and Pose, o TrackTrack pula a recuperação de detecção de NMS flexível para que máscaras e pontos-chave permaneçam alinhados com suas detecções.

Exemplos em Python#

Loop de persistência de rastreamentos#

Aqui está um script em Python usando OpenCV (cv2) e YOLO26 para executar o rastreamento de objetos em quadros de vídeo. Este script pressupõe que os pacotes necessários (opencv-python e ultralytics) já estejam instalados. O argumento persist=True diz ao rastreador que a imagem ou quadro atual é o próximo 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 da simples deteção. Este script modificado executará o rastreador em cada frame do vídeo, visualizará os resultados e exibi-los-á numa janela. O ciclo pode ser encerrado premindo 'q'.

Plotagem de Rastreamentos ao Longo do Tempo#

Visualizar rastreamentos de objetos em frames consecutivos pode fornecer informações valiosas sobre os padrões de movimento e comportamento dos objetos detetados num vídeo. Com o Ultralytics YOLO26, traçar esses rastreamentos é um processo fluido e eficiente.

No exemplo seguinte, demonstramos como utilizar as capacidades de rastreamento do YOLO26 para traçar o movimento de objetos detetados em vários frames de vídeo. Este script envolve abrir um ficheiro de vídeo, lê-lo frame a frame e utilizar o modelo YOLO para identificar e rastrear vários objetos. Ao reter os pontos centrais das bounding boxes detetadas e conectá-los, podemos desenhar linhas que representam os caminhos percorridos 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 múltiplos fluxos de vídeo simultaneamente. Isto é particularmente útil ao lidar com várias entradas de vídeo, como de várias câmaras de vigilância, onde o processamento concorrente pode melhorar drasticamente 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 concorrentemente. Cada thread é responsável por executar o rastreador num ficheiro de vídeo, e todas as threads são executadas simultaneamente em segundo plano.

Para garantir que cada thread recebe os parâmetros corretos (o ficheiro de vídeo, o modelo a utilizar e o índice do ficheiro), definimos uma função run_tracker_in_thread que aceita estes parâmetros e contém o ciclo de rastreamento principal. Esta função lê o vídeo frame a frame, executa o rastreador e exibe os resultados.

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

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

Finalmente, após todas as threads terem concluído a respetiva tarefa, as janelas que exibem os resultados são fechadas utilizando 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 expandido para lidar com mais ficheiros de vídeo e modelos, criando mais threads e aplicando a mesma metodologia.

Contribuir com Novos Rastreadores#

Tens proficiê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 secção de Rastreadores em ultralytics/cfg/trackers! As tuas aplicações e soluções do mundo real podem ser de valor inestimável para utilizadores que trabalham em tarefas de rastreamento.

Ao contribuíres para esta secção, ajudas a expandir o âmbito das soluções de rastreamento disponíveis dentro do framework Ultralytics YOLO, adicionando outra camada de funcionalidade e utilidade para a comunidade.

Para iniciar a tua contribuição, consulta o nosso Contributing Guide para obteres instruções abrangentes sobre como submeter um Pull Request (PR) 🛠️. Estamos entusiasmados por ver o que trazes para a mesa!

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

Perguntas frequentes#