Rastreamento de múltiplos objetos com Ultralytics YOLO#

O rastreamento de objetos no domínio da análise de vídeo é uma tarefa fundamental que não só identifica a localização e a classe dos objetos no enquadramento, como também mantém um ID único para cada objeto detetado à medida que o vídeo avança. As aplicações são inúmeras — desde vigilância e segurança até à análise desportiva em tempo real.

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

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

A saída dos rastreadores Ultralytics é consistente com a deteção de objetos padrão, mas acrescenta IDs de objeto. Isto facilita o rastreamento de objetos em fluxos de vídeo e a realização de análises subsequentes. Eis por que motivo deves considerar usar 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: Compatível com vários algoritmos e configurações de rastreamento.
• 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.

Aplicações no mundo real#

Início rápido#

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

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 fluxos de vídeo, usa um modelo treinado de deteção, segmentação, pose ou OBB, como YOLO26n, YOLO26n-seg, YOLO26n-pose ou YOLO26n-obb. Podes treinar modelos personalizados localmente ou através do treino na nuvem da Ultralytics Platform.

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.

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.

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

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.7, show=True)

Configuração personalizada do rastreador#

A Ultralytics também te permite usar um ficheiro de configuração de rastreador modificado. Para isso, basta fazeres uma cópia de um ficheiro de configuração de rastreador (por exemplo, custom_tracker.yaml) de ultralytics/cfg/trackers e modificares as configurações conforme as tuas necessidades (exceto tracker_type).

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:

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:

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

Ativar a reidentificação (ReID)#

A ReID fica desativada por padrão para minimizar a sobrecarga. Ative-a definindo with_reid: True em um arquivo de configuração do 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

Para obter melhor desempenho com um modelo de classificação separado, exporte-o para um back-end mais rápido, como 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.

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:

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:

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:

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:

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:

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#

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.

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

Repara na alteração de model(frame) para model.track(frame), que ativa o rastreamento de objetos em vez da deteção simples. Este script modificado executa o rastreador em cada frame do vídeo, visualiza os resultados e apresenta-os numa janela. Podes sair do loop premindo 'q'.

Representar os rastreamentos ao longo do tempo#

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

No exemplo seguinte, mostramos como usar os recursos de rastreamento do YOLO26 para representar o movimento dos objetos detetados ao longo de vários frames de vídeo. Este script abre um ficheiro de vídeo, lê-o frame a frame e usa o modelo YOLO para identificar e rastrear vários objetos. Ao guardar os pontos centrais das caixas delimitadoras detetadas e ligá-los, podemos desenhar linhas que representam os percursos seguidos pelos objetos rastreados.

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ários fluxos de vídeo em simultâneo. Isto é particularmente útil ao processar várias entradas de vídeo, como as provenientes de várias câmaras de vigilância, em que o processamento simultâneo pode aumentar significativamente a eficiência e o desempenho.

No script Python apresentado, usamos o módulo threading do Python para executar várias instâncias do rastreador em simultâneo. 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 usar e o índice do ficheiro), definimos uma função run_tracker_in_thread que aceita estes parâmetros e contém o loop principal de rastreamento. Esta função lê o vídeo frame a frame, executa o rastreador e guarda os resultados anotados.

Neste exemplo, são usados dois modelos diferentes: yolo26n.pt e yolo26n-seg.pt, cada um a rastrear 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 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().

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#

Tens experiência em rastreamento de vários 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 valiosas para quem trabalha em tarefas de rastreamento.

Ao contribuir para esta secção, ajudas a ampliar o conjunto de soluções de rastreamento disponíveis no framework Ultralytics YOLO, acrescentando mais uma camada de funcionalidade e utilidade para a comunidade.

Para iniciares a tua contribuição, consulta o nosso Guia de Contribuição para obter instruções completas sobre como enviar um Pull Request (PR) 🛠️. Estamos ansiosos por ver o que tens para partilhar!

Juntos, vamos melhorar os recursos de rastreamento do ecossistema Ultralytics YOLO 🙏!

Perguntas frequentes#