Rastreamento de Múltiplos Objetos com Ultralytics YOLO

O rastreamento de objetos no campo da análise de vídeo é uma tarefa crítica que não só identifica a localização e a classe de objetos dentro do frame, 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 — variando de vigilância e segurança a análises esportivas em tempo real.

Por que escolher 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 adicional de IDs de objetos. Isso facilita o rastreamento de objetos em fluxos de vídeo e a realização de análises subsequentes. Aqui está o porquê você deve considerar usar Ultralytics YOLO para 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: API python simples e opções de CLI para rápida integração e implantação.
• Personalização: Fácil de usar com modelos YOLO treinados personalizados, permitindo a integração em aplicações específicas do domínio.

Assista: Detecção e Rastreamento de Objetos com Ultralytics YOLO.

Aplicações no Mundo Real

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

Recursos em resumo

Ultralytics YOLO estende seus recursos de detecção de objetos para fornecer 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 Personalizáveis: Adapte o algoritmo de rastreamento para atender a requisitos específicos, ajustando vários parâmetros.

Trackers disponíveis

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

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

O rastreador padrão é o BoT-SORT.

Rastreamento

Para executar o rastreador em fluxos de vídeo, use um modelo treinado de Detect, Segment ou Pose, como YOLO11n, YOLO11n-seg e YOLO11n-pose.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolo11n.pt")  # Load an official Detect model
model = YOLO("yolo11n-seg.pt")  # Load an official Segment model
model = YOLO("yolo11n-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

# Perform tracking with various models using the command line interface
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4"      # Official Detect model
yolo track model=yolo11n-seg.pt source="https://youtu.be/LNwODJXcvt4"  # Official Segment model
yolo track model=yolo11n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Official Pose model
yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Custom trained model

# Track using ByteTrack tracker
yolo track model=path/to/best.pt tracker="bytetrack.yaml"

Como pode ser visto no uso acima, o rastreamento está disponível para todos os modelos Detect, Segment 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 Predict, como conf, iou, e show. Para mais configurações, consulte a página do Prever modelo.

from ultralytics import YOLO

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

# Configure tracking parameters and run the tracker using the command line interface
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show

Seleção de Tracker

Ultralytics também permite que você use um arquivo de configuração de rastreador modificado. Para fazer isso, simplesmente faça 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) de acordo com suas necessidades.

from ultralytics import YOLO

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

# Load the model and run the tracker with a custom configuration file using the command line interface
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

Consulte a seção Argumentos do Tracker para 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 de 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:

Ativando a Re-Identificação (ReID)

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

• Recursos nativos (model: auto): Isto aproveita as funcionalidades diretamente do detetor YOLO para ReID, adicionando uma sobrecarga mínima. É ideal quando precisa de algum nível de ReID sem afetar significativamente o desempenho. Se o detetor não suportar funcionalidades nativas, ele automaticamente volta a usar yolo11n-cls.pt.
• Modelos de classificação YOLO: Pode definir explicitamente um modelo de classificação (por exemplo, yolo11n-cls.pt) para extração de características ReID. Isso fornece embeddings mais discriminativos, mas introduz latência adicional devido à etapa de inferência extra.

Para um 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("yolo11n-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 YOLO11 para executar o rastreamento de objetos em quadros de vídeo. Este script ainda assume que você já instalou os pacotes necessários (opencv-python e ultralytics). O argumento persist=True informa 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 YOLO11 model
model = YOLO("yolo11n.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 YOLO11 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("YOLO11 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()

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

Plotagem de Rastreamentos ao Longo do Tempo

Visualizar os rastros de objetos em frames 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 YOLO11, plotar esses rastros é um processo contínuo e eficiente.

No exemplo a seguir, demonstramos como utilizar os recursos de rastreamento do YOLO11 para plotar o movimento de objetos detectados em vários frames de vídeo. Este script envolve abrir um arquivo 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 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 YOLO11 model
model = YOLO("yolo11n.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 YOLO11 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("YOLO11 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 várias entradas de vídeo, como de várias câmeras de vigilância, onde o processamento simultâneo pode aumentar 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 todos os threads são executados simultaneamente 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 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 usados neste exemplo: yolo11n.pt e yolo11n-seg.pt, cada um rastreando objetos em um arquivo de vídeo diferente. Os arquivos de vídeo são especificados no parâmetro SOURCES.

O daemon=True em threading.Thread significa que esses threads serão fechados assim que o programa principal terminar. Em seguida, iniciamos os threads com start() e usamos join() para fazer com que o thread principal espere até que ambos os threads do rastreador tenham terminado.

Finalmente, após todos os 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 = ["yolo11n.pt", "yolo11n-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 YOLO11 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

Você é proficiente em rastreamento de múltiplos objetos e implementou ou adaptou com sucesso um algoritmo de rastreamento com Ultralytics YOLO? Convidamos você a contribuir para nossa seção de Trackers em ultralytics/cfg/trackers! Suas aplicações e soluções do mundo real podem ser inestimáveis para usuários 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 dentro da estrutura Ultralytics YOLO, adicionando outra camada de funcionalidade e utilidade para a comunidade.

Para iniciar sua contribuição, consulte nosso Guia de Contribuição para obter instruções abrangentes sobre como enviar um Pull Request (PR) 🛠️. Estamos animados para ver o que você trará para a mesa!

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

FAQ

O que é Rastreamento de Múltiplos Objetos e como o Ultralytics YOLO o suporta?

O rastreamento de multi-objetos em análise de vídeo envolve tanto a identificação de objetos quanto a manutenção de um ID exclusivo para cada objeto detectado em todos os frames do vídeo. O Ultralytics YOLO suporta isso, fornecendo rastreamento em tempo real junto com IDs de objetos, facilitando tarefas como vigilância de segurança e análise esportiva. O sistema usa rastreadores como BoT-SORT e ByteTrack, que podem ser configurados através de arquivos YAML.

Como configuro um rastreador personalizado para Ultralytics YOLO?

Você pode configurar um tracker personalizado copiando um arquivo de configuração de tracker existente (por exemplo, custom_tracker.yaml) do diretório de configuração do tracker Ultralytics e modificando os parâmetros conforme necessário, exceto para o tracker_type. Use este arquivo no seu modelo de rastreamento da seguinte forma:

from ultralytics import YOLO

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

yolo track model=yolo11n.pt 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 vários fluxos de vídeo simultaneamente, você pode usar o módulo threading python. Cada thread lidará com um fluxo de vídeo separado. Aqui está um exemplo de como você pode configurar isso:

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo11n.pt", "yolo11n-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 YOLO11 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 do mundo real do rastreamento de múltiplos objetos com Ultralytics YOLO?

O rastreamento de multi-objetos com Ultralytics YOLO tem inúmeras aplicações, incluindo:

• Transporte: Rastreamento de veículos para gestão de tráfego e direção autônoma.
• Varejo: Rastreamento de pessoas para análise e segurança em lojas.
• Aquicultura: Rastreamento de peixes para monitoramento de ambientes aquáticos.
• Análise Desportiva: Rastreamento de jogadores e equipamentos para análise de desempenho.
• Sistemas de Segurança: Monitoramento 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 de alta taxa de quadros em tempo real com excepcional precisão.

Como posso visualizar rastreamentos de objetos em múltiplos frames de vídeo com Ultralytics YOLO?

Para visualizar os rastros de objetos em vários quadros de vídeo, você pode usar os recursos de rastreamento do modelo YOLO juntamente com o OpenCV para desenhar os caminhos dos objetos detectados. Aqui está um script de exemplo que demonstra isso:

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

model = YOLO("yolo11n.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("YOLO11 Tracking", annotated_frame)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break
cap.release()
cv2.destroyAllWindows()

Este script irá plotar as linhas de rastreamento mostrando os caminhos de movimento dos objetos rastreados ao longo do tempo, fornecendo informações valiosas sobre o comportamento e os padrões dos objetos.

📅 Criado há 1 ano ✏️ Atualizado há 25 dias

Comentários