Detect boshi: 6 300 katakdan 5 ta box gacha

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 ASSETS, LOGGER
from ultralytics.data.augment import LetterBox

LOGGER.setLevel("ERROR")

asl = cv2.imread(str(ASSETS / "bus.jpg"))                        # (1080, 810, 3), BGR
h0, w0 = asl.shape[:2]
lb = LetterBox((640, 640), auto=True, stride=32)(image=asl)      # predict() ishlatadigan aynan shu klass
gain = min(640 / h0, 640 / w0)
print("asl:", (h0, w0), "| letterbox:", lb.shape[:2], "| kichraytirish koeffitsiyenti:", round(gain, 4))
print("810 x gain =", w0 * gain, "-> 32 ga karrali, to'ldirish kerak emas")

x = torch.from_numpy(lb[:, :, ::-1].copy()).permute(2, 0, 1)[None].float() / 255   # BGR -> RGB, NCHW, 0..1
tarmoq = YOLO("weights/yolo11n.pt").model.eval()                 # fuse qilinmagan nusxa: boshning ichi ko'rinadi
with torch.no_grad():
    y, ichki = tarmoq(x)                                         # y: tayyor chiqish, ichki: boshning xom qismlari
print("\ny (dekodlangan):", tuple(y.shape))
print("boxes (xom):    ", tuple(ichki["boxes"].shape))
print("scores (xom):   ", tuple(ichki["scores"].shape))
print("xaritalar:      ", [tuple(f.shape) for f in ichki["feats"]])

bosh = tarmoq.model[-1]
for nom, tarmoqcha in [("cv2 (box)", bosh.cv2[0]), ("cv3 (sinf)", bosh.cv3[0])]:
    print(f"{nom:11s}: {sum(p.numel() for p in tarmoqcha.parameters()):6,} parametr, oxirgi qatlam: {tarmoqcha[-1]}")
print("reg_max:", bosh.reg_max, "| qadamlar:", bosh.stride.tolist())

anchorlar, qadamlar = [], []
for f, s in zip(ichki["feats"], bosh.stride.tolist()):
    H, W = f.shape[2:]
    yy, xx = torch.meshgrid(torch.arange(H) + 0.5, torch.arange(W) + 0.5, indexing="ij")
    anchorlar.append(torch.stack([xx.flatten(), yy.flatten()]))    # (2, H*W), katak birliklarida
    qadamlar.append(torch.full((H * W,), s))
A = torch.cat(anchorlar, 1)                                      # (2, 6300)
S = torch.cat(qadamlar)                                          # (6300,)
print("anchorlar:", tuple(A.shape), "| birinchi uchtasi (katak):", A[:, :3].T.tolist())
print("pikselda:", (A[:, :3] * S[:3]).T.tolist())
print("P3 / P4 / P5 oralig'i:", "0–4799 / 4800–5999 / 6000–6299")

print("DFL konvolyutsiyasi vaznlari:", bosh.dfl.conv.weight.flatten().tolist())
print("o'qitiladimi:", bosh.dfl.conv.weight.requires_grad)

z = ichki["boxes"][0].view(4, 16, -1)                            # (4 tomon, 16 bin, 6300 katak)
p = z.softmax(1)                                                 # har tomon bo'yicha ehtimollar
d = (p * torch.arange(16).view(1, 16, 1)).sum(1)                 # kutilgan qiymat: (4, 6300), katak birliklarida
print("\nqo'lda d vs bosh.dfl, eng katta farq:", float((d - bosh.dfl(ichki["boxes"])[0]).abs().max()))

for nom, s in zip(["P3", "P4", "P5"], bosh.stride.tolist()):
    print(f"{nom}: qadam {s:4.0f} px -> markazdan chegaragacha ko'pi bilan 15 x {s:.0f} = {15 * s:5.0f} px, box ko'pi bilan ~{30 * s:.0f} px")

x1, y1 = (A[0] - d[0]) * S, (A[1] - d[1]) * S
x2, y2 = (A[0] + d[2]) * S, (A[1] + d[3]) * S
xyxy = torch.stack([x1, y1, x2, y2], 1)                          # (6300, 4), letterbox pikselida
ehtimol = ichki["scores"][0].sigmoid()                           # (80, 6300)
bizniki = torch.cat([torch.stack([(x1 + x2) / 2, (y1 + y2) / 2, x2 - x1, y2 - y1]), ehtimol])
print("bizniki:", tuple(bizniki.shape), "| tarmoqniki:", tuple(y[0].shape))
print("eng katta farq:", float((bizniki - y[0]).abs().max()))

ishonch, sinf = ehtimol.max(0)                                   # har katak: eng yuqori ehtimol va uning sinfi
nomzod = torch.nonzero(ishonch > 0.25).flatten()                 # katak raqamlari
print("0.25 dan yuqori kataklar:", len(nomzod), "ta, 6 300 dan")
print("to'rlar bo'yicha: P3", int((nomzod < 4800).sum()), "| P4", int(((nomzod >= 4800) & (nomzod < 6000)).sum()),
      "| P5", int((nomzod >= 6000).sum()))

def iou_bitta(box, boxlar):
    """Bitta box va boxlar ro'yxati orasidagi IoU (1-bobdagi formula, torch da)."""
    ix1 = torch.maximum(box[0], boxlar[:, 0]); iy1 = torch.maximum(box[1], boxlar[:, 1])
    ix2 = torch.minimum(box[2], boxlar[:, 2]); iy2 = torch.minimum(box[3], boxlar[:, 3])
    kesishma = (ix2 - ix1).clamp(0) * (iy2 - iy1).clamp(0)
    yuza = lambda b: (b[..., 2] - b[..., 0]) * (b[..., 3] - b[..., 1])
    return kesishma / (yuza(box) + yuza(boxlar) - kesishma)

def nms(boxlar, ballar, chegara):
    """Ochko'z NMS: qoldirilgan box larning indekslari, ishonch bo'yicha tartibda."""
    tartib = ballar.argsort(descending=True)
    qoldi = []
    while tartib.numel() > 0:
        eng_yaxshi = tartib[0]
        qoldi.append(int(eng_yaxshi))
        qolgan = tartib[1:]
        tartib = qolgan[iou_bitta(boxlar[eng_yaxshi], boxlar[qolgan]) <= chegara]   # takrorlarni o'chiramiz
    return torch.tensor(qoldi)

nb, ns, nc = xyxy[nomzod], ishonch[nomzod], sinf[nomzod]
siljigan = nb + nc[:, None].float() * 7680                       # sinflarni bir-biridan uzoqlashtirish
bizniki = nms(siljigan, ns, 0.7)
torchniki = torchvision.ops.nms(siljigan, ns, 0.7)
print("bizning NMS:     ", bizniki.tolist())
print("torchvision NMS: ", torchniki.tolist())

qatorlar = [{"IoU chegarasi": t, "qolgan box lar": len(nms(siljigan, ns, t))} for t in (0.3, 0.5, 0.7, 0.9, 1.0)]
show(pd.DataFrame(qatorlar))

px, py = (lb.shape[1] - w0 * gain) / 2, (lb.shape[0] - h0 * gain) / 2   # chap va yuqoridagi to'ldirish
yakuniy = (nb[bizniki] - torch.tensor([px, py, px, py])) / gain
yakuniy[:, [0, 2]] = yakuniy[:, [0, 2]].clamp(0, w0)             # rasm chegarasidan chiqmasin
yakuniy[:, [1, 3]] = yakuniy[:, [1, 3]].clamp(0, h0)

natija = YOLO("weights/yolo11n.pt").predict(ASSETS / "bus.jpg", device="cpu", verbose=False)[0]
print("bizniki:  ", [f"{natija.names[int(c)]} {s:.3f}" for c, s in zip(nc[bizniki], ns[bizniki])])
print("predict():", [f"{natija.names[int(c)]} {s:.3f}" for c, s in zip(natija.boxes.cls, natija.boxes.conf)])
print("box lar orasidagi eng katta farq, px:", float((yakuniy - natija.boxes.xyxy).abs().max()))
toplar = ["P3" if i < 4800 else "P4" if i < 6000 else "P5" for i in nomzod[bizniki].tolist()]
print("har yakuniy box qaysi to'rdan:", toplar)

def asl_rasmga(b):
    return ((b - torch.tensor([px, py, px, py])) / gain).tolist()

_, axes = plt.subplots(1, 2, figsize=(10, 6.8))
for ax, (sarlavha, boxlar) in zip(axes, [(f"NMS dan oldin: {len(nomzod)} ta", nb), (f"NMS dan keyin: {len(bizniki)} ta", nb[bizniki])]):
    ax.imshow(asl[:, :, ::-1])
    for bx1, by1, bx2, by2 in asl_rasmga(boxlar):
        ax.add_patch(plt.Rectangle((bx1, by1), bx2 - bx1, by2 - by1, fill=False, color="yellow", lw=1.2))
    ax.set_title(sarlavha)
    ax.axis("off")
fig("nms_oldin_keyin.png", "Chapda 0.25 dan yuqori hamma nomzod: har obyekt atrofida bir nechta box. O'ngda NMS qoldirgan 5 tasi.")

tanlangan = {"aniq odam (0.89)": int(nomzod[bizniki][1]), "yarim ko'ringan odam (0.62)": int(nomzod[bizniki][4])}
tomonlar = ["chap (l)", "yuqori (t)", "o'ng (r)", "past (b)"]
_, axes = plt.subplots(2, 4, figsize=(11, 4.6), sharey=True)
qatorlar = []
for qator, (nom, k) in zip(axes, tanlangan.items()):
    for j, ax in enumerate(qator):
        pj = p[j, :, k].numpy()
        ax.bar(range(16), pj, color="#2563eb")
        ax.set_title(f"{tomonlar[j]}", fontsize=9)
        ax.set_xticks([0, 5, 10, 15])
        orta = float((pj * np.arange(16)).sum())
        qatorlar.append({"box": nom, "tomon": tomonlar[j], "kutilgan d, katak": round(orta, 2),
                         "standart og'ish": round(float(np.sqrt((pj * (np.arange(16) - orta) ** 2).sum())), 2),
                         "eng katta p": round(float(pj.max()), 2)})
    qator[0].set_ylabel(nom, fontsize=9)
fig("dfl.png", "Har tomon uchun 16 ta ehtimol. Tor cho'qqi — model chegara joyiga ishonadi; keng — ishonmaydi.")
show(pd.DataFrame(qatorlar), 8)

tarmoq26 = YOLO("weights/yolo26n.pt").model.eval()
with torch.no_grad():
    y26, ichki26 = tarmoq26(x)                                   # o'sha letterbox rasm
print("tayyor chiqish:", tuple(y26.shape), "-> 300 ta qator: x1, y1, x2, y2, ishonch, sinf")
qatorlar = []
for nom in ("one2many", "one2one"):
    eh = ichki26[nom]["scores"][0].sigmoid().max(0).values
    qatorlar.append({"bosh": nom, "box kanallari": ichki26[nom]["boxes"].shape[1],
                     "ishonch > 0.25": int((eh > 0.25).sum()), "> 0.1": int((eh > 0.1).sum()), "> 0.05": int((eh > 0.05).sum())})
show(pd.DataFrame(qatorlar))

top = y26[0][y26[0][:, 4] > 0.05]
print("one2one chiqishi, ishonch > 0.05:")
for r in top.tolist():
    print(f"  {tarmoq26.names[int(r[5])]:7s} {r[4]:.2f}   ({r[0]:6.1f}, {r[1]:6.1f}) -> ({r[2]:6.1f}, {r[3]:6.1f})")
kuchli = top[top[:, 4] > 0.25]
print("0.25 dan yuqorilarga NMS qo'llasak, nechtasi qoladi:",
      len(torchvision.ops.nms(kuchli[:, :4] + kuchli[:, 5:6] * 7680, kuchli[:, 4], 0.7)), "/", len(kuchli))