Ultralytics YOLO ile Çoklu Nesne Takibi

Video analizleri alanında nesne takibi, yalnızca çerçeve içindeki nesnelerin konumunu ve sınıfını belirlemekle kalmayıp, aynı zamanda video ilerledikçe algılanan her nesne için benzersiz bir kimlik tutan kritik bir görevdir. Uygulamalar sınırsızdır; gözetim ve güvenlikten gerçek zamanlı spor analizlerine kadar uzanır.

Nesne Takibi için Neden Ultralytics YOLO'yu Seçmelisiniz?

Ultralytics izleyicilerinden elde edilen çıktı, standart nesne tespiti ile tutarlıdır, ancak nesne kimliklerinin ek değeri vardır. Bu, video akışlarındaki nesneleri izlemeyi ve sonraki analizleri gerçekleştirmeyi kolaylaştırır. Nesne izleme ihtiyaçlarınız için neden Ultralytics YOLO'yu kullanmayı düşünmelisiniz:

• Verimlilik: Doğruluktan ödün vermeden video akışlarını gerçek zamanlı olarak işleyin.
• Esneklik: Birden çok izleme algoritmasını ve yapılandırmasını destekler.
• Kullanım Kolaylığı: Hızlı entegrasyon ve dağıtım için basit Python API'si ve CLI seçenekleri.
• Özelleştirilebilirlik: Özel eğitilmiş YOLO modelleriyle kullanımı kolaydır ve alana özgü uygulamalara entegrasyona olanak tanır.

İzle: Ultralytics YOLO ile Nesne Tespiti ve İzleme.

Gerçek Dünya Uygulamaları

Taşıma	Perakende	Su Ürünleri Yetiştiriciliği
Araç Takibi	İnsan Takibi	Balık Takibi

Bir Bakışta Özellikler

Ultralytics YOLO, nesne algılama özelliklerini, sağlam ve çok yönlü nesne takibi sağlamak için genişletir:

• Gerçek Zamanlı İzleme: Yüksek kare hızlı videolarda nesneleri sorunsuz bir şekilde izleyin.
• Çoklu İzleyici Desteği: Yerleşik izleme algoritmaları arasından seçim yapın.
• Özelleştirilebilir İzleyici Yapılandırmaları: Çeşitli parametreleri ayarlayarak izleme algoritmasını belirli gereksinimleri karşılayacak şekilde uyarlayın.

Mevcut İzleyiciler

Ultralytics YOLO, aşağıdaki izleme algoritmalarını destekler. İlgili YAML yapılandırma dosyası geçirilerek etkinleştirilebilirler, örneğin tracker=tracker_type.yaml:

• BoT-SORT - Kullanım botsort.yaml bu izleyiciyi etkinleştirmek için.
• ByteTrack - Kullanım bytetrack.yaml bu izleyiciyi etkinleştirmek için.

Varsayılan izleyici BoT-SORT'tur.

İzleme

İzleyiciyi video akışlarında çalıştırmak için YOLO11n, YOLO11n-seg ve YOLO11n-pose gibi eğitilmiş bir Detect, Segment veya Pose modeli kullanın.

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"

Yukarıdaki kullanımda görülebileceği gibi, izleme, videolar veya akış kaynaklarında çalışan tüm Algılama, Segmentasyon ve Poz modelleri için kullanılabilir.

Yapılandırma

İzleme Argümanları

İzleme yapılandırması, Tahmin modu ile özellikleri paylaşır, örneğin conf, iouve show. Daha fazla yapılandırma için şuraya bakın: Tahmin et model sayfası.

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

İzleyici Seçimi

Ultralytics ayrıca değiştirilmiş bir izleyici yapılandırma dosyası kullanmanıza da olanak tanır. Bunu yapmak için, bir izleyici yapılandırma dosyasının bir kopyasını alın (örneğin, custom_tracker.yaml) şuradan ultralytics/cfg/trackers ve herhangi bir yapılandırmayı değiştirin (hariç tracker_type) ihtiyaçlarınıza göre.

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'

Her bir parametrenin ayrıntılı açıklaması için İzleyici Argümanları bölümüne bakın.

İzleyici Argümanları

Bazı izleme davranışları, her izleme algoritmasına özel YAML yapılandırma dosyaları düzenlenerek ince ayar yapılabilir. Bu dosyalar, eşikler, arabellekler ve eşleme mantığı gibi parametreleri tanımlar:

• botsort.yaml
• bytetrack.yaml

Aşağıdaki tabloda her bir parametrenin açıklaması verilmiştir:

Yeniden Tanımlamayı (ReID) Etkinleştirme

Varsayılan olarak, ReID performans yükünü en aza indirmek için kapalıdır. Etkinleştirmek basittir—sadece şunu ayarlayın: with_reid: True içinde izleyici yapılandırması. Ayrıca şunu da özelleştirebilirsiniz: model ReID için kullanılır ve kullanım durumunuza bağlı olarak doğruluk ve hız arasında denge kurmanıza olanak tanır:

• Yerel özellikler (model: auto): Bu, ReID için doğrudan YOLO dedektöründen özellikler kullanır ve minimum ek yük getirir. Performansı önemli ölçüde etkilemeden bir miktar ReID'ye ihtiyaç duyduğunuzda idealdir. Dedektör yerel özellikleri desteklemiyorsa, otomatik olarak şuna geri döner: yolo11n-cls.pt.
• YOLO sınıflandırma modelleri: Açıkça bir sınıflandırma modeli ayarlayabilirsiniz (örneğin, yolo11n-cls.pt) ReID özellik çıkarımı için. Bu, daha ayırt edici gömmeler sağlar, ancak ek çıkarım adımı nedeniyle ek gecikme süresi getirir.

Daha iyi performans için, özellikle ReID için ayrı bir sınıflandırma modeli kullanırken, onu TensorRT gibi daha hızlı bir arka uca aktarabilirsiniz:

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)

Dışa aktarıldıktan sonra, izleyici yapılandırmanızda TensorRT model yolunu belirtebilirsiniz ve bu, izleme sırasında ReID için kullanılacaktır.

python Örnekleri

İzleri Döngüde Kalıcı Hale Getirme

İşte kullanarak bir Python betiği OpenCV (cv2) ve video karelerinde nesne takibi çalıştırmak için YOLO11. Bu betik hala gerekli paketleri zaten kurduğunuzu varsayar (opencv-python ve ultralytics). Şunu persist=True argümanı, izleyiciye mevcut görüntünün veya çerçevenin bir dizideki bir sonraki görüntü veya çerçeve olduğunu ve önceki görüntüdeki izlerin mevcut görüntüde beklenmesi gerektiğini söyler.

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

Şu değişikliklere dikkat edin: model(frame) için model.track(frame), bu da basit algılama yerine nesne takibini sağlar. Bu değiştirilmiş komut dosyası, izleyiciyi videonun her karesinde çalıştıracak, sonuçları görselleştirecek ve bir pencerede görüntüleyecektir. Döngüden 'q' tuşuna basılarak çıkılabilir.

Zaman İçinde İzleri Çizme

Ardışık kareler üzerinde nesne izlerini görselleştirmek, bir video içindeki algılanan nesnelerin hareket örüntüleri ve davranışları hakkında değerli bilgiler sağlayabilir. Ultralytics YOLO11 ile bu izleri çizmek kusursuz ve verimli bir işlemdir.

Aşağıdaki örnekte, algılanan nesnelerin hareketini birden çok video karesi boyunca çizmek için YOLO11'in izleme yeteneklerinden nasıl yararlanılacağını gösteriyoruz. Bu betik, bir video dosyasını açmayı, kare kare okumayı ve çeşitli nesneleri tanımlamak ve izlemek için YOLO modelini kullanmayı içerir. Algılanan sınırlayıcı kutuların merkez noktalarını koruyarak ve bunları birbirine bağlayarak, izlenen nesnelerin izlediği yolları temsil eden çizgiler çizebiliriz.

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

Çoklu İş Parçacıklı İzleme

Çoklu iş parçacıklı izleme, nesne takibini aynı anda birden fazla video akışında çalıştırma yeteneği sağlar. Bu, eş zamanlı işlemenin verimliliği ve performansı büyük ölçüde artırabileceği birden fazla gözetim kamerasından gelenler gibi birden fazla video girişini işlerken özellikle yararlıdır.

Sağlanan Python betiğinde, Python'ın özelliklerinden yararlanıyoruz. threading izleyiciyi eşzamanlı olarak birden çok örnekte çalıştırmak için modülü. Her iş parçacığı, izleyiciyi bir video dosyasında çalıştırmaktan sorumludur ve tüm iş parçacıkları aynı anda arka planda çalışır.

Her iş parçacığının doğru parametreleri (video dosyası, kullanılacak model ve dosya dizini) almasını sağlamak için bir fonksiyon tanımlıyoruz run_tracker_in_thread bu parametreleri kabul eden ve ana izleme döngüsünü içeren. Bu fonksiyon, video karesini kare kare okur, izleyiciyi çalıştırır ve sonuçları görüntüler.

Bu örnekte iki farklı model kullanılmaktadır: yolo11n.pt ve yolo11n-seg.pt, her biri farklı bir video dosyasındaki nesneleri izler. Video dosyaları şurada belirtilir: SOURCES.

daemon=True parametresi içinde threading.Thread bu, ana program biter bitmez bu iş parçacıklarının kapatılacağı anlamına gelir. Daha sonra iş parçacıklarını şununla başlatırız: start() ve şunu kullanın join() ana iş parçacığının, her iki izleyici iş parçacığı da bitene kadar beklemesini sağlamak için.

Son olarak, tüm iş parçacıkları görevlerini tamamladıktan sonra, sonuçları görüntüleyen pencereler kullanılarak kapatılır. 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()

Bu örnek, daha fazla iş parçacığı oluşturarak ve aynı metodolojiyi uygulayarak daha fazla video dosyası ve modeli işleyecek şekilde kolayca genişletilebilir.

Yeni İzleyiciler Ekleyin

Çoklu nesne takibi konusunda uzmansanız ve Ultralytics YOLO ile bir izleme algoritmasını başarıyla uyguladıysanız veya uyarladıysanız? Sizi ultralytics/cfg/trackers'daki İzleyiciler bölümümüze katkıda bulunmaya davet ediyoruz! Gerçek dünya uygulamalarınız ve çözümleriniz, izleme görevleri üzerinde çalışan kullanıcılar için paha biçilmez olabilir.

Bu bölüme katkıda bulunarak, Ultralytics YOLO çerçevesi içinde mevcut olan izleme çözümlerinin kapsamını genişletmeye yardımcı olur, topluluk için başka bir işlevsellik ve fayda katmanı eklersiniz.

Katkıda bulunmaya başlamak için lütfen Çekme İsteği (PR) gönderme konusunda kapsamlı talimatlar için Katkıda Bulunma Kılavuzumuza bakın 🛠️. Masaya ne getireceğinizi görmek için heyecanlıyız!

Ultralytics YOLO ekosisteminin izleme yeteneklerini birlikte geliştirelim 🙏!

SSS

Çoklu Nesne İzleme (Multi-Object Tracking) nedir ve Ultralytics YOLO bunu nasıl destekler?

Video analizinde çoklu nesne takibi, hem nesneleri tanımlamayı hem de video kareleri boyunca algılanan her nesne için benzersiz bir kimlik sağlamayı içerir. Ultralytics YOLO, nesne kimlikleriyle birlikte gerçek zamanlı izleme sağlayarak bunu destekler ve güvenlik gözetimi ve spor analitiği gibi görevleri kolaylaştırır. Sistem, YAML dosyaları aracılığıyla yapılandırılabilen BoT-SORT ve ByteTrack gibi izleyiciler kullanır.

Ultralytics YOLO için özel bir izleyiciyi nasıl yapılandırırım?

Mevcut bir izleyici yapılandırma dosyasını (örneğin, custom_tracker.yaml) şuradan: Ultralytics izleyici yapılandırma dizini ve gerektiğinde parametreleri değiştirerek, hariç tracker_typeBu dosyayı izleme modelinizde şu şekilde kullanın:

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'

Aynı anda birden fazla video akışında nesne takibini nasıl çalıştırabilirim?

Aynı anda birden fazla video akışında nesne takibi çalıştırmak için Python'ı kullanabilirsiniz. threading modülü. Her iş parçacığı ayrı bir video akışını işleyecektir. İşte bunu nasıl ayarlayabileceğinize dair bir örnek:

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

Ultralytics YOLO ile çoklu nesne takibinin gerçek dünya uygulamaları nelerdir?

Ultralytics YOLO ile çoklu nesne takibinin çok sayıda uygulaması vardır, bunlar arasında şunlar yer alır:

• Ulaşım: Trafik yönetimi ve otonom sürüş için araç takibi.
• Perakende: Mağaza içi analiz ve güvenlik için insan takibi.
• Su Ürünleri Yetiştiriciliği: Su ortamlarını izlemek için balık takibi.
• Spor Analitiği: Performans analizi için oyuncuları ve ekipmanları takip etme.
• Güvenlik Sistemleri: Şüpheli faaliyetleri izleme ve güvenlik alarmları oluşturma.

Bu uygulamalar, Ultralytics YOLO'nun yüksek kare hızlı videoları olağanüstü doğrulukla gerçek zamanlı olarak işleme yeteneğinden yararlanır.

Ultralytics YOLO ile birden fazla video karesi üzerinde nesne izlerini nasıl görselleştirebilirim?

Birden çok video karesi üzerinde nesne izlerini görselleştirmek için, algılanan nesnelerin yollarını çizmek üzere YOLO modelinin izleme özelliklerini OpenCV ile birlikte kullanabilirsiniz. İşte bunu gösteren bir örnek komut dosyası:

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

Bu betik, izlenen nesnelerin zaman içindeki hareket yollarını gösteren izleme çizgilerini çizerek, nesne davranışı ve kalıpları hakkında değerli bilgiler sağlar.

📅 1 yıl önce oluşturuldu ✏️ 23 gün önce güncellendi

Yorumlar