Başla

Ultralytics YOLO ile Çoklu Nesne Takibi

YOLO multi-object tracking with trajectory paths

Video analitiğinde çoklu nesne izleme, her karedeki nesnelerin konumunu ve sınıfını belirler; ayrıca video ilerledikçe algılanan her nesne için benzersiz bir kimlik tutar. Uygulama alanları gözetim ve güvenlikten gerçek zamanlı spor analitiğine kadar uzanır.

Planlanan takip desteği için yayımlanmamış YOLO27 önizlemesine göz at.

İzleyiciler: OC-SORT, Deep OC-SORT, FastTracker, TrackTrack

ultralytics 8.4.63 sürümünden itibaren OC-SORT, Deep OC-SORT, FastTracker ve TrackTrack, BoT-SORT ve ByteTrack'in yanında kullanılabilir.

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

Ultralytics izleyicilerinin çıktısı standart nesne algılama ile tutarlıdır; buna ek olarak nesne kimlikleri de sağlar. Böylece video akışlarındaki nesneleri izlemek ve ardından analiz yapmak kolaylaşır. Nesne izleme için Ultralytics YOLO'yu kullanmanın başlıca nedenleri:

  • Verimlilik: Doğruluktan ödün vermeden video akışlarını gerçek zamanlı işle.
  • Esneklik: Birden fazla izleme algoritmasını ve yapılandırmayı destekler.
  • Kullanım Kolaylığı: Hızlı entegrasyon ve dağıtım için basit Python API'si ve CLI seçenekleri sunar.
  • Özelleştirilebilirlik: Özel olarak eğitilmiş YOLO modelleriyle kolayca kullanılabilir ve belirli bir alana yönelik uygulamalara entegre edilebilir.


İzle: Ultralytics YOLO26 ile Çoklu Nesne Takibi Nasıl Yapılır | BoT-SORT ve ByteTrack | VisionAI 🚀

Gerçek Dünya Uygulamaları#

UlaşımPerakendeSu ürünleri yetiştiriciliği
Araç Takibiİnsan TakibiBalık Takibi

Hızlı Başlangıç#

Varsayılan TrackTrack takip algoritmasıyla bir videoda takibi başlat. tracker bağımsız değişkenini değiştirerek başka bir takip algoritmasına geç.

Örnek
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Varsayılan takip algoritması (TrackTrack)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

# ByteTrack'e geç
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

İzleyiciyi video akışlarında çalıştırmak için YOLO26n, YOLO26n-seg, YOLO26n-pose veya YOLO26n-obb gibi eğitilmiş bir Detect, Segment, Pose ya da OBB modeli kullan. Bu modellerin tümü Ultralytics Platform'daki YOLO26 koleksiyonunda bulunur. Özel modelleri yerel olarak veya Ultralytics Platform bulut eğitimiyle eğitebilirsin.

Örnek
from ultralytics import YOLO

# Resmî veya özel bir model yükle
model = YOLO("yolo26n.pt")  # Resmî bir Detect modeli yükle
model = YOLO("yolo26n-seg.pt")  # Resmî bir Segment modeli yükle
model = YOLO("yolo26n-pose.pt")  # Resmî bir Pose modeli yükle
model = YOLO("path/to/best.pt")  # Özel olarak eğitilmiş bir model yükle

# Modelle takip gerçekleştir
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Varsayılan takip algoritmasıyla takip
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # ByteTrack ile

Desteklenen Takip Algoritmaları#

Ultralytics YOLO, yerleşik altı takip algoritmasıyla birlikte gelir. Birini etkinleştirmek için YAML yapılandırma dosyasını tracker bağımsız değişkenine geçir.

Takip algoritmasıYapılandırma dosyasıHareket modeliGörünüş / ReIDKamera hareketi telafisiÖrtüşme yönetimi
BoT-SORTbotsort.yamlDoğrusal Kalmanİsteğe bağlı (with_reid)Yapılandırılabilir (gmc_method)Takip arabelleği + ReID ile yeniden eşleştirme
ByteTrackbytetrack.yamlDoğrusal KalmanYokHayırDüşük güvenli algılamalar için iki aşamalı kurtarma
OC-SORTocsort.yamlGözlem odaklı KalmanYokHayırSon gözlemden ORU, OCM, OCR yeniden güncellemesi
Deep OC-SORTdeepocsort.yamlGözlem odaklı Kalmanİsteğe bağlı (with_reid)Yapılandırılabilir (gmc_method)OC-SORT + isteğe bağlı uyarlanabilir görünüş EMA'sı
FastTrackerfasttrack.yamlDoğrusal Kalman + geri almaYokHayırKalman geri alma + örtüşme durumunda bbox genişletme
TrackTracktracktrack.yamlDoğrusal Kalman (NSA)İsteğe bağlı (with_reid)Yapılandırılabilir (gmc_method)Yinelemeli çoklu ipucu eşleştirmesi + TAI

Hangi Takip Algoritmasını Kullanmalıyım?#

Başlangıç noktası seçmek için bu akıştan yararlan; tracker belirtmediğinde tracktrack.yaml kullanılır:

  1. En hızlı ve en basit temel çözümü mü arıyorsun? → ByteTrack (ReID yok, kamera hareketi telafisi yok, en düşük ek yük).
  2. Elde çekilmiş, drone veya hareketli kamerayla çekilmiş görüntüler mi kullanıyorsun? → BoT-SORT (kamera hareketi telafisi ve isteğe bağlı ReID ekler).
  3. Doğrusal olmayan hareket (spor, dans, ani dönüşler) var ve ReID kullanmıyor musun? → OC-SORT (görünüş eşleştirme maliyeti olmadan gözlem odaklı düzeltmeler yapar).
  4. Kimlik değişimlerinin başlıca sorun olduğu kalabalık ve hareketli kameralı sahneler mi var? → Deep OC-SORT veya TrackTrack (ikisi de isteğe bağlı görünüş eşleştirmesini destekler; TrackTrack ayrıca çoklu ipucu eşleştirmesi ve yinelenen kimlikleri bastırma özelliği sunar).
  5. Gerçek zamanlı kullanımda sık sık kısmi örtüşme oluyor ve ReID için bütçen yok mu? → FastTracker (Kalman geri alma özelliğine sahip, örtüşmeleri dikkate alan bir ByteTrack çeşidi).

Takip Algoritmalarını Değiştirme#

Takip algoritmasının yapılandırma dosyası adını tracker= bağımsız değişkenine geçir. Diğer tüm kodlar aynı kalır.

Örnek
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 Bağımsız Değişkenleri#

İzleme yapılandırması, Predict modundaki conf, iou ve show gibi çıkarım argümanlarını paylaşır.

Örnek
from ultralytics import YOLO

# Takip parametrelerini yapılandır ve takip algoritmasını çalıştır
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.5, show=True)

Özel Takip Algoritması Yapılandırması#

Değiştirilmiş bir izleyici yapılandırması kullanmak için ultralytics/cfg/trackers konumundan bir izleyici yapılandırma dosyasını (örneğin custom_tracker.yaml olarak) kopyala ve tracker_type dışındaki ayarları değiştir.

Örnek
from ultralytics import YOLO

# Modeli yükle ve özel bir yapılandırma dosyasıyla takip algoritmasını çalıştır
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Ortak Takip Algoritması Bağımsız Değişkenleri#

Aşağıdaki parametreler takip algoritmalarının YAML dosyalarının çoğunda ortaktır; her parametre her yapılandırma dosyasında bulunmayabilir:

Takip Eşiği Bilgileri

track_high_thresh değerine eşit veya daha yüksek algılamalar ilk eşleştirme aşamasına girer. track_low_thresh ile track_high_thresh arasındaki algılamalar, seçilen takip algoritması düşük güvenli eşleştirmeyi etkinleştirmişse mevcut izleri kurtarabilir, ancak yeni izler başlatmaz. track_low_thresh değerine eşit veya daha düşük algılamalar yok sayılır.

ParametreGeçerli Değerler veya AralıklarAçıklama
tracker_typebotsort, bytetrack, ocsort, deepocsort, fasttrack, tracktrackTakip algoritması türünü belirtir.
track_high_thresh0.0-1.0İlk eşleştirme eşiği. Bir tespitin mevcut bir iz ile ne kadar güvenle eşleştirileceğini etkiler.
track_low_thresh0.0-1.0Düşük güvenli kurtarma tespitleri için alt sınır. OC-SORT ve Deep OC-SORT bu tespitleri yalnızca use_byte: True durumunda kullanır; TrackTrack ise bunları cezalı eşleştirme havuzuna dahil eder.
new_track_thresh0.0-1.0Tespit mevcut izlerden hiçbiriyle eşleşmezse yeni bir iz başlatmak için gereken eşik.
track_buffer>=0Kayıp izlerin kaldırılmadan önce kaç kare boyunca canlı tutulacağı. Daha yüksek değer, örtülmelere karşı daha fazla tolerans sağlar.
match_thresh0.0-1.0İzleri eşleştirme eşiği. Daha yüksek değerler eşleştirmeyi daha esnek hale getirir.
fuse_scoreTrue, FalseEşleştirme öncesinde güven puanlarının IoU uzaklıklarıyla birleştirilip birleştirilmeyeceği.
gmc_methodsparseOptFlow, orb, sift, ecc, noneKüresel hareket telafisi yöntemi. Kamera hareketini hesaba katmaya yardımcı olur.
proximity_thresh0.0-1.0Geçerli bir ReID eşleşmesi için gereken minimum IoU. Görünüş ipuçlarını kullanmadan önce nesnelerin uzamsal olarak yakın olmasını sağlar.
appearance_thresh0.0-1.0ReID için gereken minimum normalize edilmiş görünüş benzerliği.
with_reidTrue, FalseÖrtülmeler boyunca takibi iyileştirmek için görünüş tabanlı eşleştirmeyi etkinleştir. BoT-SORT, Deep OC-SORT ve TrackTrack tarafından desteklenir.
modelauto veya uyumlu ReID model yoluReID modeli. auto kullanılabiliyorsa yerel YOLO omurga özelliklerini kullanır; aksi durumda yolo26n-cls.pt seçeneğine geri döner. Özel bir kodlayıcı, .pt kontrol noktası veya .torchscript, .onnx, .engine gibi dışa aktarılmış bir model ya da bir OpenVINO model dizini olabilir.

İzleyiciye Özgü Argümanlar#

Her algoritma, paylaşılan parametrelere ek olarak başka ayarlar da sunar. Açıklamalar ve ayarlama önerileri için aşağıdaki izleyici bölümlerine bak veya doğrudan yapılandırma dosyalarını incele:

Yeniden Kimlik Tanıma (ReID) Özelliğini Etkinleştirme#

ReID, ek yükü en aza indirmek için varsayılan olarak devre dışıdır. Bir izleyici yapılandırma dosyasında with_reid: True ayarını yaparak etkinleştir.

ReID modeli seçenekleri:

  • model: auto — Yerel YOLO algılayıcı özelliklerini kullanır ve ek yükü en aza indirir. Büyük bir performans kaybı yaşamadan ReID'den yararlanmak istediğinde idealdir. Algılayıcı uyumlu özellikler sunmuyorsa yolo26n-cls.pt seçeneğine geri döner.
  • Özel ReID modeli — model: değerini bir .pt kontrol noktasına veya .torchscript, .onnx, .engine gibi uyumlu, dışa aktarılmış bir gömme modeline ya da bir OpenVINO model dizinine yönlendir. Dışa aktarılmış modeller AutoBackend aracılığıyla yüklenir ve doğrudan bir gömme tensörü üretmelidir.

Her model boyutu için kullanıma hazır ONNX kodlayıcıları yayımlanmıştır. model: değerini bu adlardan birine ayarla; izleyici ilk kez çalıştığında dosya otomatik olarak indirilir (YOLO ağırlıklarının alınmasıyla aynı şekilde) — elle dışa aktarma veya indirme 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
Modelboyut
(piksel)
parametre
(M)
FLOPs
(B)
YOLO26n-reid.onnx4482.82.0
YOLO26s-reid.onnx4487.56.6
YOLO26m-reid.onnx44812.420.1
YOLO26l-reid.onnx44815.325.2
YOLO26x-reid.onnx44832.755.9
ReID yalnızca izleme amaçlıdır

Şu anda yalnızca izleyicinin görünüş dalına yönelik ONNX ReID kodlayıcıları kullanılabilir. ReID train, val ve predict kipleri ile özel ReID dışa aktarma tarifleri hâlâ geliştirme aşamasındadır.

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

ReID modelini TensorRT'ye dışa aktarma
from torch import nn

from ultralytics import YOLO

# Sınıflandırma modelini yükle
model = YOLO("yolo26n-cls.pt")

# Ortalama havuzlama katmanı ekle
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

# TensorRT'ye dışa aktar
model.export(format="engine", quantize=16, dynamic=True, batch=32)

Dışa aktarma tamamlandıktan sonra izleyici yapılandırmanda TensorRT model yolunu belirt.

İzleyici Ayrıntıları#

Aşağıdaki bölümlerde her izleyicinin tasarımı, belirli parametreleri ve ayarlama ipuçları açıklanır.



İzle: Hangi Nesne Takipçisi Daha İyi Performans Gösteriyor? | Hız, FPS ve ID Kararlılığı | Ultralytics YOLO26 📊

BoT-SORT#

BoT-SORT (Aharon ve diğerleri, 2022), ByteTrack'i kamera hareketi telafisi ve isteğe bağlı ReID ile genişletir:

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

En uygun kullanım: Genel amaçlı izleme, özellikle hareketli kameralar. Benzer görünen kalabalıklar kimlik değişimlerine yol açıyorsa ReID ekle.

BoT-SORT'a özgü argümanlar:

ParametreGeçerli Değerler veya AralıklarAçıklama
gmc_methodsparseOptFlow, orb, sift, ecc, noneKamera hareketi telafisi arka ucu. Varsayılan değer sparseOptFlow'dır. none, CMC'yi devre dışı bırakır.
with_reidTrue, FalseGörünüş tabanlı eşleştirmeyi etkinleştir. Varsayılan olarak kapalıdır.
modelauto veya uyumlu ReID model yoluauto, kullanılabiliyorsa yerel YOLO özelliklerini kullanır; özel modeller .pt kontrol noktaları veya uyumlu dışa aktarımlar olabilir.
proximity_thresh0.0-1.0Görünüş özelliklerinin dikkate alınabilmesi için gereken minimum IoU.
appearance_thresh0.0-1.0ReID eşleşmesi için gereken minimum normalize edilmiş görünüş benzerliği. Eşleştirmeyi sıkılaştırmak için değeri artır.

Ayarlama ipuçları:

  • Sabit kamera: Kare başına birkaç ms kazanmak için gmc_method: none değerini ayarla.
  • Yoğun kamera hareketi: sparseOptFlow değerini koru; ecc daha doğrudur ancak daha yavaştır.
  • Benzer görünen kalabalıklar: with_reid: True özelliğini etkinleştir ve appearance_thresh değerini artır (ör. 0.85+).

ByteTrack#

ByteTrack (Zhang ve diğerleri, ECCV 2022), hafif bir temel yöntemdir. İki aşamalı eşleştirme için doğrusal Kalman + IoU kullanır:

  • 1. Aşama: yüksek puanlı tespitleri etkin izlerle eşleştir.
  • 2. Aşama: kısa süreli kısmi örtülmelerde izleri kurtarmak için eşleşmeyen izleri düşük puanlı tespitlerle yeniden eşleştirmeyi dene.

Görünüş modeli ve kamera hareketi telafisi yoktur.

En uygun kullanım: Algılayıcı maliyetinin baskın olduğu ve izleyici ek yükünü en aza indirmek istediğin sabit veya neredeyse sabit kameralar.

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

Ayarlama ipuçları:

  • Gürültülü algılayıcı: İkinci aşamanın daha fazla aday bulması için track_low_thresh değerini düşür.
  • Yüksek duyarlılıklı algılayıcı: Parçalı kimlikleri azaltmak için track_high_thresh değerini artır.
  • Sık kimlik titreşimi: Kısa süreliğine kaçırılan izlerin korunması için track_buffer değerini artır.

OC-SORT#

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

  • Gözlem Merkezli Yeniden Güncelleme (ORU): Son gözlem ile mevcut tespit arasında sanal bir yörüngeyi yeniden oynatır ve kaymış hızı düzeltmek için Kalman güncellemesini yeniden çalıştırır.
  • Gözlem Merkezli Momentum (OCM): Hız tutarlılığı terimi aracılığıyla yanlış yönde hareket eden tespitleri cezalandırır.
  • Gözlem Merkezli Kurtarma (OCR): Eşleşmeyen tespitleri, tahmin edilen durum yerine son gözlemlerini kullanarak yakın zamanda kaybolan izlerle yeniden kontrol eder.

En uygun kullanım: ReID modeli maliyetine katlanmadan doğrusal olmayan hareketleri izleme.

OC-SORT'a özgü argümanlar:

ParametreGeçerli Değerler veya AralıklarAçıklama
delta_t>=1OCM'de hız yönünü hesaplamak için kullanılan zamansal pencere (kare). Daha büyük değerler daha fazla yumuşatma sağlar.
inertia0.0-1.0Hız tutarlılığı maliyetinin ağırlığı. Daha yüksek değerler ani yön değişikliklerini daha fazla cezalandırır.
use_byteTrue, FalseDüşük güvenli tespitler üzerinde ByteTrack tarzı ikinci bir eşleştirme turunu etkinleştir.

Ayarlama ipuçları:

  • Doğrusal olmayan hareket: inertia değerini artır (ör. 0.3-0.4).
  • Seyrek tespitler: use_byte: True özelliğini etkinleştir.
  • Uzun örtülmeler: OCR'nin yeniden bağlayabileceği daha fazla kayıp iz olması için track_buffer değerini artır.

OBB modellerinde, yönlendirilmiş son gözlem geçmişi tutulmadığı için OCR, Kalman tarafından tahmin edilen yönlendirilmiş kutuyu kullanır.

Deep OC-SORT#

Deep OC-SORT, OC-SORT'u görünüş bilgisi ve kamera hareketi telafisiyle genişletir:

  • Görünüş eşleştirmesi: Kosinüs gömme uzaklığı örtüşmeye göre sınırlandırılır ve hareket maliyetiyle birleştirilir.
  • Dinamik görünüş EMA'sı: İz gömmeleri, yumuşatma katsayısı tespit güvenine göre uyarlanan bir EMA ile güncellenir.
  • Kamera Hareketi Telafisi: Kalman durumları, kareler arasında seyrek optik akış, ORB veya ECC aracılığıyla dönüştürülür.

En uygun kullanım: Görsel olarak farklı ancak uzamsal olarak yakın nesneler arasında kimlik değişimlerinin sık yaşandığı kalabalık veya hareketli kameralı sahneler.

Deep OC-SORT'a özgü argümanlar:

ParametreGeçerli Değerler veya AralıklarAçıklama
with_reidTrue, FalseGörünüş tabanlı eşleştirmeyi etkinleştir. Varsayılan olarak kapalıdır.
modelauto veya uyumlu ReID model yoluauto, kullanılabiliyorsa yerel YOLO özelliklerini kullanır; özel modeller .pt kontrol noktaları veya uyumlu dışa aktarımlar olabilir.
proximity_thresh0.0-1.0Görünüş özelliklerinin dikkate alınabilmesi için gereken minimum IoU.
appearance_thresh0.0-1.0ReID eşleşmesi için gereken minimum normalize edilmiş görünüş benzerliği.
alpha_fixed_emb0.0-1.0İz gömme güncellemeleri için temel EMA katsayısı. Daha yüksek değerler eski gömmenin daha uzun süre korunmasını sağlar.
gmc_methodsparseOptFlow, orb, sift, ecc, noneKüresel hareket telafisi yöntemi.
delta_t>=1OCM'de hız yönünü hesaplamak için kullanılan zamansal pencere (kare) (OC-SORT'tan devralınmıştır).
inertia0.0-1.0Hız tutarlılığı maliyetinin ağırlığı (OC-SORT'tan devralınmıştır).
use_byteTrue, FalseDüşük güvenli tespitler üzerinde ByteTrack tarzı ikinci bir eşleştirmeyi etkinleştir (OC-SORT'tan devralınmıştır).

Ayarlama ipuçları:

  • Kalabalıklarda kimlik değişimleri: appearance_thresh değerini artır (ör. 0.92-0.95) ve gömmelerin daha yavaş uyum sağlaması için alpha_fixed_emb değerini yükselt.
  • Hareketli kamera: gmc_method: sparseOptFlow değerini ayarla (Deep OC-SORT varsayılan olarak none kullanır).
  • Daha düşük gecikme: Yalnızca hareket + CMC için with_reid: False değerini (varsayılan) koru; ReID'yi yalnızca hatalarda kimlik değişimleri baskınsa etkinleştir.

FastTracker#

FastTracker, görünüş modeli içermeyen ve örtülmeleri dikkate alan bir ByteTrack çeşididir:

  • Örtülme tespiti: Diğer etkin izlerin kapladığı alan occ_cover_thresh değerini aştığında izleri örtülmüş olarak işaretler.
  • Örtülme sırasında Kalman geri alma: Halka tamponunda tutulan geçmişi kullanarak Kalman durumunu örtülme öncesi bir kareye geri alır.
  • Hareket azaltma ve arama alanını genişletme: Örtülme sırasında hız azaltılır ve tahmin edilen bbox büyütülür.
  • Başlatma-IoU baskılama: Etkin izlerin üzerine yeni izlerin başlatılmasını önler.

En uygun kullanım: Hedeflerin sık sık üst üste bindiği (kalabalıklar, kuyruklar, spor) gerçek zamanlı, yalnızca algılamaya dayalı işlem hatları.

FastTracker'a özgü bağımsız değişkenler:

ParametreGeçerli Değerler veya AralıklarAçıklama
reset_velocity_offset_occ>=0Örtülme başladığında Kalman hızını geri yüklemek için geçmişteki kare sayısı.
reset_pos_offset_occ>=0Örtülme başladığında Kalman konumunu geri yüklemek için geçmişteki kare sayısı.
enlarge_bbox_occ>=1.0Örtülme sırasında tahmin edilen bbox'a uygulanan yükseklik ölçeklendirmesi (genişlik, XYAH en-boy oranına göre ölçeklenir).
dampen_motion_occ0.0-1.0Örtülme sırasında kullanılan hız çarpanı. Daha düşük değerler, iz nesnesinin örtülme sırasında "yavaşlamasını" sağlar.
active_occ_to_lost_thresh>=1Etkin bir iz kayıp durumuna geçirilmeden önce izin art arda örtülü kalabileceği en fazla kare sayısı.
occ_cover_thresh0.0-1.0Örtülme kararı vermek için başka bir etkin iz tarafından kaplanan iz alanı oranı.
occ_reappear_window>=0Yakın zamanda örtülmüş kayıp bir izin yeniden bulunabilir durumda öncelikli olarak tutulduğu kare sayısı.
init_iou_suppress0.0-1.0IoU değeri herhangi bir etkin iz için bu eşiği aşarsa yeni iz başlatmayı engelle. Devre dışı bırakmak için 1.0 olarak ayarla.

Ayarlama ipuçları:

  • Sık kısmi örtülmeler: occ_cover_thresh değerini düşür (ör. 0.5-0.6).
  • Örtüşme çevresinde yinelenen kimlikler: init_iou_suppress değerini düşür (ör. 0.5).
  • Uzun süreli örtülmeler: 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ştır); daha geniş bir arama bölgesi kurtarmayı iyileştiriyorsa yalnızca enlarge_bbox_occ değerini artır.

TrackTrack#

TrackTrack (Shim ve diğerleri, CVPR 2025) varsayılan izleyicidir. Çoklu ipucuyla yinelemeli eşleştirme yaparken her izin bakış açısından değerlendirme gerçekleştirir:

  • İz Perspektifine Dayalı Eşleştirme (TPA): HMIoU'yu, isteğe bağlı kosinüs ReID mesafesini, güven projeksiyonu mesafesini ve köşe açısı mesafesini birleştirir. Atama, gevşetilen bir eşikle yinelemeli olarak çözülür.
  • İz Farkındalıklı Başlatma (TAI): yeni bir kimlik oluşturulmadan önce yinelenen iz oluşumlarını engeller.

En uygun kullanım: yinelenen kimliklerin sorun olduğu, sık örtülmelerin yaşandığı kalabalık sahneler.

TrackTrack'e özgü bağımsız değişkenler:

ParametreGeçerli Değerler veya AralıklarAçıklama
iou_weight0.0-1.0ReID etkin olduğunda HMIoU mesafesinin ağırlığı; aksi durumda doğrudan HMIoU kullanılır.
reid_weight0.0-1.0ReID etkin olduğunda kosinüs ReID mesafesinin ağırlığı; aksi durumda yok sayılır.
conf_weight0.0-1.0Güven projeksiyonu mesafesinin ağırlığı.
angle_weight0.0-1.0Köşe açısı mesafesinin ağırlığı.
penalty_p0.0-1.0Düşük güvenli tespitler için maliyet cezası.
penalty_q0.0-1.0İkincil NMS tarafından kurtarılan tespitler için maliyet cezası.
reduce_step0.0-1.0Her yinelemede eşleştirme eşiğinin gevşetilme miktarı.
tai_thr0.0-1.0İz Farkındalıklı Başlatma NMS'si için IoU eşiği.
min_track_len>=0Yeni bir izin doğrulanmasından önce gereken en kısa geçmiş uzunluğu.
lost_match_thr0.0-1.0Gevşetilmiş kayıp izi yeniden bağlama adımı için daha esnek maliyet eşiği; 0 bu özelliği devre dışı bırakır.
with_reidTrue, FalseKosinüs ReID görünüş eşleştirmesini etkinleştir (yerel YOLO özelliklerini kullanır). Varsayılan olarak kapalıdır.
modelauto veya uyumlu ReID model yoluauto, kullanılabiliyorsa yerel YOLO özelliklerini kullanır; özel modeller .pt kontrol noktaları veya uyumlu dışa aktarımlar olabilir.
gmc_methodsparseOptFlow, orb, sift, ecc, noneKüresel hareket telafisi yöntemi.

Ayarlama ipuçları:

  • Kalabalık yaya grupları: yinelenen iz oluşumlarını daha fazla engellemek için tai_thr değerini düşür (ör. 0.45); daha uzun örtülmeler için track_buffer değerini artır.
  • Hızlı kamera hareketi: gmc_method: sparseOptFlow özelliğini etkin tut.
  • Küçük/hızlı nesneler: angle_weight değerini biraz artır ve min_track_len değerini düşür.
  • ReID'yi yalnızca gerektiğinde etkinleştir: çıkarım maliyetini artırır; kısa süreli örtülmelerde varsayılan çoklu ipucu maliyeti genellikle yeterlidir.

Segment ve Pose modellerinde TrackTrack, maskelerin ve anahtar noktaların tespitleriyle hizalı kalması için gevşek NMS tespit kurtarmayı atlar.

Python Örnekleri#



İzle: Ultralytics YOLO26 ile Etkileşimli Nesne Takibi Nasıl Oluşturulur: Dakikalar İçinde Oluştur | Python!

İzleri Korumalı Döngü#

Burada, video karelerinde nesne izleme gerçekleştirmek için OpenCV (cv2) ve YOLO26 kullanan bir Python betiği yer alıyor. Bu betik, gerekli paketlerin (opencv-python ve ultralytics) önceden yüklü olduğunu varsayar. persist=True bağımsız değişkeni, izleyiciye geçerli görüntünün veya karenin bir dizideki sonraki kare olduğunu ve geçerli görüntüde önceki görüntüdeki izleri beklemesi gerektiğini bildirir.

İzleri koruma ve izleyici seçme

persist=True seçeneğini yalnızca aynı video akışından art arda gelen kareleri model.track() öğesine aktarırken kullan. Böylece izleyici önceki karelerdeki durumu yeniden kullanabilir ve zaman içinde tutarlı iz kimliklerini koruyabilir. Önceki iz durumu aktarılabileceği için persist=True seçeneğini alakasız görüntülerde veya farklı bir akışta kullanma.

tracker="botsort.yaml", tracker="bytetrack.yaml" veya tracker="tracktrack.yaml" gibi bir izleyici yapılandırma dosyası aktararak da izleyici arka ucunu seçebilirsin.

İzlemeli akış for döngüsü
import cv2

from ultralytics import YOLO

# YOLO26 modelini yükle
model = YOLO("yolo26n.pt")

# Video dosyasını aç
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Video kareleri üzerinde döngü oluştur
while cap.isOpened():
    # Videodan bir kare oku
    success, frame = cap.read()

    if success:
        # Karede YOLO26 ile izleme yap ve kareler arasında izleri koru
        # ve BoT-SORT izleyici arka ucunu kullan
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # Sonuçları kare üzerinde görselleştir
        annotated_frame = results[0].plot()

        # Açıklama eklenmiş kareyi görüntüle
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # 'q' tuşuna basılırsa döngüyü sonlandır
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Videonun sonuna ulaşılırsa döngüyü sonlandır
        break

# Video yakalama nesnesini serbest bırak ve görüntüleme penceresini kapat
cap.release()
cv2.destroyAllWindows()

Nesne izlemeyi basit algılama yerine etkinleştiren model(frame) öğesinin model.track(frame) olarak değiştirildiğine dikkat et. Değiştirilen bu betik, izleyiciyi videonun her karesinde çalıştırır, sonuçları görselleştirir ve bir pencerede gösterir. 'q' tuşuna basarak döngüden çıkabilirsin.

İzleri Zaman İçinde Çizme#

Ardışık karelerdeki nesne izlerini görselleştirmek, bir videoda algılanan nesnelerin hareket örüntüleri ve davranışları hakkında değerli bilgiler sağlayabilir. Ultralytics YOLO26 bu izleri kolayca çizmeni sağlar.

Aşağıdaki örnekte YOLO26 izleme özelliği, birden fazla video karesinde algılanan nesnelerin hareketini çizmek için kullanılır. Betik bir video dosyasını açar, kareleri tek tek okur ve nesneleri tanımlayıp izlemek için YOLO modelini kullanır. Algılanan sınırlayıcı kutuların merkez noktalarını kaydedip birleştirerek izlenen nesnelerin izlediği yolları gösteren çizgiler çizer.

Birden fazla video karesi boyunca izleri çizme
from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# YOLO26 modelini yükle
model = YOLO("yolo26n.pt")

# Video dosyasını aç
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# İz geçmişini sakla
track_history = defaultdict(list)

# Video kareleri üzerinde döngü oluştur
while cap.isOpened():
    # Videodan bir kare oku
    success, frame = cap.read()

    if success:
        # Karede YOLO26 ile izleme yap ve kareler arasında izleri koru
        result = model.track(frame, persist=True)[0]

        # Kutuları ve iz kimliklerini al
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Sonucu karede görselleştir
            frame = result.plot()

            # İzleri çiz
            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 merkez noktası
                if len(track) > 30:  # 30 kare boyunca 30 izi tut
                    track.pop(0)

                # İzleme çizgilerini çiz
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Açıklama eklenmiş kareyi görüntüle
        cv2.imshow("YOLO26 Tracking", frame)

        # 'q' tuşuna basılırsa döngüyü sonlandır
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Videonun sonuna ulaşılırsa döngüyü sonlandır
        break

# Video yakalama nesnesini serbest bırak ve görüntüleme penceresini kapat
cap.release()
cv2.destroyAllWindows()

Çok İş Parçacıklı İzleme#

Çok iş parçacıklı izleme, nesne izlemeyi aynı anda birden fazla video akışında çalıştırma olanağı sağlar. Eş zamanlı işlemenin verimi artırdığı birden fazla gözetim kamerasından gelenler gibi birden fazla video girdisini işlerken özellikle yararlıdır.

Aşağıdaki Python betiği, izleyicinin birden fazla örneğini eş zamanlı çalıştırmak için Python'ın threading modülünü kullanır. Her iş parçacığı izleyiciyi tek bir video kaynağında çalıştırır ve tüm iş parçacıkları arka planda aynı anda yürütülür.

Her iş parçacığının doğru parametreleri (kullanılacak model ve video kaynağı) almasını sağlamak için betik, bu parametreleri kabul eden ve ana izleme döngüsünü içeren run_tracker_in_thread işlevini tanımlar. Bu işlev videoyu kare kare okur, izleyiciyi çalıştırır ve açıklama eklenmiş sonuçları kaydeder.

Bu örnekte, her biri farklı bir kaynaktan (yerel bir video dosyası ve web kamerası) gelen görüntülerde nesneleri izleyen iki farklı model, yolo26n.pt ve yolo26n-seg.pt, kullanılır. Kaynaklar SOURCES içinde belirtilir.

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 her iki izleyici iş parçacığı da tamamlanana kadar ana iş parçacığının beklemesi 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.

Çok iş parçacıklı izleme uygulaması
import threading

import cv2

from ultralytics import YOLO

# Model adlarını ve video kaynaklarını tanımla
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # yerel video, web kamerası için 0

def run_tracker_in_thread(model_name, filename):
    """Run YOLO tracker in its own thread for concurrent processing.

    Args:
        model_name (str): Model checkpoint name or path loaded inside the thread.
        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

# Bir for döngüsüyle izleyici iş parçacıkları oluştur ve başlat
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()

# Tüm izleyici iş parçacıklarının tamamlanmasını bekle
for thread in tracker_threads:
    thread.join()

# Temizle ve pencereleri kapat
cv2.destroyAllWindows()

Bu örnek, daha fazla iş parçacığı oluşturup aynı yöntemi uygulayarak daha fazla video dosyası ve model işleyecek şekilde kolayca genişletilebilir.

Yeni İzleyicilere Katkıda Bulun#

Ultralytics YOLO için çoklu nesne izleme algoritması uyguladıysan veya uyarladıysan, topluluğun kullanımına sunulan izleme seçeneklerini artırmak için algoritmayı eşleşen bir yapılandırmayla ultralytics/cfg/trackers içindeki ultralytics/trackers deposuna katkıda bulunmayı düşünebilirsin.

Sık Sorulan Sorular#

  • Video analitiğinde çoklu nesne izleme, nesneleri belirlemeyi ve tespit edilen her nesne için video kareleri boyunca benzersiz bir kimliği korumayı kapsar. Ultralytics YOLO; gerçek zamanlı izleme ve nesne kimlikleri sağlayarak güvenlik gözetimi ve spor analitiği gibi görevleri kolaylaştırır. Sistem, YAML dosyaları üzerinden yapılandırılabilen BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker ve TrackTrack gibi izleyiciler kullanır.

  • Hayır. Standart Ultralytics .pt dosyaları YOLO model ağırlıklarını saklarken izleyici, çıkarım sırasında model.track() tarafından oluşturulur. İz kimlikleri art arda gelen karelerdeki izleyici durumuna bağlıdır. Bu nedenle tek bir bağımsız görüntü kutular, sınıflar ve güven değerleri gibi tespit sonuçları döndürebilir; ancak tek başına anlamlı ve kalıcı izleme kimlikleri üretemez.

    Dağıtım için tespit modelini ve izleyiciyi uygulamanda birlikte paketle; kareler aynı video akışından geliyorsa model.track() öğesini kare kare, persist=True ile çağır. Videolar arasında durum aktarımını önlemek için alakasız akışlarda ayrı model veya izleyici örnekleri kullan.

  • Var olan bir izleyici yapılandırma dosyasını (ör. custom_tracker.yaml) Ultralytics izleyici yapılandırma dizininden kopyalayıp tracker_type dışında gerekli parametreleri değiştirerek özel bir izleyici yapılandırabilirsin. Bu dosyayı izleme modelinde şöyle kullan:

    Örnek
    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 nesne izlemek için Python'ın threading modülünü kullanabilirsin. Her iş parçacığı ayrı bir video akışını işler. Bunu nasıl ayarlayabileceğine dair bir örnek:

    Çok İş Parçacıklı İzleme
    import threading
    
    import cv2
    
    from ultralytics import YOLO
    
    # Model adlarını ve video kaynaklarını tanımla
    MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
    SOURCES = ["path/to/video.mp4", "0"]  # yerel video, web kamerası için 0
    
    def run_tracker_in_thread(model_name, filename):
        """Run YOLO tracker in its own thread for concurrent processing.
    
        Args:
            model_name (str): Model checkpoint name or path loaded inside the thread.
            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
    
    # Bir for döngüsüyle izleyici iş parçacıkları oluştur ve başlat
    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()
    
    # Tüm izleyici iş parçacıklarının tamamlanmasını bekle
    for thread in tracker_threads:
        thread.join()
    
    # Temizle ve pencereleri kapat
    cv2.destroyAllWindows()
  • Ultralytics YOLO ile çoklu nesne izlemenin aşağıdakiler de dahil olmak üzere birçok uygulaması vardır:

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

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

  • Birden fazla video karesindeki nesne izlerini görselleştirmek için tespit edilen nesnelerin yollarını çizmede YOLO modelinin izleme özelliklerini OpenCV ile birlikte kullanabilirsin. Bunu gösteren örnek bir betik:

    Birden fazla video karesi boyunca izleri çizme
    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:
            result = model.track(frame, persist=True)[0]
            annotated_frame = result.plot()
            if result.boxes and result.boxes.is_track:
                boxes = result.boxes.xywh.cpu()
                track_ids = result.boxes.id.int().cpu().tolist()
                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, izlenen nesnelerin zaman içindeki hareket yollarını gösteren izleme çizgilerini çizer ve nesne davranışları ile örüntüleri hakkında değerli bilgiler sağlar.

Yorumlar679

Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.

  1. bhaskar2443053GitHub

    I’m using YOLO-Pose to detect and track people throughout ~1-hour videos and need each person to keep the same ID. I already have high-quality ground-truth tracks from a SAM-based tracker.

    Do you have a script that can fine-tune YOLO-Pose (and its tracker/Re-ID parameters) against this ground truth to squeeze out the best IDF1 or HOTA scores ?

    1
    1. maxexplorerGitHub

      Hi!

      Thank you for your great work on YOLO and tracking integration. We are using YOLO with ByteTrack/BoT-SORT for object counting and tracking and want to improve ID stability.

      1. We notice that sometimes, even when the object visually looks the same and the scene and motion are stable, the track_id changes. What parameters or reasons should we check to understand why the ID changes unexpectedly?

      2. Is the match_thresh parameter based on IoU, and is it possible to print or visualize the IoU used during matching for debugging?

      3. Is there a way to output Kalman-predicted boxes of lost tracks so we can analyze them?

      4. Could increasing the video FPS improve tracking and IoU consistency, or is this mainly related to detection stability and parameter tuning?

      5. Does ByteTrack or BoT-SORT use a min_hits parameter before confirming tracks, or are tracks confirmed immediately after creation?

      6. If a track is lost, can a new ID only be assigned on the second frame after reappearance if conf > new_track_thresh and then conf > track_high_thresh, or can it happen immediately on the first detection?

      7. Is the track_buffer parameter the number of frames a track is kept using Kalman prediction after it is lost before being deleted?

      8. Do you have any tips to improve tracking stability and avoid unnecessary ID switches?

      Thank you for your support!

    2. Glenn JocherUltralytics

      @bhaskar2443053 currently there isn't a built-in script for fine-tuning YOLO-Pose tracking parameters against ground truth. You would need to implement custom evaluation using libraries like TrackEval or MOTChallenge to compute IDF1/HOTA scores and optimize tracker parameters iteratively.

      @maxexplorer great questions about tracking stability! Here are the key points:

      1. ID changes typically occur due to low IoU between predicted and detected boxes, occlusions, or threshold mismatches. Check track_high_thresh and match_thresh in your tracker config.

      2. match_thresh is indeed IoU-based. For debugging, you can add logging to the tracker code, but there's no built-in visualization.

      3. Kalman predictions aren't directly exposed, but you can access them by modifying the tracker implementation.

      4. Higher FPS generally improves tracking by reducing inter-frame motion, making associations more reliable.

      5. Both trackers use confirmation logic - tracks need to meet certain criteria before being confirmed as valid tracks.

      6. New tracks can be assigned immediately if detection confidence exceeds new_track_thresh.

      7. Correct - track_buffer maintains lost tracks for that many frames using prediction.

      8. For stability: increase track_buffer, adjust match_thresh based on your scenario, and ensure consistent detection quality with appropriate conf thresholds.

      For detailed parameter tuning, refer to the tracker configuration files and our tracking documentation.

  2. rohith-aiunikaGitHub(düzenlendi)

    Hi YOLO Team, I've been using the following Python script to track objects with my YOLOv8 model: from ultralytics import YOLO

    model = YOLO(r"/home/best_pt_files/v1.0.2.pt") results = model.track(r"/home/video.MP4", save=False, stream=False)

    However, I noticed that my GPU memory usage gradually increases, leading to an "out of memory" error before the video finishes processing. Interestingly, when I use the following command from the terminal, the entire video tracks successfully without excessive GPU memory consumption: yolo track model=/home/best_pt_files/1.0.2.pt source=/home/video.MP4

    Previously, the Python script worked without any issues. The memory issue has only recently started occurring. Could you please help me understand the possible reasons for this memory increase and how to address it?

    i have experimented with persist= True and False,stream = true and false, show = true and false also but the issue is still there

    1
    1. Glenn JocherUltralytics

      @rohith-aiunika thanks for reporting this. The memory buildup in Python scripts (but not CLI) typically occurs when not using streaming mode. To match the CLI's memory behavior, modify your Python script to process frames iteratively using stream=True:

      from ultralytics import YOLO
      
      model = YOLO("/home/best_pt_files/v1.0.2.pt")
      for result in model.track("/home/video.MP4", stream=True):  # Process frames iteratively
          pass  # Add your frame processing logic here

      This streams frames sequentially like the CLI, preventing memory accumulation. For more details, see the streaming implementation in our Tracking documentation. Let us know if this resolves the issue!

    2. rohith-aiunikaGitHub

      i have used stream = True, then the code is just executing without showing error and without tracking also

    3. Glenn JocherUltralytics

      @rohith-aiunika thanks for the update. Let's ensure you're properly iterating through streaming results. Try adding a processing loop like this:

      for result in model.track(source=video_path, stream=True):
          annotated_frame = result[0].plot()
          cv2.imshow('Tracking', annotated_frame)
          if cv2.waitKey(1) == ord('q'):
              break

      This actively processes each frame and displays tracking annotations. If issues persist, you might need to verify your video source format using our supported inference sources documentation.

  3. mwaselaGitHub

    Hello, Made a custom model that i can successfully run and with a well tweaked confidence filter, am getting good results.

    Now Ive wrapped the classification and tracking functionality into a flask app, that returns the count ID's when accessed by a REST call like get, meaning it can be accessed by a separate app for processing and stuff. I want to be able to reset the counting through some other request. My camera feed is always live, i need a way to reset the track id's to zero when neccessary, they just keep counting until i exit the program.

    1
    1. Glenn JocherUltralytics

      @mwasela hello,

      It's great to hear that your custom model is performing well. To reset the tracking IDs in your Flask app, you can implement a mechanism to reinitialize the tracker state upon receiving a specific request. This can be done by resetting the tracker object or reloading the model within your tracking function.

      For more detailed guidance on configuring and using trackers, please refer to our documentation: Multi-Object Tracking with Ultralytics YOLO.

  4. Orziqulov-JavohirGitHub

    I really need help to do this programm: I wanna select region via mouse "dangerous zone" Track detected person, If person enters this zone crop and save person's photo Can you show me pls how to do it for 10 cameras, my gpu is RTX 3080TI

    1
    1. Orziqulov-JavohirGitHub

      import cv2 from ultralytics import YOLO import time

      Load the YOLOv8 model

      model = YOLO("yolov8n.pt") # pretrained YOLOv8n model

      Initialize video capture for multiple cameras

      camera_ids = [

      'rtsp://admin:admin12345@172.17.67.20:554',

      'rtsp://admin:admin12345@172.17.67.16:554', 'rtsp://admin:admin12345@172.17.67.18:554', 'rtsp://admin:admin12345@172.17.67.19:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554',
      ]

      caps = [cv2.VideoCapture(camera_id) for camera_id in camera_ids]

      Open the video file

      roi_start = [(0, 0)] * len(caps) roi_end = [(0, 0)] * len(caps) drawing = [False] * len(caps)

      tracked_persons = [[] for _ in range(len(caps))] # List to track persons in dangerous zones

      def draw_rectangle(event, x, y, flags, param): global roi_start, roi_end, drawing idx = param # Use param to identify the camera index if event == cv2.EVENT_LBUTTONDOWN: drawing[idx] = True roi_start[idx] = (x, y) roi_end[idx] = (x, y) print(f"Camera {idx}: Started drawing rectangle at: {roi_start[idx]}") elif event == cv2.EVENT_MOUSEMOVE: if drawing[idx]: roi_end[idx] = (x, y) print(f"Camera {idx}: Updated rectangle end to: {roi_end[idx]}") elif event == cv2.EVENT_LBUTTONUP: drawing[idx] = False roi_end[idx] = (x, y) print(f"Camera {idx}: Finished drawing rectangle at: {roi_end[idx]}")

      Create a window and set mouse callback for each camera

      for idx in range(len(caps)): window_name = f'Video {idx}' cv2.namedWindow(window_name) cv2.setMouseCallback(window_name, draw_rectangle, idx)

      def is_inside_roi(x, y, roi_start, roi_end): x1, y1 = roi_start x2, y2 = roi_end return min(x1, x2) <= x <= max(x1, x2) and min(y1, y2) <= y <= max(y1, y2)

      while True: frames = [] for cap in caps: ret, frame = cap.read() if not ret: continue # frame = cv2.resize(frame, (640, 480)) frames.append(frame)

      for idx, frame in enumerate(frames):
          window_name = f'Video {idx}'
          
          # Draw the ROI rectangle on the frame
          if drawing[idx] or roi_start[idx] != roi_end[idx]:
              cv2.rectangle(frame, roi_start[idx], roi_end[idx], (0, 255, 0), 2)
              cv2.putText(frame, "Dangerous Zone", (roi_start[idx][0], roi_start[idx][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
      
          # Run YOLOv8 tracking on the frame, persisting tracks between frames
          results = model.track(frame, tracker="bytetrack.yaml", persist=True)
      
          for result in results:
              boxes = result.boxes
      
              for box in boxes:
                  x1, y1, x2, y2 = box.xyxy.tolist()[0][:4]
                  cls = box.cls.tolist()[0]
                  if cls == 0:  # Person class in COCO dataset
                      # Check if the center of the person is inside the ROI
                      cx, cy = int((x1 + x2) / 2), int((y1 + y2) / 2)
                      if is_inside_roi(cx, cy, roi_start[idx], roi_end[idx]):
                          # Check if this person is already tracked
                          person_id = box.id.tolist()[0] if box.id is not None else None
                          
                          if person_id not in tracked_persons[idx]:
                              tracked_persons[idx].append(person_id)
                              # Crop and save the frame
                              crop = frame[int(y1):int(y2), int(x1):int(x2)]
                              cv2.imwrite(f"cropped_camera{idx}_person{person_id}_{int(time.time())}.jpg", crop)
                              # Draw a label on the person
                              cv2.putText(frame, "Person in Dangerous Zone", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
                              cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
      
          cv2.imshow(window_name, frame)
      
      if cv2.waitKey(1) & 0xFF == ord('q'):
          break

      Release all video captures

      for cap in caps: cap.release() cv2.destroyAllWindows()

    2. Glenn JocherUltralytics

      Your approach looks solid for setting up a security program to track and save images of individuals entering a designated "dangerous zone" across multiple cameras. To enhance your implementation, ensure you're using the latest versions of the Ultralytics package for optimal performance and bug fixes. For more detailed guidance on tracking configurations and additional features, you can refer to the Ultralytics tracking documentation. If you encounter any specific issues or need further assistance, feel free to ask!

    3. mariem158GitHub

      File "", line 91 results = model.track(frame, persist=True, tracker="botsort.yaml") ^ IndentationError: unexpected indent COMMENT CORRIGER CETTE ERREUR

    4. Glenn JocherUltralytics

      The error you're encountering is due to an unexpected indent in your code. Ensure that the indentation is consistent throughout your script. If the issue persists, please verify it with the latest version of the Ultralytics package. For more details on tracking configurations, you can refer to the Ultralytics tracking documentation.

  5. GKYofficeGitHub

    How can I get the tracking metrics of a tracker such as MOTA, IDF1, etc.

    1
    1. GKYofficeGitHub

      Can I set the parameter ''save_txt'' to True in the track function, and then write code to evaluate the tracking data?

    2. Paula DerrengerUltralytics

      Currently, the Ultralytics YOLO framework doesn't provide built-in functionality for computing tracking metrics like MOTA or IDF1 directly through the API or command line. However, you can utilize external libraries such as MOTChallenge eval for calculating these metrics.

      After running your tracking with YOLOv8, you'd typically export your tracking results in a format compatible with these libraries (usually a .txt format with frame ID, object ID, bounding boxes, etc.). Then, use the external library to compute the desired metrics by providing it with both the ground truth and your results file.

      Here's a generic example on how you might save tracking results (modify based on your actual use case):

      from ultralytics import YOLO
      
      # Initialize and load your model
      model = YOLO("path/to/your/model.pt")
      
      # Tracking
      results = model.track(source='path/to/video.mp4', save_txt=True, project='runs/track', name='exp')
      
      # results are saved in 'runs/track/exp' in a format that can be used with MOTChallenge eval tools

      Afterwards, follow the documentation of the MOTChallenge eval toolkit to compute the metrics using the outputs stored in 'runs/track/exp'.

      If you encounter any specific issues while implementing this, feel free to ask!🛠️

  6. AdadAlShababGitHub

    Can I run two models simultaneously in one video? Ex: model = YOLO('E:/Ultralytics/best.pt') model = YOLO('yolov8m-pose.pt') results = model.track(source="file.mp4", show=True, conf=0.3, save=False) results = model.track(source="file.mp4", show=True, conf=0.3, save=False)

    I want that two models will works simultaneously with cumulative results? Is it possible? Please let me know. Thanks in advance!!

    1
    1. Paula DerrengerUltralytics

      @AdadAlShabab yes, you can run two models simultaneously on one video, but you'll need to manage the inference in a way that allows both models to process the video frames concurrently. Here's a simplified example using threading to achieve this:

      import threading
      from ultralytics import YOLO
      
      # Load the models
      model1 = YOLO('E:/Ultralytics/best.pt')
      model2 = YOLO('yolov8m-pose.pt')
      
      # Function to run tracking
      def track_video(model, source, conf, show, save):
          results = model.track(source=source, show=show, conf=conf, save=save)
          # Process results here or return them
      
      # Create threads for each model
      thread1 = threading.Thread(target=track_video, args=(model1, "file.mp4", 0.3, True, False))
      thread2 = threading.Thread(target=track_video, args=(model2, "file.mp4", 0.3, True, False))
      
      # Start the threads
      thread1.start()
      thread2.start()
      
      # Wait for both threads to finish
      thread1.join()
      thread2.join()

      This script will run both models in separate threads. If you want to combine the results from both models, you'll need to implement a mechanism to synchronize and merge the results from both threads. Keep in mind that displaying the results (show=True) from two threads might not work as expected, and you might need to handle the visualization separately.

      Remember to handle the GPU memory usage carefully, as running two models simultaneously will require more memory. If you encounter any issues, consider running the models sequentially or on separate GPUs if available.

      4
  7. Journey2-20GitHub

    Hello I'm newer to Opencv and I'm trying to run a tracking camera for airsoft. How would i select specific bounding boxes?

    1. Paula DerrengerUltralytics

      Use model.track(frame, persist=True) and inspect results[0].boxes.xyxy with results[0].boxes.id; select the box containing your OpenCV mouse-click coordinates, store its track ID, then process or draw only boxes whose boxes.id matches that ID. Feel free to continue posting questions here so the Ultralytics team can help.

  8. yashpatel2010GitHub

    In my jetson orin nano super developer kit with jetpack6.1 and deepstream7.1 i want to do cross camera person tracking. Is there any default way in deepstream configs to do it? Or any other lightweight thing that can be easily doable in jetson orin nano 8 gb super dev kit.

    1. Glenn JocherUltralytics

      Ultralytics track is single-camera MOT, so cross-camera person IDs are not built in; on DeepStream 7.1 the practical Orin Nano path is NvDeepSORT/ReID per stream plus downstream association from the exported embeddings described in the DeepStream gst-nvtracker docs, or NVIDIA’s separate Multi-Camera Tracking workflow for full MTMC. Please keep the details here in Discussions and share your current tracker config if you want a minimal setup suggestion. (docs.nvidia.com)

  9. anvi97GitHub(düzenlendi)

    Hi @glenn-jocher,

    I am building a road surface detection system using YOLO segmentation.

    My pipeline:

    Apply bird eye view using cv2.getPerspectiveTransform()

    Mask only road area

    Detect potholes, zebra crossings, and speed bumps

    I am facing the following issues:

    1️⃣ Overlapping Potholes Not Merging Properly

    I want overlapping potholes to merge into one bounding box.

    In many cases it works, but sometimes:

    Two boxes are still shown for the same pothole

    Even when they overlap visually

    I am using YOLO with:

    results = model(frame, conf=0.45, iou=0.4)

    Is YOLO’s internal NMS preventing full merging? Should I apply custom merging after inference? Is segmentation-based merging better than bounding box merging for potholes?

    2️⃣ Object Size Changing After Bird Eye View

    I calculate pothole size using:

    pixels_per_foot = 220

    But I selected this value randomly (no real-world measurement).

    Because of this:

    Object size changes depending on frame position

    Same pothole appears different size

    Is it correct that without real-world calibration, size cannot be accurate? What is the correct method to calculate real-world size in a monocular dashcam setup?

    3️⃣ Zebra Crossing vs Black–White Speed Bump Confusion

    Black–white speed bumps are getting confused with zebra crossings because both have parallel white-black stripes.

    Currently I am detecting only yellow speed bumps to avoid confusion.

    What is the better approach to separate them?

    Use segmentation instead of boxes?

    Add geometry-based filtering?

    Train with more hard-negative examples?

    1. anvi97GitHub

      this is my code ..... from ultralytics import YOLO import cv2 import numpy as np

      model = YOLO("runs/segment/pothole_seg_model3/weights/best.pt") pixels_per_foot = 220

      video_path = "sample_video.mp4" cap = cv2.VideoCapture(video_path)

      if not cap.isOpened(): print(" Cannot open video") exit()

      width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = cap.get(cv2.CAP_PROP_FPS) or 25.0

      fourcc = cv2.VideoWriter_fourcc(*'avc1') out = cv2.VideoWriter("pothole5.mp4", fourcc, fps, (width, height))

      STRETCH_AMOUNT = 50

      src = np.float32([ [0, height],
      [width, height],
      [922, 183],
      [265, 183]
      ])

      dst = np.float32([ [0, height], [width, height], [width + STRETCH_AMOUNT, 0], [0 - STRETCH_AMOUNT, 0] ])

      matrix = cv2.getPerspectiveTransform(src, dst) def compute_iou(box1, box2): x1 = max(box1[0], box2[0]) y1 = max(box1[1], box2[1]) x2 = min(box1[2], box2[2]) y2 = min(box1[3], box2[3])

      inter_area = max(0, x2 - x1) * max(0, y2 - y1)
      
      box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
      box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
      
      union = box1_area + box2_area - inter_area
      
      if union == 0:
          return 0
      
      return inter_area / union

      def should_merge(box1, box2, iou_thresh=0.1, dist_thresh=150): # Containment check - if one box is inside the other if (box1[0] >= box2[0] and box1[1] >= box2[1] and box1[2] <= box2[2] and box1[3] <= box2[3]): return True if (box2[0] >= box1[0] and box2[1] >= box1[1] and box2[2] <= box1[2] and box2[3] <= box1[3]): return True

      iou = compute_iou(box1, box2)
      if iou > iou_thresh:
          return True
      
      cx1, cy1 = (box1[0]+box1[2])/2, (box1[1]+box1[3])/2
      cx2, cy2 = (box2[0]+box2[2])/2, (box2[1]+box2[3])/2
      
      if np.sqrt((cx1-cx2)**2 + (cy1-cy2)**2) < dist_thresh:
          return True
      
      return False

      while True: ret, frame = cap.read() if not ret: break

      bird_eye = cv2.warpPerspective(frame, matrix, (width, height))
      
      results = model(bird_eye, conf=0.45, iou=0.4)[0]
      annotated = results.plot()
      
      if results.boxes is not None:
          for box in results.boxes:
              cls_id = int(box.cls.item())
      
              if cls_id == 0:  # pothole only
                  x1, y1, x2, y2 = map(int, box.xyxy.cpu().numpy()[0])
      
                  w_px = x2 - x1
                  h_px = y2 - y1
      
                  w_ft = w_px / pixels_per_foot
                  h_ft = h_px / pixels_per_foot
      
                  label = f"{w_ft:.2f}ft x {h_ft:.2f}ft"
      
                  cv2.putText(
                      annotated,
                      label,
                      (x1, y1 - 15),
                      cv2.FONT_HERSHEY_SIMPLEX,
                      0.6,
                      (0, 255, 255),
                      2
                  )
      
      cv2.imshow("Bird Eye + Pothole Detection", annotated)
      out.write(annotated)
      
      if cv2.waitKey(1) & 0xFF == 27:
          break

      cap.release() out.release() cv2.destroyAllWindows()

    2. Glenn JocherUltralytics

      For (1), YOLO’s NMS will only suppress duplicate detections based on iou=...—it won’t “merge” two overlapping detections into a larger union box, and in your snippet compute_iou() / should_merge() aren’t actually applied to results.boxes, so you’re still visualizing the raw post-NMS output; since you’re using a Segment model, the most robust way to merge “split” potholes is to union the pothole masks and re-extract connected components (then box/measure those) rather than trying to union boxes.

      import cv2
      import numpy as np
      
      r = model(bird_eye, conf=0.45, iou=0.4)[0]
      
      if r.masks is not None and r.boxes is not None:
          cls = r.boxes.cls.int().cpu().numpy()
          pothole_idx = np.where(cls == 0)[0]
          if pothole_idx.size:
              m = r.masks.data[pothole_idx].cpu().numpy()  # (N,H,W), 0/1
              union = (m.sum(0) > 0).astype(np.uint8) * 255
              n, labels = cv2.connectedComponents(union)
              for k in range(1, n):
                  ys, xs = np.where(labels == k)
                  x1, y1, x2, y2 = xs.min(), ys.min(), xs.max(), ys.max()
                  cv2.rectangle(bird_eye, (x1, y1), (x2, y2), (0, 255, 255), 2)

      For (2), yes—without real-world calibration (and a valid “road plane” assumption), pixels_per_foot=220 can’t be physically meaningful, and even with a BEV warp you only get consistent scale if your homography is tied to metric coordinates; the usual monocular approach is: calibrate camera intrinsics, estimate the road plane, build a homography to a top-down plane in real units (or derive scale from at least one known road-plane measurement like lane width/stripe spacing), then measure in the BEV plane.

      For (3), the best fix is usually data: train both classes explicitly with lots of “hard negatives” (zebra crossings that look like bumps and vice versa) and keep labels consistent; segmentation often helps because you can then add simple shape/location constraints on the mask (zebra = large repeated pattern region, bump = single narrow band across lane) and optionally smooth decisions over time (if you’re doing video, using model.track(..., persist=True) from the Track mode docs can help stabilize per-frame flicker, even though it won’t merge instances within a frame).

      If you can paste !yolo checks output and one representative frame (plus what you consider the “correct” merged result), I can suggest concrete thresholds/post-processing for your exact outputs.

    3. anvi97GitHub

      Representative frame In the attached frame:

      The large water-filled pothole on the left should be treated as a single instance.

      The small region in the top-left corner (currently detected as separate) should be merged with the large region.

      Essentially, all visually continuous damaged area should result in one bounding box / one connected component.

      Currently:

      Mask union + connected components splits them due to small segmentation gaps

      Goal:

      Treat visually continuous pothole surface as one instance for measurement stability.

    4. Glenn JocherUltralytics

      That split is expected because connectedComponents() treats any 1–2 px “mask hole” as a hard break, so add a small gap-closing step on the union mask (morphological close / dilate→erode) before components, with the kernel sized to the largest gap you still consider “visually continuous” (see Ultralytics YOLO segmentation docs for more mask/seg usage details):

      # union: uint8 {0,255}
      union = (m.sum(0) > 0).astype(np.uint8) * 255
      
      # bridge small gaps (tune kernel size to your expected mask discontinuities)
      k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (25, 25))
      union_closed = cv2.morphologyEx(union, cv2.MORPH_CLOSE, k_close, iterations=1)
      
      # optional: remove tiny speckles after closing
      k_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
      union_closed = cv2.morphologyEx(union_closed, cv2.MORPH_OPEN, k_open, iterations=1)
      
      n, labels = cv2.connectedComponents(union_closed)
  10. mslabdelhak29GitHub

    Reid doesn't work how can i fix it i tried to change it True in botsort.yaml but it doesn't work

    1. Glenn JocherUltralytics(düzenlendi)

      @mslabdelhak29 ReID is only supported by some trackers (for example BoT-SORT), not ByteTrack, and it’s enabled via the tracker YAML you pass at runtime. Copy the default config, enable ReID explicitly, and point track() to your copy:

      # custom_botsort.yaml
      tracker_type: botsort
      with_reid: True
      model: yolo26n-cls.pt  # or another YOLO classification weight you have locally
      from ultralytics import YOLO
      model = YOLO("yolo26n.pt")  # any YOLO detector
      results = model.track(source="path/to/video.mp4", tracker="custom_botsort.yaml", persist=True, show=False)

      If it still doesn’t work, you’re likely editing a different YAML than the one being loaded; always pass the path as above. Also share the output of yolo checks and the exact custom_botsort.yaml you used so we can verify your environment and keys. See the ReID section in the tracking guide and the BoT-SORT config for details: Multi‑Object Tracking docs and botsort.yaml config.