Ultralytics YOLO ile Çoklu Nesne Takibi#

Video analitiği alanında nesne takibi, nesnelerin çerçeve içindeki konumunu ve sınıfını tanımlamakla kalmayıp, video ilerledikçe her bir algılanan nesne için benzersiz bir kimlik (ID) tutan kritik bir görevdir. Uygulama alanları sınırsızdır; gözetim ve güvenlikten gerçek zamanlı spor analitiğine kadar uzanır.

Nesne Takibi İçin Neden Ultralytics YOLO'yu Seçmelisin?#

Ultralytics izleyicilerinden elde edilen çıktı, standart nesne tespiti ile tutarlıdır ancak ek bir değer olarak nesne kimlikleri (ID) sunar. Bu, video akışlarındaki nesneleri izlemeyi ve ardından gelen analitikleri gerçekleştirmeyi kolaylaştırır. Nesne izleme ihtiyaçların için Ultralytics YOLO kullanmayı düşünmen gereken sebepler şunlardır:

• Verimlilik: Doğruluktan ödün vermeden video akışlarını gerçek zamanlı olarak işle.
• Esneklik: Birden fazla takip algoritmasını ve yapılandırmayı 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 kolayca kullanılabilir, böylece etki alanına özgü uygulamalara entegrasyon sağlar.

Gerçek Dünya Uygulamaları#

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

Hızlı Başlangıç#

Varsayılan BoT-SORT izleyicisi ile bir videoda izleme çalıştır. tracker argümanını değiştirerek başka bir izleyiciye geçiş yap.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Default tracker (BoT-SORT)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

# Switch to ByteTrack
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

Video akışlarında izleyiciyi çalıştırmak için YOLO26n, YOLO26n-seg, YOLO26n-pose veya YOLO26n-obb gibi eğitilmiş bir Detect, Segment, Pose veya OBB modeli kullan. Özel modelleri yerel olarak veya Ultralytics Platform bulut eğitimi ile 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

Desteklenen Takipçiler#

Ultralytics YOLO, altı yerleşik izleyici ile birlikte gelir. YAML yapılandırma dosyasını tracker argümanına ileterek birini etkinleştir.

Hangi Takipçiyi Kullanmalıyım?#

Bir başlangıç noktası seçmek için bu akışı kullan:

1. En hızlı, en basit temel modele mi ihtiyacın var? → ByteTrack (ReID yok, kamera hareketi dengeleme yok, minimum ek yük).
2. Elde tutulan, drone veya hareketli kamera görüntüleri mi? → BoT-SORT (varsayılan; kamera hareketi dengeleme ve isteğe bağlı ReID ekler).
3. Doğrusal olmayan hareket (spor, dans, ani dönüşler) ve ReID gerekmiyor mu? → OC-SORT (görünüm maliyeti olmadan gözlem odaklı düzeltmeler).
4. Kimlik değişimlerinin ana sorun olduğu kalabalık hareketli kamera sahneleri mi? → Deep OC-SORT veya TrackTrack (her ikisi de uyarlanabilir görünüm füzyonu ekler; TrackTrack ayrıca çok ipuçlu ilişkilendirme ve yinelenen kimlik bastırma ekler).
5. Gerçek zamanlı olarak sık kısmi örtüşme, ReID bütçesi yok mu? → FastTracker (Kalman geri alma özelliği ile tıkanma farkındalıklı ByteTrack varyantı).

Takipçileri Değiştirme#

İzleyici yapılandırma dosya adını tracker= değerine ilet. Diğer tüm kodlar aynı kalır.

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

Yapılandırma#

Takip Argümanları#

İzleme yapılandırması; conf, iou ve show gibi Predict modu ile ortak özellikler paylaşır. Daha fazla yapılandırma için Predict modeli sayfasına göz at.

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)

Özel Takipçi Yapılandırması#

Ultralytics ayrıca değiştirilmiş bir takipçi yapılandırma dosyası kullanmana izin verir. Bunu yapmak için, ultralytics/cfg/trackers adresinden bir takipçi yapılandırma dosyasının (örneğin custom_tracker.yaml) bir kopyasını oluştur ve (tracker_type hariç) tüm yapılandırmaları ihtiyaçlarına göre değiştir.

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

Paylaşılan Takipçi Argümanları#

Aşağıdaki parametreler çoğu takipçi YAML dosyası için ortaktır; her parametre her yapılandırmada bulunmaz:

Takipçi-spesifik Argümanlar#

Her algoritma, paylaşılan parametrelere ek olarak ilave ayarlar sunar. Açıklamalar ve ince ayar önerileri için aşağıdaki takipçi bazlı bölümlere göz at veya doğrudan yapılandırma dosyalarına başvur:

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

Yeniden Tanımlamayı (ReID) Etkinleştirme#

Ek yükü en aza indirmek için ReID varsayılan olarak devre dışıdır. Bir izleyici yapılandırma dosyasında with_reid: True değerini ayarlayarak etkinleştir.

ReID model seçenekleri:

• model: auto — Yerel YOLO dedektör özelliklerini kullanır ve minimum ek yük ekler. Büyük bir performans kaybı yaşamadan bazı ReID özelliklerine ihtiyaç duyduğun durumlarda idealdir. Dedektör uyumlu özellikleri dışa aktarmazsa yolo26n-cls.pt seçeneğine geri döner.
• Dışa aktarılan ReID modeli — Kırpma başına ekstra bir ileri geçiş (forward pass) maliyeti pahasına daha ayırt edici gömmeler (embeddings) elde etmek için model: hedefini dışa aktarılan bir dosyaya (.torchscript, .onnx, .engine, .openvino vb.) yönlendir. Kodlayıcı AutoBackend aracılığıyla yüklenir, bu nedenle Ultralytics'in desteklediği herhangi bir dışa aktarım formatı kod değişikliği gerektirmeden çalışır.

Her model boyutu için kullanıma hazır ONNX ReID kodlayıcıları yayınlanmıştır. model: değerini bu adlardan birine ayarla ve dosya, izleyici ilk kez çalıştığında otomatik olarak indirilir (YOLO ağırlıklarının alınma şekliyle aynıdır); manuel dışa aktarma veya indirme adımı gerekmez:

# 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

Ayrı bir sınıflandırma modeliyle daha iyi performans için, modeli TensorRT gibi daha hızlı bir arka uca dışa aktar:

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", quantize=16, dynamic=True, batch=32)

Dışa aktardıktan sonra, takipçi yapılandırmanda TensorRT model yolunu belirt.

Takipçi Detayları#

Her takipçinin tasarımı, özel parametreleri ve ince ayar ipuçları için aşağıdaki bölümleri genişlet.

BoT-SORT#

BoT-SORT (Aharon ve ark., 2022) varsayılan izleyicidir. ByteTrack'i kamera hareketi telafisi ve isteğe bağlı ReID ile genişletir:

• Kamera Hareketi Dengeleme (CMC): IoU eşleştirmesinden önce Kalman durumlarına her karede tahmin edilen bir afin dönüşüm (varsayılan olarak seyrek optik akış; ayrıca ORB / ECC kullanılabilir) uygulanır.
• İsteğe bağlı ReID: görünüm gömmeleri maliyet matrisine dahil edilebilir. Varsayılan olarak devre dışıdır; with_reid: True ile etkinleştirilir.

En iyi kullanım alanı: Genel amaçlı takip, özellikle hareketli kameralar. ReID'yi yalnızca birbirine benzeyen kalabalıklar kimlik değişimlerine (ID swap) yol açtığında ekle.

BoT-SORT-spesifik argümanlar:

İnce ayar ipuçları:

• Sabit kamera: her karede birkaç milisaniye tasarruf etmek için gmc_method: none ayarını yap.
• Yoğun kamera hareketi: sparseOptFlow seçeneğini koru; ecc daha doğrudur ancak daha yavaştır.
• Birbirine benzeyen kalabalıklar: with_reid: True seçeneğini aç ve appearance_thresh değerini artır (örn. 0.85+).

ByteTrack#

ByteTrack (Zhang ve ark., ECCV 2022) hafif taban çizgisidir. İki aşamalı bir ilişkilendirme ile doğrusal Kalman + IoU kullanır:

• Aşama 1: Yüksek puanlı tespitleri aktif takiplere göre eşleştir.
• Aşama 2: Kısa süreli kısmi tıkanıklıkları (occlusion) kurtarmak için eşleşmemiş takipleri düşük puanlı tespitlere karşı tekrar dene.

Bir görünüm modeli veya kamera hareketi dengeleme yoktur.

En iyi kullanım alanı: Dedektör maliyetinin baskın olduğu ve minimum takipçi yükü istediğin sabit veya sabit benzeri kameralar.

ByteTrack'e özel argümanlar: Paylaşılan izleyici argümanları dışında yoktur.

İnce ayar ipuçları:

• Gürültülü dedektör: ikinci aşamanın daha fazla adaya sahip olması için track_low_thresh değerini düşür.
• Yüksek geri çağırma (high-recall) dedektörü: parçalanmış kimlikleri azaltmak için track_high_thresh değerini artır.
• Sık kimlik titremesi (flicker): kısa süreliğine kaçırılan izlerin hayatta kalması için track_buffer değerini artır.

OC-SORT#

OC-SORT (Cao ve ark., CVPR 2023), SORT'un gözlem odaklı bir uzantısıdır. SORT'un hafif tasarımını korur (görünüm özellikleri yoktur) ve üç düzeltme ekler:

• Gözlem Odaklı Yeniden Güncelleme (ORU): Son gözlem ile mevcut tespit arasında sanal bir yörüngeyi tekrar oynatarak, kayan hızı onarmak için Kalman güncellemesini yeniden çalıştırır.
• Gözlem Odaklı İvme (OCM): Hız tutarlılığı terimi aracılığıyla yanlış yönde hareket eden tespitleri cezalandırır.
• Gözlem Odaklı Kurtarma (OCR): Eşleşmemiş tespitleri, tahmin edilen durum yerine son gözlemlerini kullanarak yakın zamanda kaybolan takiplere karşı tekrar kontrol eder.

En iyi kullanım alanı: ReID modelinin maliyeti olmadan doğrusal olmayan hareket.

OC-SORT-spesifik argümanlar:

İnce ayar ipuçları:

• Doğrusal olmayan hareket: inertia değerini artır (örn. 0.3-0.4).
• Seyrek tespitler: use_byte: True seçeneğini etkinleştir.
• Uzun süreli kapanmalar (occlusions): OCR'ın yeniden bağlayacağı daha fazla kayıp iz bulabilmesi için track_buffer değerini artır.

Deep OC-SORT#

Deep OC-SORT, OC-SORT'u görünüm bilgisi ve kamera hareketi telafisi ile zenginleştirir:

• Uyarlanabilir görünüm birleştirme: Tespit gömmeleri, tespit güveni ve örtüşme ile modüle edilen ağırlıklarla maliyet matrisine dahil edilir.
• Dinamik görünüm EMA: Takip gömmeleri, yumuşatma faktörü tespit güvenine uyum sağlayan bir EMA ile güncellenir.
• Kamera Hareketi Dengeleme: Kalman durumları, seyrek optik akış, ORB veya ECC aracılığıyla kareler arasında dengelenir.

En iyi kullanım alanı: Görsel olarak farklı ancak uzamsal olarak yakın nesneler arasındaki kimlik değişimlerinin yaygın olduğu kalabalık veya hareketli kamera sahneleri.

Deep OC-SORT-spesifik argümanlar:

İnce ayar ipuçları:

• Kalabalıklarda kimlik değişimleri: appearance_thresh değerini artır (örn. 0.92-0.95) ve gömmelerin daha yavaş uyum sağlaması için alpha_fixed_emb değerini düşür.
• Hareketli kamera: gmc_method: sparseOptFlow ayarını yap (Deep OC-SORT varsayılan olarak none kullanır).
• Düşük gecikme (latency): yalnızca hareket + CMC için with_reid: False (varsayılan) değerini koru; ReID özelliğini yalnızca kimlik değişimleri hatalara hakim olduğunda etkinleştir.

FastTracker#

FastTracker, görünüm modeli olmayan, kapanma farkındalığına sahip bir ByteTrack varyantıdır:

• Kapanma tespiti (occlusion detection): diğer aktif izler tarafından kapsama alanı occ_cover_thresh değerini aştığında izleri kapanmış olarak işaretler.
• Tıkanıklıkta Kalman geri alma: Halka arabellekli geçmişi kullanarak Kalman durumunu tıkanıklık öncesi bir kareye geri döndürür.
• Hareket sönümleme ve arama genişletme: Tıkanıklık sırasında hız sönümlenir ve tahmin edilen bbox genişletilir.
• Init-IoU bastırma: Yeni takiplerin aktif takiplerin üzerinde oluşmasını engeller.

En iyi kullanım alanı: Sık hedef-hedef örtüşmesinin olduğu (kalabalıklar, kuyruklar, spor) gerçek zamanlı, sadece tespit odaklı hatlar.

FastTracker-spesifik argümanlar:

İnce ayar ipuçları:

• Sık kısmi kapanmalar: occ_cover_thresh değerini düşür (örn. 0.5-0.6).
• Örtüşme etrafında yinelenen kimlikler: init_iou_suppress değerini düşür (örn. 0.5).
• Uzun süreli kapanmalar: occ_reappear_window ve track_buffer değerlerini birlikte artır.
• Hızlı hareket eden hedefler: dampen_motion_occ değerini artır (1.0 değerine yaklaşacak şekilde) ve enlarge_bbox_occ değerini düşür.

TrackTrack#

TrackTrack (Shim ve ark., CVPR 2025), çok ipuçlu yinelemeli ilişkilendirme ile her izin perspektifinden akıl yürütür:

• İz Perspektifine Dayalı İlişkilendirme (TPA): HMIoU, kosinüs ReID mesafesi, güven-projeksiyon mesafesi ve köşe-açı mesafesini birleştirir. Atama, gevşetici bir eşik ile yinelemeli olarak çözülür.
• İz-Farkında Başlatma (TAI): Yeni bir kimlik oluşturulmadan önce kopya oluşumları bastırır.

En iyisi: Kopya kimliklerin sorun olduğu, sık tıkanıklık yaşanan kalabalık sahneler için.

TrackTrack'e özgü argümanlar:

İnce ayar ipuçları:

• Kalabalık yayalar: daha fazla yinelenen üretimi engellemek için tai_thr değerini düşür (örn. 0.45); daha uzun kapanmalar için track_buffer değerini artır.
• Hızlı kamera hareketi: gmc_method: sparseOptFlow ayarını etkin tut.
• Küçük/hızlı nesneler: angle_weight değerini biraz artır ve min_track_len değerini düşür.
• ReID'yi sadece gerektiğinde etkinleştir: çıkarım maliyetini artırır; kısa tıkanıklıklar için varsayılan çoklu ipuçlu maliyet genellikle yeterlidir.

Python Örnekleri#

Kalıcı İzleme Döngüsü#

Video kareleri üzerinde nesne izleme çalıştırmak için OpenCV (cv2) ve YOLO26 kullanan bir Python betiği burada bulunmaktadır. Bu betik, gerekli paketlerin (opencv-python ve ultralytics) halihazırda kurulu olduğunu varsayar. persist=True argümanı, izleyiciye mevcut görüntü veya karenin bir dizideki sonraki kare olduğunu ve önceki görüntüden gelen izleri mevcut görüntüde beklemesini 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
        # and using the BoT-SORT tracker backend
        results = model.track(frame, persist=True, tracker="botsort.yaml")

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

Basit tespit yerine nesne izlemeyi etkinleştiren model(frame) değerinden model.track(frame) değerine geçişe lütfen dikkat et. Bu değiştirilmiş betik, videonun her फ्रेम (kare) üzerinde izleyiciyi çalıştıracak, sonuçları görselleştirecek ve bunları bir pencerede gösterecektir. 'q' tuşuna basılarak döngüden çıkılabilir.

İzleri Zaman İçinde Çizdirme#

Nesne izlerini ardışık kareler boyunca görselleştirmek, videodaki tespit edilen nesnelerin hareket modelleri ve davranışları hakkında değerli içgörüler sağlayabilir. Ultralytics YOLO26 ile bu izleri çizdirmek kesintisiz ve verimli bir süreçtir.

Aşağıdaki örnekte, tespit edilen nesnelerin birden fazla video karesindeki hareketini çizdirmek için YOLO26'nın izleme yeteneklerinden nasıl yararlanılacağını gösteriyoruz. Bu betik, bir video dosyasını açmayı, onu 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 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(list)

# 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ı İzleme#

Çok iş parçacıklı izleme, 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ından gelenler gibi çoklu video girişlerini işlerken özellikle yararlıdır.

Sağlanan Python betiğinde, izleyicinin birden fazla örneğini eşzamanlı olarak çalıştırmak için Python'ın threading modülünden yararlanıyoruz. Her iş parçacığı (thread) bir video dosyasında izleyiciyi çalıştırmaktan sorumludur ve tüm iş parçacıkları arka planda aynı anda ç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 izleme döngüsünü içeren bir run_tracker_in_thread fonksiyonu tanımlıyoruz. Bu fonksiyon videoyu kare kare okur, izleyiciyi çalıştırır ve sonuçları görüntüler.

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

threading.Thread içindeki daemon=True parametresi, ana program biter bitmez bu iş parçacıklarının kapatılacağı anlamına gelir. Ardından iş parçacıklarını start() ile başlatır ve ana iş parçacığının her iki takipçi iş parçacığı da bitene kadar beklemesini sağlamak için join() kullanırız.

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şturularak ve aynı metodoloji uygulanarak daha fazla video dosyası ve modeli işleyecek şekilde kolayca genişletilebilir.

Yeni İzleyicilere Katkıda Bulun#

Çoklu nesne izleme konusunda uzman mısın ve Ultralytics YOLO ile bir izleme algoritmasını başarıyla uyguladın veya uyarladın mı? Seni ultralytics/cfg/trackers içindeki İzleyiciler (Trackers) bölümümüze katkıda bulunmaya davet ediyoruz! Gerçek dünyadaki uygulamaların ve çözümlerin, izleme görevleri üzerinde çalışan kullanıcılar için çok değerli 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 ve topluluk için başka bir işlevsellik ve fayda katmanı eklersin.

Katkını başlatmak için, bir Pull Request (PR) göndermeye yönelik kapsamlı talimatlar için lütfen Katkıda Bulunma Kılavuzumuza göz at 🛠️. Ortaya ne koyacağını görmek için sabırsızlanıyoruz!

Birlikte, Ultralytics YOLO ekosisteminin izleme yeteneklerini geliştirelim 🙏!

SSS#

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

Video analitiğinde çoklu nesne izleme, hem nesnelerin tanımlanmasını hem de video kareleri boyunca tespit edilen her nesne için benzersiz bir kimliğin (ID) korunmasını içerir. Ultralytics YOLO, nesne kimlikleriyle birlikte gerçek zamanlı izleme sağlayarak bunu destekler ve güvenlik gözetimi ile spor analitiği gibi görevleri kolaylaştırır. Sistem; YAML dosyaları aracılığıyla yapılandırılabilen BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker ve TrackTrack gibi izleyicileri kullanır.

Takipçiyi bir YOLO model dosyasının içinde saklayabilir miyim?#

Hayır. Standart Ultralytics .pt dosyaları YOLO model ağırlıklarını saklarken, izleyici çıkarım (inference) anında model.track() tarafından oluşturulur. İz kimlikleri, ardışık kareler boyunca izleyici durumuna bağlıdır; bu nedenle tek başına bağımsız bir görüntü kutular, sınıflar ve güven skorları gibi tespitler döndürebilir, ancak tek başına anlamlı kalıcı iz kimlikleri üretemez.

Dağıtım için, detektörü ve takipçiyi uygulamanda birlikte paketle ve kareler aynı video akışından geldiğinde persist=True ile kare kare model.track() fonksiyonunu çağır. Durumun videolar arasında aktarılmaması için ilgisiz akışlar için ayrı model veya takipçi örnekleri kullan.

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

Mevcut bir izleyici yapılandırma dosyasını (ör. custom_tracker.yaml) Ultralytics izleyici yapılandırma dizininden kopyalayarak ve tracker_type hariç parametreleri gerektiği gibi değiştirerek özel bir izleyici yapılandırabilirsin. Bu dosyayı izleme modelinde şu şekilde kullanabilirsin:

from ultralytics import YOLO

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

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

Birden fazla video akışında aynı anda nesne izleme çalıştırmak için Python'ın threading modülünü kullanabilirsin. Her iş parçacığı ayrı bir video akışını ele alacaktır. Bunu nasıl ayarlayabileceğine dair bir örnek aşağıdadı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()

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

Ultralytics YOLO ile çoklu nesne takibi, aşağıdakiler dahil olmak üzere sayısız uygulamaya sahiptir:

• Ulaşım: Trafik yönetimi ve otonom sürüş için araç izleme.
• 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 faaliyetlerin izlenmesi ve güvenlik alarmlarının oluşturulması.

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

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

Birden fazla video karesi üzerinde nesne izlerini görselleştirmek için, YOLO modelinin izleme özelliklerini OpenCV ile birlikte kullanarak tespit edilen nesnelerin yollarını çizebilirsin. İşte bunu gösteren bir örnek 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(list)

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 izleme çizgilerini çizecek ve nesne davranışı ve modelleri hakkında değerli içgörüler sağlayacaktır.