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 tespit edilen her nesne için benzersiz bir kimlik (ID) koruyan kritik bir görevdir. Uygulamalar, gözetim ve güvenlikten gerçek zamanlı spor analitiğine kadar sınırsızdır.

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

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

Ultralytics takipçilerinden gelen çıktı, standart nesne tespiti ile uyumludur ancak nesne kimlikleri (ID) şeklinde ek bir değer taşır. Bu, video akışlarında nesneleri takip etmeyi ve sonraki analitiği gerçekleştirmeyi kolaylaştırır. Nesne takibi ihtiyaçların için Ultralytics YOLO kullanmayı düşünmen gerektiğinin nedenleri ş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ırmasını destekler.
• Kullanım Kolaylığı: Hızlı entegrasyon ve dağıtım için basit Python API ve CLI seçenekleri sunar.
• Özelleştirilebilirlik: Özel olarak eğitilmiş YOLO modelleriyle kolayca kullanılabilir ve bu sayede alana özgü uygulamalara entegrasyona olanak tanır.

Gerçek Dünya Uygulamaları#

Hızlı Başlangıç#

Varsayılan TrackTrack takipçisi ile bir videoda takibi çalıştır. tracker argümanını değiştirerek başka bir takipçiye geçiş yap.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Default tracker (TrackTrack)
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")

Takipçiyi video akışlarında ç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 takipçiyle 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; herhangi bir tracker iletmediğinde tracktrack.yaml kullanılır:

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

Takipçileri Değiştirme#

Takipçi yapılandırma dosya adını tracker= öğesine 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ı#

Takip yapılandırması, conf, iou ve show gibi Predict modu ile özellikleri 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 ihtiyaçlarına göre herhangi bir yapılandırmayı (tracker_type hariç) 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 yer almaz:

Takipçiye Özel Argümanlar#

Her algoritma, paylaşılan parametrelere ek olarak ek ayar düğmeleri sunar. Açıklamalar ve ayarlama tavsiyeleri için aşağıdaki takipçi başlıklarına bak veya doğrudan yapılandırma dosyalarına göz at:

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

Yeniden Kimliklendirmeyi (ReID) Etkinleştirme#

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

ReID modeli seçenekleri:

• model: auto — Minimum ek yük ekleyerek yerel YOLO dedektör özelliklerini kullanır. Büyük bir performans düşüşü yaşamadan biraz ReID'ye ihtiyacın olduğunda idealdir. Dedektör uyumlu özellikleri 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ışarı aktarılmış gömme (embedding) modeline ya da bir OpenVINO model dizinine yönlendir. Dışarı aktarılan modeller AutoBackend aracılığıyla yüklenir ve doğrudan bir gömme tensörü çıktısı vermelidir.

Kullanıma hazır ONNX kodlayıcıları her model boyutu için yayınlanır. model: değerini bu adlardan birine ayarla ve dosya, takipçi ilk kez çalıştırıldığında (YOLO ağırlıklarının alınma şekliyle aynı şekilde) otomatik olarak indirilir; manuel dışarı aktarma veya indirme adımına gerek yoktur:

# 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 (backend) 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ışarı aktarıldıktan sonra, takipçi yapılandırmanda TensorRT model yolunu göster.

Takipçi Ayrıntıları#

Aşağıdaki bölümlerde her takipçinin tasarımı, belirli parametreleri ve ayar ipuçları açıklanmaktadır.

BoT-SORT#

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

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

Şunlar için idealdir: Genel amaçlı takip, özellikle hareketli kameralar. Yalnızca birbirine benzeyen kalabalıklar kimlik değişimlerine yol açtığında ReID ekle.

BoT-SORT özel 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 değerini koru; ecc daha doğrudur ancak daha yavaştır.
• Birbirine benzeyen kalabalıklar: with_reid: True değerini aç ve appearance_thresh değerini artır (örn. 0.85+).

ByteTrack#

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

• Aşama 1: Yüksek puanlı tespitleri aktif takiple eşleştir.
• Aşama 2: Kısa süreli kısmi kapanmaları telafi etmek için eşleşmeyen takipleri düşük puanlı tespitlerle yeniden dene.

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

Şunlar için idealdir: Dedektör maliyetinin baskın olduğu ve minimum takipçi yükü istediğin statik veya statik olmaya yakın kameralar.

ByteTrack özel argümanları: Paylaşılan takipçi argümanları dışında hiçbiri yoktur.

İnce ayar ipuçları:

• Gürültülü dedektör: İkinci aşamanın daha fazla adaya sahip olması için track_low_thresh değerini düşür.
• Yüksek geri çağırma dedektörü: Parçalanmış kimlikleri azaltmak için track_high_thresh değerini artır.
• Sık kimlik titremesi: Kısa süreliğine kaçırılan takiplerin hayatta kalması için track_buffer değerini artır.

OC-SORT#

OC-SORT (Cao ve ark., CVPR 2023), SORT'un gözlem merkezli bir uzantısıdır. SORT'un hafif tasarımını korur (görünüm özellikleri yoktur) 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 kayan hızı onarmak için Kalman güncellemesini yeniden çalıştırır.
• Gözlem Merkezli Momentum (OCM): Bir hız tutarlılığı terimi aracılığıyla yanlış yönde hareket eden tespitlere ceza verir.
• Gözlem Merkezli Kurtarma (OCR): Tahmini durum yerine son gözlemlerini kullanarak eşleşmeyen tespitleri yakın zamanda kaybolan takiplere karşı yeniden kontrol eder.

Şunlar için idealdir: Bir ReID modelinin maliyeti olmaksızın doğrusal olmayan hareket.

OC-SORT özel 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 değerini etkinleştir.
• Uzun kapanmalar: OCR'nin yeniden bağlayacak daha fazla kayıp takip bulabilmesi için track_buffer değerini artır.

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

Deep OC-SORT#

Deep OC-SORT, OC-SORT'a görünüm bilgisi ve kamera hareketi telafisi ekler:

• Görünüm eşleştirme: Kosinüs gömme mesafesi çakışma ile sınırlanır ve hareket maliyetiyle birleştirilir.
• Dinamik görünüm EMA: Takip gömmeleri, yumuşatma faktörü tespit güvenine göre uyarlanan bir EMA ile güncellenir.
• Kamera Hareketi Telafisi: Kalman durumları, seyrek optik akış, ORB veya ECC aracılığıyla kareden kareye bükülür.

Şunlar için idealdir: 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 özel 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 artır.
• Hareketli kamera: gmc_method: sparseOptFlow ayarını yap (Deep OC-SORT varsayılan olarak none kullanır).
• Düşük gecikme: Yalnızca hareket + CMC için with_reid: False (varsayılan) değerini koru; ReID'yi yalnızca kimlik değişimleri hatalara baskın çıktığında etkinleştir.

FastTracker#

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

• Kapanma tespiti: Diğer aktif takiplerdeki kapsam occ_cover_thresh değerini aştığında takipleri kapanmış olarak işaretler.
• Kapanmada Kalman geri alma: Halka tamponlu geçmişi kullanarak Kalman durumunu kapanma öncesi bir kareye geri döndürür.
• Hareket sönümleme ve arama genişletme: Kapanma sırasında hız sönümlenir ve tahmini kutu büyütülür.
• Init-IoU bastırma: Yeni takipçilerin aktif takipçilerin üzerinde türemesini engeller.

Şunlar için idealdir: Sık hedef çakışmalarının olduğu gerçek zamanlı yalnızca tespit boru hatları (kalabalıklar, kuyruklar, spor).

FastTracker özel argümanları:

İnce ayar ipuçları:

• Sık kısmi kapanmalar: occ_cover_thresh değerini düşür (örn. 0.5-0.6).
• Çakışma etrafında yinelenen kimlikler: init_iou_suppress değerini düşür (örn. 0.5).
• Uzun 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 yakın); daha geniş bir arama bölgesi iyileştirme sağladığında yalnızca enlarge_bbox_occ değerini artır.

TrackTrack#

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

• Takip Perspektifi Tabanlı İlişkilendirme (TPA): HMIoU, isteğe bağlı kosinüs ReID mesafesi, güven projeksiyon mesafesi ve köşe açı mesafesini birleştirir. Atama, esnek bir eşikle yinelemeli olarak çözülür.
• Takip Farkındalı Başlatma (TAI): Yeni bir kimlik oluşturulmadan önce yinelenen üretimleri bastırır.

Şunlar için idealdir: Yinelenen kimliklerin sorun oluşturduğu, sık kapanmaların olduğu kalabalık sahneler.

TrackTrack özel argümanları:

İnce ayar ipuçları:

• Kalabalık yayalar: Daha fazla yinelenen üretimi bastırmak 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 değerini 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 maliyeti ekler; kısa kapanmalar için varsayılan çok ipuçlu maliyet genellikle yeterlidir.

Segment ve Pose modelleri ile TrackTrack, maskelerin ve anahtar noktaların tespitleriyle hizalı kalması için gevşek NMS tespit kurtarılmasını atlar.

Python Örnekleri#

Takipleri Döngü İçinde Sürdürme#

İşte video kareleri üzerinde nesne takibi çalıştırmak için OpenCV (cv2) ve YOLO26 kullanan bir Python betiği. Bu betik, gerekli paketlerin (opencv-python ve ultralytics) halihazırda kurulu olduğunu varsayar. persist=True argümanı, takipçiye mevcut görüntünün veya karenin bir dizideki sıradaki olduğunu ve mevcut görüntüde önceki görüntüden gelen takipleri 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 takibini etkinleştiren model(frame) ile model.track(frame) arasındaki değişiklik lütfen dikkate alınsın. Bu değiştirilmiş komut dosyası, izleyiciyi videonun her kareinde ç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#

Ardışık kareler üzerindeki nesne izlerini görselleştirmek, bir videoda tespit edilen nesnelerin hareket kalıpları ve davranışları hakkında değerli bilgiler 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 karesi üzerindeki hareketini çizdirmek için YOLO26'nın takip yeteneklerinin nasıl kullanılacağını gösteriyoruz. Bu komut dosyası, bir video dosyası açmayı, bunu kare kare okumayı ve çeşitli nesneleri belirleyip takip etmek için YOLO modelini kullanmayı içerir. Tespit edilen sınırlayıcı kutuların merkez noktalarını tutarak ve bunları birbirine bağlayarak, 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ı Takip#

Çok iş parçacıklı takip, birden fazla video akışında nesne takibini aynı anda ç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 girdilerini işlerken özellikle yararlıdır.

Sağlanan Python komut dosyasında, 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ığı, izleyiciyi bir video dosyasında ç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 takip 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: her biri farklı bir video dosyasındaki nesneleri takip eden yolo26n.pt ve yolo26n-seg.pt. Video dosyaları SOURCES içinde belirtilmiştir.

threading.Thread içindeki daemon=True parametresi, bu iş parçacıklarının ana program biter bitmez kapatılacağı anlamına gelir. Ardından iş parçacıklarını start() ile başlatırız 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örevini tamamladıktan sonra, sonuçları görüntüleyen 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): 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

# 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ını ve modeli işlemek için kolayca genişletilebilir.

Yeni İzleyiciler Katkısında Bulun#

Çoklu nesne takibinde uzman mısın ve Ultralytics YOLO ile bir takip algoritmasını başarıyla uyguladın veya uyarladın mı? Seni ultralytics/cfg/trackers içindeki İzleyiciler bölümümüze katkıda bulunmaya davet ediyoruz! Gerçek dünyadaki uygulamaların ve çözümlerin, takip görevleri üzerinde çalışan kullanıcılar için çok değerli olabilir.

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

Katkını başlatmak için, lütfen bir Pull Request (PR) 🛠️ göndermeye yönelik kapsamlı talimatlar için Contributing Guide kılavuzumuza göz at. Neler ortaya koyacağını görmek için heyecanlıyız!

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

SSS#