Ultralytics YOLO ile Çoklu Nesne Takibi

Video analitiği alanında nesne takibi, yalnızca kare içindeki nesnelerin konumunu ve sınıfını belirlemekle kalmayıp, aynı zamanda video ilerledikçe her bir tespit edilen nesne için benzersiz bir kimliği koruyan kritik bir görevdir. Uygulama alanları, gözetim ve güvenlikten gerçek zamanlı spor analitiğine kadar sınırsızdır.

Neden Nesne Takibi İçin Ultralytics YOLO Seçmelisin?

Ultralytics takipçilerinden alınan çıktı, standart nesne tespiti ile tutarlıdır ancak nesne kimlikleri gibi ek bir değer sunar. Bu, video akışlarındaki nesneleri takip etmeyi ve sonraki analizleri gerçekleştirmeyi kolaylaştırır. İşte nesne takibi ihtiyaçların için Ultralytics YOLO kullanmayı düşünmen gereken nedenler:

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

Gerçek Dünya Uygulamaları

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

Özelliklere Bir Bakış

Ultralytics YOLO, güçlü ve çok yönlü nesne takibi sağlamak için nesne tespiti özelliklerini genişletir:

• Gerçek Zamanlı Takip: Yüksek kare hızlı videolarda nesneleri kesintisiz takip et.
• Çoklu Takipçi Desteği: Çeşitli yerleşik takip algoritmaları arasından seçim yap.
• Özelleştirilebilir Takipçi Yapılandırmaları: Çeşitli parametreleri ayarlayarak takip algoritmasını özel gereksinimlerine göre uyarla.

Mevcut Takipçiler

Ultralytics YOLO aşağıdaki takip algoritmalarını destekler. Bunlar, tracker=tracker_type.yaml gibi ilgili YAML yapılandırma dosyası geçilerek etkinleştirilebilir:

• BoT-SORT - Bu takipçiyi etkinleştirmek için botsort.yaml kullan.
• ByteTrack - Bu takipçiyi etkinleştirmek için bytetrack.yaml kullan.

Varsayılan takipçi BoT-SORT'tur.

Takip

Takipçiyi video akışlarında çalıştırmak için YOLO26n, YOLO26n-seg veya YOLO26n-pose gibi eğitilmiş bir Tespit, Segment veya Poz modeli kullan. Özel modelleri yerel olarak veya Ultralytics Platform üzerinden bulut GPU'larında eğitebilirsin.

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

Yukarıdaki kullanımda görülebileceği gibi, takip özelliği videolarda veya akış kaynaklarında çalıştırılan tüm Tespit, Segment ve Poz modelleri için mevcuttur.

Yapılandırma

Takip Bağımsız Değişkenleri

Takip yapılandırması; conf, iou ve show gibi Predict modu ile ortak özelliklere sahiptir. Diğer yapılandırmalar için Predict model sayfasına başvur.

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)

Takipçi Seçimi

Ultralytics also allows you to use a modified tracker configuration file. To do this, simply make a copy of a tracker config file (for example, custom_tracker.yaml) from ultralytics/cfg/trackers and modify any configurations (except the tracker_type) as per your needs.

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

Her parametrenin ayrıntılı açıklaması için Takipçi Bağımsız Değişkenleri bölümüne bak.

Takipçi Bağımsız Değişkenleri

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

• botsort.yaml
• bytetrack.yaml

Aşağıdaki tablo her parametrenin açıklamasını sağlar:

Yeniden Tanımlamayı (ReID) Etkinleştirme

By default, ReID is turned off to minimize performance overhead. Enabling it is simple—just set with_reid: True in the tracker configuration. You can also customize the model used for ReID, allowing you to trade off accuracy and speed depending on your use case:

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

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 aktarabilirsin:

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)

Dışa aktarıldıktan sonra, takipçi yapılandırmanda TensorRT model yolunu gösterebilirsin; takip sırasında ReID için bu model kullanılacaktır.

Python Örnekleri

Kalıcı Takip Döngüsü

İşte video karelerinde nesne takibi çalıştırmak için OpenCV (cv2) ve YOLO26 kullanan bir Python betiği. Bu betik, gerekli paketlerin (opencv-python ve ultralytics) zaten kurulu olduğunu varsayar. persist=True bağımsız değişkeni, takipçiye mevcut görüntünün veya karenin bir dizideki bir sonraki öğe olduğunu ve mevcut görüntüde önceki görüntüden gelen takip beklentisinde olmasını söyler.

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

Lütfen model(frame) yerine basit tespit yerine nesne takibini etkinleştiren model.track(frame) kullanımına geçiş yapıldığına dikkat et. Bu değiştirilmiş betik, takipçiyi 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.

Takipleri Zaman İçinde Çizdirme

Nesne takiplerini ardışık kareler üzerinde görselleştirmek, bir video içindeki tespit edilen nesnelerin hareket modelleri ve davranışları hakkında değerli bilgiler sağlayabilir. Ultralytics YOLO26 ile bu takiplerin çizdirilmesi sorunsuz ve verimli bir süreçtir.

Aşağıdaki örnekte, tespit edilen nesnelerin hareketini birden fazla video karesi üzerinde çizdirmek için YOLO26'nın takip yeteneklerinden nasıl yararlanılacağını gösteriyoruz. Bu betik; bir video dosyası açmayı, kare kare okumayı ve çeşitli nesneleri tanımlamak ve takip etmek için YOLO modelini kullanmayı içerir. Tespit edilen sınırlayıcı kutuların (bounding boxes) merkez noktalarını tutarak ve bunları birleştirerek, takip edilen nesnelerin izlediği yolları temsil eden çizgiler çizebiliriz.

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

Çok İş parçacıklı (Multithreaded) Takip

Çok iş parçacıklı takip, aynı anda birden fazla video akışında nesne takibi ç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üvenlik kamerası gibi birden fazla video girişiyle uğraşırken özellikle yararlıdır.

Sunulan Python betiğinde, takipçinin birden fazla örneğini aynı anda çalıştırmak için Python'un threading modülünü kullanıyoruz. Her iş parçacığı, bir video dosyasında takipçiyi çalıştırmaktan sorumludur ve tüm iş parçacıkları arka planda eşzamanlı olarak çalışır.

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

Bu örnekte iki farklı model kullanılmıştır: yolo26n.pt ve yolo26n-seg.pt, her biri farklı bir video dosyasındaki nesneleri takip eder. Video dosyaları SOURCES içinde belirtilmiştir.

The daemon=True parameter in threading.Thread means that these threads will be closed as soon as the main program finishes. We then start the threads with start() and use join() to make the main thread wait until both tracker threads have finished.

Son olarak, tüm iş parçacıkları görevlerini tamamladıktan sonra, sonuçları gösteren pencereler cv2.destroyAllWindows() kullanılarak kapatılır.

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

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

Yeni Takipçilere Katkıda Bulun

Çoklu nesne takibi konusunda yetkin misin ve Ultralytics YOLO ile bir takip algoritmasını başarıyla uyguladın veya uyarladın mı? Seni ultralytics/cfg/trackers içindeki Takipçiler bölümümüze katkıda bulunmaya davet ediyoruz! Gerçek dünya uygulamaların ve çözümlerin, takip 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çindeki mevcut takip çözümlerinin kapsamını genişletmeye ve topluluk için bir işlevsellik ve yararlılık katmanı daha eklemeye yardımcı olursun.

Katkını başlatmak için, bir Pull Request (PR) göndermeye dair kapsamlı talimatlar için lütfen Katkıda Bulunma Rehberimize başvur 🛠️. Neler sunacağını görmek için heyecanlıyız!

Hadi, Ultralytics YOLO ekosisteminin takip yeteneklerini hep birlikte geliştirelim 🙏!

SSS

Çoklu Nesne Takibi nedir ve Ultralytics YOLO bunu nasıl destekler?

Video analitiğinde çoklu nesne takibi, hem nesnelerin tanımlanmasını hem de video kareleri boyunca tespit edilen her nesne için benzersiz bir ID'nin korunmasını içerir. Ultralytics YOLO, nesne ID'leri ile birlikte gerçek zamanlı takip sağlayarak bunu destekler ve güvenlik gözetimi ile spor analitiği gibi görevleri kolaylaştırır. Sistem, BoT-SORT ve ByteTrack gibi YAML dosyaları aracılığıyla yapılandırılabilen takipçiler kullanır.

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

Mevcut bir takipçi yapılandırma dosyasını (örneğin custom_tracker.yaml) Ultralytics takipçi yapılandırma dizininden kopyalayıp tracker_type hariç parametreleri gerektiği gibi değiştirerek özel bir takipçi yapılandırabilirsin. Bu dosyayı takip modelinde şu şekilde kullan:

from ultralytics import YOLO

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

Birden fazla video akışında aynı anda nasıl nesne takibi çalıştırabilirim?

Birden fazla video akışında aynı anda nesne takibi çalıştırmak için Python'ın threading modülünü kullanabilirsin. Her iş parçacığı ayrı bir video akışını işleyecektir. Bunu nasıl ayarlayabileceğine dair bir örnek:

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

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

Ultralytics YOLO ile çoklu nesne takibinin aşağıdakiler dahil birçok uygulaması vardır:

• Ulaşım: Trafik yönetimi ve otonom sürüş için araç takibi.
• Perakende: Mağaza içi analitik 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 oyuncu ve ekipman takibi.
• Güvenlik Sistemleri: Şüpheli aktiviteleri izleme ve güvenlik alarmları oluşturma.

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

Ultralytics YOLO ile çoklu video kareleri üzerinde nesne izlerini nasıl görselleştirebilirim?

Nesne izlerini çoklu video kareleri üzerinde görselleştirmek için, YOLO modelinin takip özelliklerini OpenCV ile birlikte kullanarak tespit edilen nesnelerin yollarını çizebilirsin. İşte bunu gösteren örnek bir betik:

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

Bu betik, takip edilen nesnelerin zaman içindeki hareket yollarını gösteren takip çizgilerini çizecek ve nesne davranışı ve desenleri hakkında değerli bilgiler sağlayacaktır.