Rastreamento de múltiplos objetos com Ultralytics YOLO

O rastreamento de objetos no âmbito 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 avança. As aplicações são ilimitadas—desde vigilância e segurança até análise esportiva em tempo real.

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 objeto. Isso torna fácil rastrear objetos em fluxos de vídeo e realizar análises subsequentes. Eis por que você deve considerar usar o Ultralytics YOLO para as suas necessidades de rastreamento de objetos:

• Eficiência: Processe fluxos de vídeo em tempo real sem comprometer a precisão.
• Flexibilidade: Suporta múltiplos algoritmos de rastreamento e configurações.
• Facilidade de uso: Opções simples de API Python e CLI para integração e implantação rápidas.
• Customizabilidade: 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 do mundo real

Transporte	Varejo	Aquicultura
Rastreamento de Veículos	Rastreamento de Pessoas	Rastreamento de Peixes

Recursos em resumo

O Ultralytics YOLO estende seus recursos de detecção de objetos para fornecer um rastreamento de objetos robusto e versátil:

• Rastreamento em tempo real: Rastreie objetos perfeitamente em vídeos de alta taxa de quadros.
• Suporte a múltiplos rastreadores: Escolha entre uma variedade de algoritmos de rastreamento estabelecidos.
• Configurações de rastreador customizáveis: Adapte o algoritmo de rastreamento para atender a requisitos específicos ajustando vários parâmetros.

Rastreadores disponíveis

O Ultralytics YOLO suporta os seguintes algoritmos de rastreamento. Eles podem ser habilitados passando o arquivo de configuração YAML relevante, como tracker=tracker_type.yaml:

• BoT-SORT - Use botsort.yaml para habilitar este rastreador.
• ByteTrack - Use bytetrack.yaml para habilitar este rastreador.

O rastreador padrão é o BoT-SORT.

Rastreamento

Para executar o rastreador em fluxos de vídeo, use um modelo treinado de Detecção, Segmentação ou Pose, como YOLO26n, YOLO26n-seg ou YOLO26n-pose. Você pode treinar modelos personalizados localmente ou em GPUs na nuvem através da Plataforma Ultralytics.

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

Como pode ser visto no uso acima, o rastreamento está disponível para todos os modelos de Detecção, Segmentação e Pose executados em vídeos ou fontes de streaming.

Configuração

Argumentos de rastreamento

A configuração de rastreamento compartilha propriedades com o modo de Predição, como conf, iou e show. Para configurações adicionais, consulte a página do modelo de Predição.

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)

Seleção de rastreador

O Ultralytics também permite que você use um arquivo de configuração de rastreador modificado. Para fazer isso, simplesmente crie uma cópia de um arquivo de configuração de rastreador (por exemplo, custom_tracker.yaml) de ultralytics/cfg/trackers e modifique quaisquer configurações (exceto o tracker_type) conforme suas 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")

Consulte a seção Argumentos do Rastreador para obter uma descrição detalhada de cada parâmetro.

Argumentos do rastreador

Alguns comportamentos de rastreamento podem ser ajustados editando os arquivos de configuração YAML específicos para cada algoritmo de rastreamento. Esses arquivos definem parâmetros como limites, buffers e lógica de correspondência:

• botsort.yaml
• bytetrack.yaml

A tabela a seguir fornece uma descrição de cada parâmetro:

Habilitando a Reidentificação (ReID)

Por padrão, o ReID é desligado para minimizar a sobrecarga de desempenho. Habilitá-lo é simples—basta definir with_reid: True na configuração do rastreador. Você também pode customizar o model usado para ReID, permitindo equilibrar precisão e velocidade dependendo do seu caso de uso:

• Recursos nativos (model: auto): Isso aproveita recursos diretamente do detector YOLO para ReID, adicionando sobrecarga mínima. É ideal quando você precisa de algum nível de ReID sem impactar significativamente o desempenho. Se o detector não suportar recursos nativos, ele retorna automaticamente para usar yolo26n-cls.pt.
• Modelos de classificação YOLO: Você pode definir explicitamente um modelo de classificação (por exemplo, yolo26n-cls.pt) para extração de recursos ReID. Isso fornece incorporações mais discriminativas, mas introduz latência adicional devido à etapa extra de inferência.

Para melhor desempenho, especialmente ao usar um modelo de classificação separado para ReID, você pode exportá-lo 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", half=True, dynamic=True, batch=32)

Uma vez exportado, você pode apontar para o caminho do modelo TensorRT na sua configuração de rastreador, e ele será usado para ReID durante o rastreamento.

Exemplos em Python

Loop de persistência de rastreamentos

Aqui está um script 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
        results = model.track(frame, persist=True)

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

Observe a mudança de model(frame) para model.track(frame), que habilita o rastreamento de objetos em vez da 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 encerrado pressionando 'q'.

Plotando rastreamentos ao longo do tempo

Visualizar rastreamentos de objetos em quadros consecutivos pode fornecer percepções valiosas sobre os padrões de movimento e comportamento de objetos detectados em um vídeo. Com o Ultralytics YOLO26, plotar esses rastreamentos é um processo contínuo e eficiente.

No exemplo a seguir, demonstramos como utilizar as capacidades 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(lambda: [])

# 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 fornece a capacidade de executar o rastreamento de objetos em múltiplos fluxos de vídeo simultaneamente. Isso é particularmente útil ao lidar com múltiplas entradas de vídeo, como de múltiplas câmeras de vigilância, onde o processamento concorrente pode melhorar muito a eficiência e o desempenho.

No script Python fornecido, fazemos uso do módulo threading do Python para executar múltiplas 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 simultaneamente em segundo plano.

Para garantir que cada thread receba os parâmetros corretos (o arquivo de vídeo, o modelo a usar 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 terem concluído 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): The YOLO26 model object.
        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.

Contribuir com novos rastreadores

Tens experiência em rastreamento de múltiplos objetos e implementaste ou adaptaste com sucesso um algoritmo de rastreamento com Ultralytics YOLO? Convidamo-te a contribuir para a nossa secção de 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 secção, ajudas a expandir o âmbito das soluções de rastreamento disponíveis na estrutura Ultralytics YOLO, adicionando outra camada de funcionalidade e utilidade para a comunidade.

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

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

FAQ

O que é o rastreamento de múltiplos objetos e como é que o Ultralytics YOLO o suporta?

O rastreamento de múltiplos objetos em análise de vídeo envolve tanto a identificação de objetos como a manutenção de um ID único para cada objeto detetado ao longo dos frames do vídeo. O Ultralytics YOLO suporta isto fornecendo rastreamento em tempo real juntamente com IDs de objetos, facilitando tarefas como vigilância de segurança e análise desportiva. O sistema utiliza trackers como BoT-SORT e ByteTrack, que podem ser configurados através de ficheiros YAML.

Como configuro um tracker personalizado para o Ultralytics YOLO?

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

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Como posso executar o rastreamento de objetos em múltiplos fluxos de vídeo simultaneamente?

Para executar o rastreamento de objetos em múltiplos fluxos de vídeo simultaneamente, podes usar o módulo threading do Python. Cada thread tratará de um fluxo de vídeo separado. Aqui tens um exemplo de como podes configurar isto:

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): The YOLO26 model object.
        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()

Quais são as aplicações no mundo real do rastreamento de múltiplos objetos com Ultralytics YOLO?

O rastreamento de múltiplos objetos com 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álises dentro da loja e segurança.
• Aquicultura: Rastreamento de peixes para monitorização de ambientes aquáticos.
• Análise Desportiva: Rastreamento de jogadores e equipamentos para análise de desempenho.
• Sistemas de Segurança: Monitorização de atividades suspeitas e criação de alarmes de segurança.

Estas aplicações beneficiam da capacidade do Ultralytics YOLO de processar vídeos com alta taxa de frames em tempo real com uma precisão excecional.

Como posso visualizar rastreios de objetos ao longo de múltiplos frames de vídeo com o Ultralytics YOLO?

Para visualizar rastreios de objetos ao longo de múltiplos frames de vídeo, podes usar as funcionalidades de rastreamento do modelo YOLO juntamente com o OpenCV para desenhar os caminhos dos objetos detetados. Aqui tens um exemplo de script que demonstra isto:

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(lambda: [])

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        boxes = results[0].boxes.xywh.cpu()
        track_ids = results[0].boxes.id.int().cpu().tolist()
        annotated_frame = results[0].plot()
        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 irá desenhar as linhas de rastreamento mostrando os caminhos de movimento dos objetos rastreados ao longo do tempo, fornecendo informações valiosas sobre o comportamento e padrões dos objetos.