Tracking: "bu o'sha odammi?"

# MOT17 (9-bob): 5.9 GB arxivdan faqat train qismidagi FRCNN papkalari (~850 MB)
if not (root / "MOT17" / "train").exists():
    download("https://motchallenge.net/data/MOT17.zip", dir=root, unzip=False)
    with zipfile.ZipFile(root / "MOT17.zip") as z:
        kerak = [n for n in z.namelist() if n.startswith("MOT17/train/") and "-FRCNN/" in n]
        z.extractall(root, kerak)
    (root / "MOT17.zip").unlink()                                            # 5.9 GB arxiv endi kerak emas

curl -C - -o datasets/MOT17.zip https://motchallenge.net/data/MOT17.zip

import configparser
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.utils import LOGGER

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

sayt = {"02": (62, 18581, "qo'zg'almas"), "04": (83, 47557, "qo'zg'almas"), "05": (133, 6917, "harakatda"),
        "09": (26, 5325, "qo'zg'almas"), "10": (57, 12839, "harakatda"), "11": (75, 9436, "harakatda"),
        "13": (110, 11642, "harakatda")}                        # motchallenge.net/data/MOT17 jadvalidan
qatorlar = []
for papka in sorted(MOT.iterdir()):
    ini = configparser.ConfigParser()
    ini.read(papka / "seqinfo.ini")
    s = ini["Sequence"]
    gt = np.loadtxt(papka / "gt" / "gt.txt", delimiter=",")
    piyoda = gt[(gt[:, 7] == 1) & (gt[:, 6] == 1)]              # 7-ustun: sinf (1 = piyoda), 6-ustun: hisobga olinadimi
    raqam = papka.name[6:8]
    qatorlar.append({"video": papka.name[:8], "fps": int(s["frameRate"]), "o'lcham": f"{s['imWidth']}x{s['imHeight']}",
                     "kadrlar": int(s["seqLength"]), "treklar": len(np.unique(piyoda[:, 1])), "sayt: treklar": sayt[raqam][0],
                     "box lar": len(piyoda), "sayt: box lar": sayt[raqam][1], "kamera": sayt[raqam][2]})
show(pd.DataFrame(qatorlar))

gt_yol = MOT / "MOT17-09-FRCNN" / "gt" / "gt.txt"
print("".join(open(gt_yol).readlines()[:3]))
gt = np.loadtxt(gt_yol, delimiter=",")
sinf_nomi = {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"}
show(pd.DataFrame([{"sinf": int(k), "nomi": sinf_nomi[int(k)], "qatorlar": int((gt[:, 7] == k).sum()),
                    "hisobga olinadi (6-ustun = 1)": int(((gt[:, 7] == k) & (gt[:, 6] == 1)).sum())} for k in np.unique(gt[:, 7])]))

piyoda = gt[(gt[:, 7] == 1) & (gt[:, 6] == 1)]
birinchi = cv2.imread(str(MOT / "MOT17-09-FRCNN" / "img1" / "000001.jpg"))[:, :, ::-1]
_, ax = plt.subplots(figsize=(11, 6.2))
ax.imshow(birinchi, alpha=0.6)
ranglar = plt.cm.tab20(np.linspace(0, 1, 20))
for j, tid in enumerate(np.unique(piyoda[:, 1])):
    t = piyoda[piyoda[:, 1] == tid]
    t = t[np.argsort(t[:, 0])]
    ax.plot(t[:, 2] + t[:, 4] / 2, t[:, 3] + t[:, 5], color=ranglar[j % 20], lw=2)      # oyoq o'rtasi
    ax.text(t[0, 2] + t[0, 4] / 2, t[0, 3] + t[0, 5], str(int(tid)), color="white", fontsize=8,
            bbox=dict(fc=ranglar[j % 20], ec="none", pad=1), clip_on=True)
ax.set_xlim(0, birinchi.shape[1])                                # kadrdan chiqib ketgan oyoqlar chizilmasin
ax.set_ylim(birinchi.shape[0], 0)
ax.axis("off")
fig("mot09_yollar.png", "MOT17-09: 26 ta piyodaning 525 kadrdagi yo'llari, birinchi kadr ustida. Raqam — trek boshlanadigan joy.")

v = piyoda[:, 8]
print(f"piyoda box lari: {len(v)}")
print(f"yarmidan kami ko'rinadi (ko'rinish < 0.5):  {(v < 0.5).mean() * 100:.1f}%")
print(f"deyarli ko'rinmaydi (ko'rinish < 0.1):      {(v < 0.1).mean() * 100:.1f}%")

t1 = piyoda[piyoda[:, 1] == 1]
kadrlar = [20, 31, 40, 50, 55, 70]
_, axes = plt.subplots(1, len(kadrlar), figsize=(12, 3.6))
for ax, k in zip(axes, kadrlar):
    q = t1[t1[:, 0] == k][0]
    x, y, w, h = q[2:6].astype(int)
    rasm = cv2.imread(str(MOT / "MOT17-09-FRCNN" / "img1" / f"{k:06d}.jpg"))[:, :, ::-1]
    ax.imshow(rasm[max(y, 0):y + h, max(x, 0):x + w])
    ax.set_title(f"{k}-kadr\nko'rinish {q[8]:.2f}", fontsize=9)
    ax.axis("off")
fig("toslish.png", "Bitta odamning GT box i: 31–50-kadrlarda box bor, lekin odam to'suvchi orqasida.")

kadr_yollari = sorted((MOT / "MOT17-09-FRCNN" / "img1").iterdir())
model = YOLO("weights/yolo11n.pt")
det, qatorlar = {}, []
for imgsz in (640, 1280):
    natijalar = [model.predict(f, classes=[0], conf=0.1, imgsz=imgsz, device=0, verbose=False)[0] for f in kadr_yollari]
    qatorlar.append({"imgsz": imgsz, "box lar (conf ≥ 0.1)": sum(len(r.boxes) for r in natijalar),
                     "ulardan conf ≥ 0.25": sum(int((r.boxes.conf >= 0.25).sum()) for r in natijalar),
                     **{k: float(np.median([r.speed[k] for r in natijalar])) for k in ("preprocess", "inference", "postprocess")}})
    det[imgsz] = {i: np.hstack([r.boxes.xyxy.cpu().numpy(), r.boxes.conf.cpu().numpy()[:, None]])
                  for i, r in enumerate(natijalar, 1)}                        # kadr -> (n, 5): x1 y1 x2 y2 ishonch
show(pd.DataFrame(qatorlar).round(2))

# keyingi boblar uchun: MOT det formatida (kadr, -1, x, y, w, h, ishonch) saqlaymiz
Path("out/mot17").mkdir(parents=True, exist_ok=True)
qator = [f"{k},-1,{b[0]:.1f},{b[1]:.1f},{b[2] - b[0]:.1f},{b[3] - b[1]:.1f},{b[4]:.4f}" for k, bb in det[1280].items() for b in bb]
Path("out/mot17/MOT17-09_yolo11n_1280.txt").write_text("\n".join(qator) + "\n")
print("saqlandi:", len(qator), "qator")

def iou_matritsa(a, b):
    return torchvision.ops.box_iou(torch.tensor(a[:, :4]), torch.tensor(b[:, :4])).numpy()

def oddiy_tracker(det, min_ishonch=0.25, min_iou=0.3):
    """Faqat oldingi kadr bilan IoU bo'yicha ochko'z ulash. Qaytaradi: (kadr, id, x1, y1, x2, y2) qatorlar va ID lar soni."""
    natija, oldingi, oldingi_id, oxirgi_id = [], np.zeros((0, 5)), [], 0
    for k in sorted(det):
        d = det[k][det[k][:, 4] >= min_ishonch]
        idlar = [-1] * len(d)
        if len(oldingi) and len(d):
            M = iou_matritsa(oldingi, d)
            band_eski, band_yangi = set(), set()
            for e, y in sorted(zip(*np.nonzero(M >= min_iou)), key=lambda juft: -M[juft]):   # katta IoU dan boshlab
                if e not in band_eski and y not in band_yangi:
                    idlar[y] = oldingi_id[e]
                    band_eski.add(e)
                    band_yangi.add(y)
        for j in range(len(d)):
            if idlar[j] == -1:                                                # ulanmadi -> yangi trek
                oxirgi_id += 1
                idlar[j] = oxirgi_id
        natija += [(k, idlar[j], *d[j, :4]) for j in range(len(d))]
        oldingi, oldingi_id = d, idlar
    return np.array(natija), oxirgi_id

trek, soni = oddiy_tracker(det[1280])
print(f"tracker ochgan ID lar: {soni} | videodagi haqiqiy piyodalar: {len(np.unique(piyoda[:, 1]))}")

def id_tahlili(trek, piyoda):
    """Har GT odamga berilgan ID lar, ID almashishlari soni va topilgan GT box lar soni."""
    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)):                                  # 1) oldingi juftlik hali to'g'ri bo'lsa, saqlaymiz
            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]):   # 2) qolganlari IoU bo'yicha
            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

idlar, almashish, topildi = id_tahlili(trek, piyoda)
har_biriga = [len({p for _, p in v}) for v in idlar.values()]
print(f"GT box lardan topilgani: {topildi} / {len(piyoda)} ({topildi / len(piyoda) * 100:.0f}%)")
print(f"ID almashishlari: {almashish}")
print(f"bitta haqiqiy odamga berilgan ID lar: o'rtacha {np.mean(har_biriga):.1f}, eng ko'pi {max(har_biriga)}")

_, ax = plt.subplots(figsize=(11, 6))
for qator, gid in enumerate(sorted(idlar)):
    k, p = np.array(idlar[gid]).T
    ax.scatter(k, np.full(len(k), qator), c=plt.cm.tab20(p % 20), s=6, marker="s")
ax.set_yticks(range(len(idlar)))
ax.set_yticklabels([f"GT {g}" for g in sorted(idlar)], fontsize=7)
ax.set_xlabel("kadr")
ax.set_xlim(0, 526)
fig("oddiy_idlar.png", "Har qator — bitta haqiqiy odam. Rang — oddiy tracker bergan ID. Bo'shliq — odam topilmagan kadrlar.")