Baholash: MOTA, IDF1 va HOTA

import configparser
import contextlib
import inspect
import io
from pathlib import Path

import cv2
import numpy as np
import pandas as pd
import torch
import torchvision
import matplotlib.pyplot as plt
from scipy.optimize import linear_sum_assignment
from ultralytics import YOLO
from ultralytics.engine.results import Boxes
from ultralytics.trackers import BOTSORT, BYTETracker
from ultralytics.trackers.byte_tracker import STrack
from ultralytics.trackers.utils.kalman_filter import KalmanFilterXYWH
from ultralytics.utils import LOGGER, YAML, IterableSimpleNamespace
from ultralytics.utils.checks import check_yaml

LOGGER.setLevel("ERROR")
MOT = Path("datasets/MOT17/train")
VIDEOLAR = ["MOT17-02", "MOT17-04", "MOT17-05", "MOT17-09", "MOT17-10", "MOT17-11", "MOT17-13"]
KAMERA = {"MOT17-05": "harakatda", "MOT17-10": "harakatda", "MOT17-11": "harakatda", "MOT17-13": "harakatda"}

def seqinfo(video):
    ini = configparser.ConfigParser()
    ini.read(MOT / f"{video}-FRCNN" / "seqinfo.ini")
    s = ini["Sequence"]
    return int(s["seqLength"]), int(s["frameRate"]), (int(s["imHeight"]), int(s["imWidth"]))

model = YOLO("weights/yolo11n.pt")
for video in VIDEOLAR:
    fayl = Path(f"out/mot17/{video}_yolo11n_1280.txt")
    if fayl.exists():                                                # 09 va 10 oldingi boblarda saqlangan
        continue
    qatorlar = []
    for k, yol in enumerate(sorted((MOT / f"{video}-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")

qatorlar = []
for video in VIDEOLAR:
    n, fps, (h, w) = seqinfo(video)
    gt = np.loadtxt(MOT / f"{video}-FRCNN" / "gt" / "gt.txt", delimiter=",")
    d = np.loadtxt(f"out/mot17/{video}_yolo11n_1280.txt", delimiter=",")
    qatorlar.append({"video": video, "kadrlar": n, "fps": fps, "o'lcham": f"{w}x{h}", "kamera": KAMERA.get(video, "qo'zg'almas"),
                     "GT piyoda box": int((gt[:, 7] == 1).sum()), "YOLO11n box": len(d)})
show(pd.DataFrame(qatorlar))

SINF = {1: "piyoda", 2: "transportdagi odam", 3: "mashina", 4: "velosiped", 5: "mototsikl", 6: "motorsiz transport",
        7: "turgan odam", 8: "chalg'ituvchi", 9: "to'suvchi", 10: "yerdagi to'suvchi", 11: "to'liq to'suvchi", 12: "aks (oyna)"}
DISTRAKTOR = [2, 7, 8, 12]                       # transportdagi odam, turgan odam, chalg'ituvchi, aks
jadval, belgi = {}, []
for video in VIDEOLAR:
    gt = np.loadtxt(MOT / f"{video}-FRCNN" / "gt" / "gt.txt", delimiter=",")
    jadval[video] = {SINF[s]: int((gt[:, 7] == s).sum()) for s in SINF}
    belgi.append(np.array_equal(gt[:, 6] == 1, gt[:, 7] == 1))
show(pd.DataFrame(jadval))
print("6-ustun (hisobga olinadi) = 1 aynan piyodalarda, 7 videoning hammasida:", all(belgi))

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 xyxy_to_xywh(b):
    return np.array([(b[0] + b[2]) / 2, (b[1] + b[3]) / 2, b[2] - b[0], b[3] - b[1]])

def xywh_to_xyxy(x):
    return np.array([x[0] - x[2] / 2, x[1] - x[3] / 2, x[0] + x[2] / 2, x[1] + x[3] / 2])

kf = KalmanFilterXYWH()

class Trek:
    def __init__(self, tid, box):
        self.id, self.box, self.tasdiq, self.yoqolgan = tid, box, 1, 0
        self.m, self.P = kf.initiate(xyxy_to_xywh(box))

def mini_sort(det, kalman=True, venger=True, max_yoqolish=30, min_tasdiq=3, min_ishonch=0.25, min_iou=0.3):
    """10-bobdagi mini-SORT."""
    treklar, natija, oxirgi_id = [], [], 0
    for k in sorted(det):
        D = det[k][det[k][:, 4] >= min_ishonch]
        if kalman:
            for t in treklar:
                t.m, t.P = kf.predict(t.m, t.P)
        taxmin = [xywh_to_xyxy(t.m[:4]) if kalman else t.box for t in treklar]
        juftlar = []
        if treklar and len(D):
            M = iou_matritsa(taxmin, D)
            if venger:
                r, c = linear_sum_assignment(1 - M)
                juftlar = [(i, j) for i, j in zip(r, c) if M[i, j] >= min_iou]
            else:
                band_t, band_d = set(), set()
                for i, j in sorted(zip(*np.nonzero(M >= min_iou)), key=lambda juft: -M[juft]):
                    if i not in band_t and j not in band_d:
                        juftlar.append((i, j))
                        band_t.add(i)
                        band_d.add(j)
        for i, j in juftlar:
            t = treklar[i]
            t.m, t.P = kf.update(t.m, t.P, xyxy_to_xywh(D[j]))
            t.box, t.tasdiq, t.yoqolgan = D[j, :4], t.tasdiq + 1, 0
        ulangan_t, ulangan_d = {i for i, _ in juftlar}, {j for _, j in juftlar}
        for i, t in enumerate(treklar):
            if i not in ulangan_t:
                t.yoqolgan += 1
        treklar = [t for t in treklar if t.yoqolgan <= max_yoqolish]
        for j in range(len(D)):
            if j not in ulangan_d:
                oxirgi_id += 1
                treklar.append(Trek(oxirgi_id, D[j, :4]))
        for t in treklar:
            if t.yoqolgan == 0 and t.tasdiq >= min_tasdiq:
                natija.append((k, t.id, *(xywh_to_xyxy(t.m[:4]) if kalman else t.box)))
    return np.array(natija)

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

def ultralytics_tracker(det, sozlama, video):
    n, fps, olcham = seqinfo(video)
    klass = BOTSORT if sozlama.tracker_type == "botsort" else BYTETracker
    klass.reset_id()
    tracker = klass(args=sozlama, frame_rate=fps)
    yollar = sorted((MOT / f"{video}-FRCNN" / "img1").iterdir())
    natija = []
    for k in sorted(det):
        kadr = cv2.imread(str(yollar[k - 1])) if sozlama.tracker_type == "botsort" else None   # GMC va ReID kadrni ko'radi
        treklar = tracker.update(Boxes(np.c_[det[k], np.zeros(len(det[k]))], olcham), kadr)
        natija += [(k, int(t[4]), *t[:4]) for t in treklar]
    return np.array(natija)

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, seqinfo(video)[0] + 1)}                    # kadr -> (n, 5): x1 y1 x2 y2 ishonch

BAHO = Path("out/mot17/baho")

def oqi(fayl):
    a = np.loadtxt(fayl, delimiter=",", ndmin=2)
    return np.c_[a[:, :2], a[:, 2:4], a[:, 2:4] + a[:, 4:6]]           # (kadr, id, x1, y1, x2, y2)

def natija_fayli(papka, video, yarat):
    """Tracker natijasi MOTChallenge formatida. Fayl bo'lsa qayta hisoblamaydi."""
    fayl = BAHO / papka / "data" / f"{video}-FRCNN.txt"
    if not fayl.exists():
        fayl.parent.mkdir(parents=True, exist_ok=True)
        fayl.write_text("".join(f"{int(q[0])},{int(q[1])},{q[2]:.2f},{q[3]:.2f},{q[4] - q[2]:.2f},{q[5] - q[3]:.2f},1,-1,-1,-1\n"
                                for q in yarat()))
    return oqi(fayl)

TRACKERLAR = {"9-bob: oddiy IoU tracker": dict(kalman=False, venger=False, max_yoqolish=0, min_tasdiq=1),
              "+ Venger ulash": dict(kalman=False, venger=True, max_yoqolish=0, min_tasdiq=1),
              "+ Kalman bashorati": dict(kalman=True, venger=True, max_yoqolish=0, min_tasdiq=1),
              "+ xotira: 30 kadr": dict(kalman=True, venger=True, max_yoqolish=30, min_tasdiq=1),
              "+ tasdiq: 3 kadr": dict(kalman=True, venger=True, max_yoqolish=30, min_tasdiq=3),
              "+ ishonch 0.4 (mini-SORT)": dict(kalman=True, venger=True, max_yoqolish=30, min_tasdiq=3, min_ishonch=0.4),
              "ByteTrack": tracker_sozlama("bytetrack.yaml"),
              "ByteTrack, ikkinchi bosqichsiz": tracker_sozlama("bytetrack.yaml", track_low_thresh=0.25),
              "BoT-SORT, GMC siz": tracker_sozlama("botsort.yaml", gmc_method="none"),
              "BoT-SORT, GMC bilan": tracker_sozlama("botsort.yaml"),
              "BoT-SORT, GMC + ReID": tracker_sozlama("botsort.yaml", with_reid=True, model="weights/yolo26n-cls.pt")}
PAPKA = {nom: f"t{i:02d}" for i, nom in enumerate(TRACKERLAR)}

def ishga_tushir(sozlama, det, video):
    return mini_sort(det, **sozlama) if isinstance(sozlama, dict) else ultralytics_tracker(det, sozlama, video)

treklar = {}
for video in VIDEOLAR:
    det = yukla(video)
    for nom, s in TRACKERLAR.items():
        treklar[nom, video] = natija_fayli(PAPKA[nom], video, lambda: ishga_tushir(s, det, video))
print("MOT17-09, mini-SORT bosqichlaridagi ID lar (10-bob jadvali bilan solishtiring):",
      [len(np.unique(treklar[nom, "MOT17-09"][:, 1])) for nom in list(TRACKERLAR)[:6]])

def tayyorla(video, trek):
    """Qaytaradi: har kadr uchun (GT ID lar, tracker ID lar, IoU matritsa). ID lar 0 dan ketma-ket."""
    g = np.loadtxt(MOT / f"{video}-FRCNN" / "gt" / "gt.txt", delimiter=",")
    gt = np.c_[g[:, :2], g[:, 2:4], g[:, 2:4] + g[:, 4:6], g[:, 7]]     # kadr, id, x1, y1, x2, y2, sinf
    kadrlar = []
    for k in range(1, seqinfo(video)[0] + 1):
        G, T = gt[gt[:, 0] == k], trek[trek[:, 0] == k]
        S = iou_matritsa(G[:, 2:6], T[:, 2:6]) if len(G) and len(T) else np.zeros((len(G), len(T)))
        if len(G) and len(T):
            r, c = linear_sum_assignment(-np.where(S >= 0.5, S, 0))
            juft = S[r, c] >= 0.5
            olib = c[juft][np.isin(G[r[juft], 6], DISTRAKTOR)]           # distraktorga tushgan tracker box lari
            T, S = np.delete(T, olib, 0), np.delete(S, olib, 1)
        piyoda = G[:, 6] == 1
        kadrlar.append((G[piyoda, 1].astype(int), T[:, 1].astype(int), S[piyoda]))
    gi = np.unique(np.concatenate([k[0] for k in kadrlar]))
    ti = np.unique(np.concatenate([k[1] for k in kadrlar]))
    return [(np.searchsorted(gi, g), np.searchsorted(ti, t), S) for g, t, S in kadrlar]

tayyor = {v: tayyorla(v, treklar["ByteTrack", v]) for v in VIDEOLAR}
show(pd.DataFrame([{"video": v, "ByteTrack box lari": len(treklar["ByteTrack", v]),
                    "distraktorga tushib chiqarildi": len(treklar["ByteTrack", v]) - sum(len(t) for _, t, _ in tayyor[v])}
                   for v in VIDEOLAR]))

def clear_mot(kadrlar):
    tp = fn = fp = idsw = 0
    iou_yigindi = 0.0
    oxirgi, oldingi_kadr = {}, {}                  # GT -> oxirgi ulangan tracker ID; GT -> oldingi kadrdagi tracker ID
    for g, t, S in kadrlar:
        if not len(g) or not len(t):
            fn, fp = fn + len(g), fp + len(t)
            continue
        eski = np.array([oldingi_kadr.get(a, -1) for a in g])[:, None] == t[None]
        ball = np.where(S >= 0.5, S + 1000 * eski, 0)
        r, c = linear_sum_assignment(-ball)
        r, c = r[ball[r, c] > 0], c[ball[r, c] > 0]
        for a, b in zip(g[r], t[c]):
            idsw += a in oxirgi and oxirgi[a] != b
            oxirgi[a] = b
        oldingi_kadr = dict(zip(g[r], t[c]))
        tp, fn, fp = tp + len(r), fn + len(g) - len(r), fp + len(t) - len(r)
        iou_yigindi += S[r, c].sum()
    return {"TP": tp, "FN": fn, "FP": fp, "IDSW": idsw, "IoU": iou_yigindi}

def jami(sanoqlar):
    return {k: sum(s[k] for s in sanoqlar) for k in sanoqlar[0]}

for nom, s in (("MOT17-09", clear_mot(tayyor["MOT17-09"])), ("7 video", jami([clear_mot(tayyor[v]) for v in VIDEOLAR]))):
    gt_soni = s["TP"] + s["FN"]
    print(f"ByteTrack, {nom}: GT {gt_soni} | FN {s['FN']} ({s['FN'] / gt_soni:.1%}) | FP {s['FP']} ({s['FP'] / gt_soni:.1%}) | "
          f"IDSW {s['IDSW']} ({s['IDSW'] / gt_soni:.2%}) | MOTA {1 - (s['FN'] + s['FP'] + s['IDSW']) / gt_soni:.1%} | "
          f"MOTP {s['IoU'] / s['TP']:.3f}")

def sonlar(kadrlar):
    """Har bir GT va tracker ID necha kadrda bor."""
    return (np.bincount(np.concatenate([k[0] for k in kadrlar])).astype(float),
            np.bincount(np.concatenate([k[1] for k in kadrlar])).astype(float))

def idf1_sanoq(kadrlar):
    n_g, n_t = sonlar(kadrlar)
    M = np.zeros((len(n_g), len(n_t)))                  # M[g, t]: birga turgan kadrlar soni
    for g, t, S in kadrlar:
        a, b = np.nonzero(S >= 0.5)
        M[g[a], t[b]] += 1
    r, c = linear_sum_assignment(-M)
    return {"IDTP": M[r, c].sum(), "GT": n_g.sum(), "TR": n_t.sum()}

for nom, s in (("MOT17-09", idf1_sanoq(tayyor["MOT17-09"])), ("7 video", jami([idf1_sanoq(tayyor[v]) for v in VIDEOLAR]))):
    print(f"ByteTrack, {nom}: IDTP {s['IDTP']:.0f} | GT box {s['GT']:.0f} | tracker box {s['TR']:.0f} | "
          f"IDF1 {2 * s['IDTP'] / (s['GT'] + s['TR']):.1%}")

ALFA = np.arange(0.05, 0.99, 0.05)                      # 19 ta chegara

def hota_sanoq(kadrlar):
    n_g, n_t = sonlar(kadrlar)
    P = np.zeros((len(n_g), len(n_t)))                  # 1) juftlikning butun video bo'yicha o'xshashligi
    for g, t, S in kadrlar:
        maxraj = S.sum(0)[None] + S.sum(1)[:, None] - S
        P[np.ix_(g, t)] += np.divide(S, maxraj, out=np.zeros_like(S), where=maxraj > 0)
    umumiy = P / (n_g[:, None] + n_t[None] - P)
    TP, FN, FP = np.zeros(len(ALFA)), np.zeros(len(ALFA)), np.zeros(len(ALFA))
    C = np.zeros((len(ALFA), len(n_g), len(n_t)))       # 2) har alfa uchun: juftlik necha kadrda moslandi (TPA)
    for g, t, S in kadrlar:
        if not len(g) or not len(t):
            FN, FP = FN + len(g), FP + len(t)
            continue
        r, c = linear_sum_assignment(-umumiy[np.ix_(g, t)] * S)
        for i, alfa in enumerate(ALFA):
            m = S[r, c] >= alfa
            TP[i], FN[i], FP[i] = TP[i] + m.sum(), FN[i] + len(g) - m.sum(), FP[i] + len(t) - m.sum()
            C[i, g[r[m]], t[c[m]]] += 1
    A = C / np.maximum(1, n_g[:, None] + n_t[None] - C)  # TPA / (TPA + FNA + FPA)
    return {"H_TP": TP, "H_FN": FN, "H_FP": FP, "AssA_TP": (C * A).sum((1, 2))}

def sanoq(video, trek):
    k = tayyorla(video, trek)
    return {**clear_mot(k), **idf1_sanoq(k), **hota_sanoq(k)}

def yakuniy(s):
    """Sanoqlardan metrikalar (%). Bir nechta video: avval sanoqlar qo'shiladi (jami), keyin shu funksiya."""
    DetA = s["H_TP"] / np.maximum(1, s["H_TP"] + s["H_FN"] + s["H_FP"])
    AssA = s["AssA_TP"] / np.maximum(1, s["H_TP"])
    return {"HOTA": np.sqrt(DetA * AssA).mean() * 100, "DetA": DetA.mean() * 100, "AssA": AssA.mean() * 100,
            "MOTA": (1 - (s["FN"] + s["FP"] + s["IDSW"]) / (s["TP"] + s["FN"])) * 100, "MOTP": s["IoU"] / s["TP"] * 100,
            "IDF1": 2 * s["IDTP"] / (s["GT"] + s["TR"]) * 100, "IDSW": s["IDSW"], "FP": s["FP"], "FN": s["FN"]}

show(pd.DataFrame([{"ByteTrack": "MOT17-09", **yakuniy(sanoq("MOT17-09", treklar["ByteTrack", "MOT17-09"]))}]).round(2))

pip install --no-deps "trackeval @ git+https://github.com/JonathonLuiten/TrackEval.git@12c8791b303e0a0b50f753af204249e622d0281a"

np.float, np.int = float, int                          # TrackEval eski numpy nomlarini ishlatadi
import trackeval

bizniki = {(nom, v): sanoq(v, treklar[nom, v]) for nom in TRACKERLAR for v in VIDEOLAR}

with contextlib.redirect_stdout(io.StringIO()):         # TrackEval ning jarayon xabarlari kerak emas
    baholovchi = trackeval.Evaluator({"USE_PARALLEL": False, "PRINT_RESULTS": False, "PRINT_CONFIG": False, "TIME_PROGRESS": False,
                                      "OUTPUT_SUMMARY": False, "OUTPUT_DETAILED": False, "PLOT_CURVES": False})
    dataset = trackeval.datasets.MotChallenge2DBox({"GT_FOLDER": str(MOT), "TRACKERS_FOLDER": str(BAHO), "BENCHMARK": "MOT17",
                                                    "SKIP_SPLIT_FOL": True, "TRACKERS_TO_EVAL": list(PAPKA.values()),
                                                    "SEQ_INFO": {f"{v}-FRCNN": None for v in VIDEOLAR}, "PRINT_CONFIG": False})
    rasmiy, _ = baholovchi.evaluate([dataset], [trackeval.metrics.HOTA(), trackeval.metrics.CLEAR(), trackeval.metrics.Identity()])

farq = {}
for nom, papka in PAPKA.items():
    for v in VIDEOLAR + ["7 video"]:
        r = rasmiy["MotChallenge2DBox"][papka]["COMBINED_SEQ" if v == "7 video" else f"{v}-FRCNN"]["pedestrian"]
        s = yakuniy(jami([bizniki[nom, x] for x in VIDEOLAR]) if v == "7 video" else bizniki[nom, v])
        te = {"HOTA": r["HOTA"]["HOTA"].mean() * 100, "DetA": r["HOTA"]["DetA"].mean() * 100, "AssA": r["HOTA"]["AssA"].mean() * 100,
              "MOTA": r["CLEAR"]["MOTA"] * 100, "MOTP": r["CLEAR"]["MOTP"] * 100, "IDF1": r["Identity"]["IDF1"] * 100,
              "IDSW": r["CLEAR"]["IDSW"], "FP": r["CLEAR"]["CLR_FP"], "FN": r["CLEAR"]["CLR_FN"]}
        for m in te:
            farq[m] = max(farq.get(m, 0), abs(te[m] - s[m]))
print(f"{len(PAPKA)} tracker x {len(VIDEOLAR) + 1} (har video + 7 video birga) ta natija solishtirildi")
print("bizniki va TrackEval orasidagi eng katta farq:", {m: float(f"{x:.1e}") for m, x in farq.items()})

jadval = pd.DataFrame([{"tracker": nom, **yakuniy(jami([bizniki[nom, v] for v in VIDEOLAR]))} for nom in TRACKERLAR])
show(jadval.drop(columns="MOTP").round(2))

tanlangan = ["9-bob: oddiy IoU tracker", "+ ishonch 0.4 (mini-SORT)", "ByteTrack", "BoT-SORT, GMC siz", "BoT-SORT, GMC bilan", "BoT-SORT, GMC + ReID"]
show(pd.DataFrame([{"HOTA": nom, **{v: yakuniy(bizniki[nom, v])["HOTA"] for v in VIDEOLAR}} for nom in tanlangan]).round(1))

_, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 4.8))
s = jami([bizniki["ByteTrack", v] for v in VIDEOLAR])
det_a = s["H_TP"] / (s["H_TP"] + s["H_FN"] + s["H_FP"])
ass_a = s["AssA_TP"] / s["H_TP"]
for y, nom in ((det_a, "DetA"), (ass_a, "AssA"), (np.sqrt(det_a * ass_a), "HOTA")):
    ax1.plot(ALFA, y * 100, marker="o", ms=3, label=nom)
ax1.axvline(0.5, color="gray", lw=0.8, ls="--")
ax1.set_xlabel("IoU chegarasi α")
ax1.set_ylabel("%")
ax1.set_title("ByteTrack, 7 video", fontsize=10)
ax1.legend(fontsize=8)
for i, (nom, q) in enumerate(jadval.set_index("tracker").iterrows(), 1):
    ax2.scatter(q["DetA"], q["AssA"], color="C0" if i <= 6 else "C1")
    ax2.annotate(str(i), (q["DetA"], q["AssA"]), xytext=(5, 2) if i % 2 == 0 else (-12, 2), textcoords="offset points", fontsize=9)
ax2.set_xlabel("DetA, %")
ax2.set_ylabel("AssA, %")
ax2.set_title("1–6: mini-SORT bosqichlari, 7–11: ultralytics (jadval tartibida)", fontsize=10)
fig("hota_ichidan.png", "Chapda: IoU chegarasi oshgan sari aniqlash va bog'lash sifati tushadi; HOTA — 19 nuqtaning o'rtachasi. O'ngda: tracker lar asosan AssA bo'yicha farq qiladi.")

ideal = {"ByteTrack": [], "oddiy IoU tracker": []}
for video in VIDEOLAR:
    g = np.loadtxt(MOT / f"{video}-FRCNN" / "gt" / "gt.txt", delimiter=",")
    p = g[g[:, 7] == 1]
    det = {k: np.c_[p[p[:, 0] == k][:, 2:4], p[p[:, 0] == k][:, 2:4] + p[p[:, 0] == k][:, 4:6], np.ones((p[:, 0] == k).sum())]
           for k in range(1, seqinfo(video)[0] + 1)}
    ideal["ByteTrack"].append(sanoq(video, natija_fayli("ideal_bytetrack", video,
                                                        lambda: ultralytics_tracker(det, tracker_sozlama("bytetrack.yaml"), video))))
    ideal["oddiy IoU tracker"].append(sanoq(video, natija_fayli("ideal_oddiy", video,
                                                                lambda: mini_sort(det, **TRACKERLAR["9-bob: oddiy IoU tracker"]))))
show(pd.DataFrame([{"tracker": "ByteTrack", "detector": "YOLO11n", **yakuniy(jami([bizniki["ByteTrack", v] for v in VIDEOLAR]))},
                   {"tracker": "ByteTrack", "detector": "ideal (GT box)", **yakuniy(jami(ideal["ByteTrack"]))},
                   {"tracker": "oddiy IoU tracker", "detector": "YOLO11n", **yakuniy(jami([bizniki["9-bob: oddiy IoU tracker", v] for v in VIDEOLAR]))},
                   {"tracker": "oddiy IoU tracker", "detector": "ideal (GT box)", **yakuniy(jami(ideal["oddiy IoU tracker"]))}]).round(2))

print("\n".join(q.strip() for q in inspect.getsource(STrack.activate).splitlines() if "frame_id == 1" in q or "self.is_activated" in q))
print("\n".join(q.strip() for q in inspect.getsource(BYTETracker.update).splitlines() if "if x.is_activated" in q))

qatorlar = []
for chegara in (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7):
    s = dict(TRACKERLAR["+ ishonch 0.4 (mini-SORT)"], min_ishonch=chegara)
    sanoqlar = [sanoq(v, natija_fayli(f"ishonch_{chegara}", v, lambda: mini_sort(yukla(v), **s))) for v in VIDEOLAR]
    qatorlar.append({"ishonch chegarasi": chegara, **yakuniy(jami(sanoqlar))})
chegaralar = pd.DataFrame(qatorlar)
show(chegaralar.drop(columns="MOTP").round(2))

_, ax = plt.subplots(figsize=(8, 4.5))
for m in ("HOTA", "MOTA", "IDF1"):
    ax.plot(chegaralar["ishonch chegarasi"], chegaralar[m], marker="o", label=m)
    eng = chegaralar.loc[chegaralar[m].idxmax()]
    ax.scatter(eng["ishonch chegarasi"], eng[m], s=120, facecolors="none", edgecolors="black")
ax.set_xlabel("detector ishonch chegarasi")
ax.set_ylabel("%")
ax.legend()
fig("ishonch_chegarasi.png", "mini-SORT, 7 video. Qora doira — har metrikaning eng yuqori nuqtasi: uchala metrika uch xil chegarani tanlaydi.")