ByteTrack va BoT-SORT: ultralytics dagi tayyor tracker lar

import inspect
import time
from pathlib import Path

import cv2
import numpy as np
import pandas as pd
import torch
import torchvision
import matplotlib.pyplot as plt
from ultralytics import YOLO
from ultralytics.engine.results import Boxes
from ultralytics.trackers import BOTSORT, BYTETracker
from ultralytics.trackers.utils.gmc import GMC
from ultralytics.utils import LOGGER, YAML, IterableSimpleNamespace
from ultralytics.utils.checks import check_yaml

LOGGER.setLevel("ERROR")
MOT = Path("datasets/MOT17/train")

model = YOLO("weights/yolo11n.pt")
kadrlar = sorted((MOT / "MOT17-09-FRCNN" / "img1").iterdir())
korsat = {}
for k, yol in enumerate(kadrlar[:120], 1):
    r = model.track(yol, persist=True, tracker="botsort.yaml", classes=[0], imgsz=1280, device=0, verbose=False)[0]
    if k in (30, 75, 120):
        korsat[k] = r.plot(line_width=6, font_size=44, conf=False)[:, :, ::-1]   # ID lar chizilgan kadr (RGB)
print("120-kadrdagi box lar ID lari:", r.boxes.id.int().tolist())
print("box lar soni:", len(r.boxes), "| r.boxes.is_track:", r.boxes.is_track)

_, axes = plt.subplots(1, 3, figsize=(15, 3.1))
for ax, (k, rasm) in zip(axes, korsat.items()):
    ax.imshow(rasm)
    ax.set_title(f"{k}-kadr", fontsize=10)
    ax.axis("off")
fig("track_api.png", "model.track(): har box yonida 'id:N' — tracker bergan raqam. Bir xil odam kadrdan kadrga bir xil raqamda qoladi.")

sozlama = YAML.load(check_yaml("botsort.yaml"))
izoh = {"tracker_type": "botsort yoki bytetrack",
        "track_high_thresh": "birinchi bosqich: shundan yuqori ishonchli box lar",
        "track_low_thresh": "ikkinchi bosqich: shundan yuqori, lekin birinchidan past box lar",
        "new_track_thresh": "ulanmagan box shundan yuqori bo'lsagina yangi trek ochiladi",
        "track_buffer": "yo'qolgan trek necha kadr kutiladi (30 fps da 30 = 1 soniya)",
        "match_thresh": "ulash narxining chegarasi (narx = 1 - IoU x ishonch)",
        "fuse_score": "narxga detector ishonchini qo'shish",
        "gmc_method": "kamera harakatini topish usuli (none — o'chirilgan)",
        "proximity_thresh": "ReID: shundan kam IoU li juftlarga tashqi ko'rinish ishlatilmaydi",
        "appearance_thresh": "ReID: tashqi ko'rinish o'xshashligi chegarasi",
        "with_reid": "tashqi ko'rinishdan foydalanish (12-bob)",
        "model": "ReID modeli (auto — detector ning o'z xususiyatlari)"}
show(pd.DataFrame([{"parametr": k, "qiymat": v, "ma'nosi": izoh.get(k, "")} for k, v in sozlama.items()]), 20)

kod = inspect.getsource(BYTETracker.update).splitlines()
kalit = ("thresh", "Step", "linear_assignment", "init_track(")
print("\n".join(q.rstrip() for q in kod if any(s in q for s in kalit)))

def yukla(video):
    d = np.loadtxt(f"out/mot17/{video}_yolo11n_1280.txt", delimiter=",")
    return {k: np.c_[d[d[:, 0] == k][:, 2:4], d[d[:, 0] == k][:, 2:4] + d[d[:, 0] == k][:, 4:6], d[d[:, 0] == k][:, 6]]
            for k in range(1, int(d[:, 0].max()) + 1)}                 # kadr -> (n, 5): x1 y1 x2 y2 ishonch

def tracker_sozlama(yaml_nomi, **ozgartirish):
    s = YAML.load(check_yaml(yaml_nomi))
    s.update(ozgartirish)
    return IterableSimpleNamespace(**s)

def ishga_tushir(det, sozlama, kadrlar=None, olcham=(1080, 1920)):
    """Ultralytics tracker ini tayyor box lar bilan yuritadi. Qaytaradi: (kadr, id, x1, y1, x2, y2) va ms/kadr."""
    klass = BOTSORT if sozlama.tracker_type == "botsort" else BYTETracker
    klass.reset_id()                                                   # ID lar 1 dan boshlansin
    tracker = klass(args=sozlama, frame_rate=30)
    natija, vaqt = [], 0.0
    for k in sorted(det):
        kadr = cv2.imread(str(kadrlar[k - 1])) if kadrlar is not None else None
        boxlar = Boxes(np.c_[det[k], np.zeros(len(det[k]))], olcham)  # oxirgi ustun — sinf (0 = odam)
        t0 = time.perf_counter()
        treklar = tracker.update(boxlar, kadr)
        vaqt += time.perf_counter() - t0
        natija += [(k, int(t[4]), *t[:4]) for t in treklar]            # t: x1 y1 x2 y2 id ishonch sinf indeks
    return np.array(natija), vaqt / len(det) * 1000

def iou_matritsa(a, b):
    return torchvision.ops.box_iou(torch.tensor(np.asarray(a)[:, :4], dtype=torch.float64),
                                   torch.tensor(np.asarray(b)[:, :4], dtype=torch.float64)).numpy()

def id_tahlili(trek, piyoda):
    """9-10-boblardagi kabi: GT odamga berilgan ID lar, ID almashishlari va topilgan GT box lar (CLEAR-MOT qoidasi)."""
    idlar, oxirgi, almashish, topildi = {}, {}, 0, 0
    for k in np.unique(piyoda[:, 0]).astype(int):
        G, P = piyoda[piyoda[:, 0] == k], trek[trek[:, 0] == k]
        if not len(P):
            continue
        M = iou_matritsa(np.c_[G[:, 2], G[:, 3], G[:, 2] + G[:, 4], G[:, 3] + G[:, 5]], P[:, 2:6])
        juftlar, band_g, band_p = [], set(), set()
        for a in range(len(G)):
            b = np.nonzero(P[:, 1] == oxirgi.get(int(G[a, 1]), -1))[0]
            if len(b) and b[0] not in band_p and M[a, b[0]] >= 0.5:
                juftlar.append((a, b[0]))
                band_g.add(a)
                band_p.add(b[0])
        for a, b in sorted(zip(*np.nonzero(M >= 0.5)), key=lambda juft: -M[juft]):
            if a not in band_g and b not in band_p:
                juftlar.append((a, b))
                band_g.add(a)
                band_p.add(b)
        for a, b in juftlar:
            gid, pid = int(G[a, 1]), int(P[b, 1])
            topildi += 1
            idlar.setdefault(gid, []).append((k, pid))
            if gid in oxirgi and oxirgi[gid] != pid:
                almashish += 1
            oxirgi[gid] = pid
    return idlar, almashish, topildi

def solishtir(video, variantlar):
    det, kadrlar = yukla(video), sorted((MOT / f"{video}-FRCNN" / "img1").iterdir())
    gt = np.loadtxt(MOT / f"{video}-FRCNN" / "gt" / "gt.txt", delimiter=",")
    piyoda = gt[(gt[:, 7] == 1) & (gt[:, 6] == 1)]
    qatorlar = []
    for nom, s, rasm_kerak in variantlar:
        trek, ms = ishga_tushir(det, s, kadrlar if rasm_kerak else None)
        idlar, almashish, topildi = id_tahlili(trek, piyoda)
        qatorlar.append({"tracker": nom, "ID lar": len(np.unique(trek[:, 1])), "ID almashishi": almashish,
                         "bir odamga ID": np.mean([len({p for _, p in v}) for v in idlar.values()]),
                         "topilgan GT, %": topildi / len(piyoda) * 100, "tracker, ms/kadr": ms})
    return pd.DataFrame(qatorlar)

variantlar = [("ByteTrack", tracker_sozlama("bytetrack.yaml"), False),
              ("ByteTrack, ikkinchi bosqichsiz", tracker_sozlama("bytetrack.yaml", track_low_thresh=0.25), False),
              ("BoT-SORT, GMC bilan", tracker_sozlama("botsort.yaml"), True),
              ("BoT-SORT, GMC siz", tracker_sozlama("botsort.yaml", gmc_method="none"), True)]
mini_sort = {"tracker": "10-bob: mini-SORT (ishonch 0.4)", "ID lar": 90, "ID almashishi": 73, "bir odamga ID": 3.4,
             "topilgan GT, %": 69.69, "tracker, ms/kadr": 0.28}          # 10-bobdagi jadvaldan
show(pd.concat([pd.DataFrame([mini_sort]), solishtir("MOT17-09", variantlar)]).round(2))

fayl = Path("out/mot17/MOT17-10_yolo11n_1280.txt")
if not fayl.exists():                                               # 9-bobdagi kabi: bir marta, 1280 da, conf >= 0.1
    qatorlar = []
    for k, yol in enumerate(sorted((MOT / "MOT17-10-FRCNN" / "img1").iterdir()), 1):
        b = model.predict(yol, classes=[0], conf=0.1, imgsz=1280, device=0, verbose=False)[0].boxes
        for x in np.hstack([b.xyxy.cpu().numpy(), b.conf.cpu().numpy()[:, None]]):
            qatorlar.append(f"{k},-1,{x[0]:.1f},{x[1]:.1f},{x[2] - x[0]:.1f},{x[3] - x[1]:.1f},{x[4]:.4f}")
    fayl.write_text("\n".join(qatorlar) + "\n")
print("MOT17-10 box lari:", sum(1 for _ in open(fayl)))

_, axes = plt.subplots(1, 2, figsize=(12, 3.4), sharey=True)
for ax, video in zip(axes, ("MOT17-09", "MOT17-10")):
    gmc = GMC(method="sparseOptFlow")
    siljish = np.array([gmc.apply(cv2.imread(str(p)))[:, 2] for p in sorted((MOT / f"{video}-FRCNN" / "img1").iterdir())])
    ax.plot(siljish[:, 0], label="t_x (gorizontal)", lw=1.2)
    ax.plot(siljish[:, 1], label="t_y (vertikal)", lw=1.2)
    ax.set_title(f"{video}: kadrlar orasidagi kamera siljishi", fontsize=10)
    ax.set_xlabel("kadr")
    print(f"{video}: o'rtacha |t_x| = {np.abs(siljish[:, 0]).mean():.2f} px, eng katta |t_x| = {np.abs(siljish[:, 0]).max():.1f} px")
axes[0].set_ylabel("px / kadr")
axes[1].legend(fontsize=8)
fig("gmc.png", "GMC baholagan kamera siljishi: qo'zg'almas kamerada nolga yaqin, harakatdagi kamerada kadriga o'nlab pikselgacha.")

variantlar = [("ByteTrack", tracker_sozlama("bytetrack.yaml"), False),
              ("BoT-SORT, GMC siz", tracker_sozlama("botsort.yaml", gmc_method="none"), True),
              ("BoT-SORT, GMC bilan", tracker_sozlama("botsort.yaml"), True)]
show(solishtir("MOT17-10", variantlar).round(2))