Loss va tayinlash: model qanday o'rganadi

import math
import cv2
import numpy as np
import pandas as pd
import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
from ultralytics import YOLO
from ultralytics.cfg import get_cfg
from ultralytics.data.augment import LetterBox
from ultralytics.utils import DEFAULT_CFG, LOGGER
from ultralytics.utils.loss import E2ELoss, v8DetectionLoss
from ultralytics.utils.tal import TaskAlignedAssigner

LOGGER.setLevel("ERROR")

nom = "000000031093"
asl = cv2.imread(f"datasets/coco/images/val2017/{nom}.jpg")
h0, w0 = asl.shape[:2]
label = np.loadtxt(f"datasets/coco/labels/val2017/{nom}.txt", ndmin=2)
print(open(f"datasets/coco/labels/val2017/{nom}.txt").read().strip())

lb = LetterBox((640, 640), auto=False)(image=asl)                  # o'qitishdagi kabi to'liq kvadrat 640x640
g = min(640 / h0, 640 / w0)
px, py = (640 - w0 * g) / 2, (640 - h0 * g) / 2
x = torch.from_numpy(lb[:, :, ::-1].copy()).permute(2, 0, 1)[None].float() / 255

# GT: normallashgan xywh (asl rasm) -> letterbox pikselidagi xyxy
xc, yc = label[:, 1] * w0 * g + px, label[:, 2] * h0 * g + py
bw, bh = label[:, 3] * w0 * g, label[:, 4] * h0 * g
gt_box = torch.tensor(np.stack([xc - bw / 2, yc - bh / 2, xc + bw / 2, yc + bh / 2], 1), dtype=torch.float32)
gt_sinf = torch.tensor(label[:, 0]).long()

model = YOLO("weights/yolo11n.pt")
nomlar = model.names
show(pd.DataFrame({"GT": range(len(gt_box)), "sinf": [nomlar[int(c)] for c in gt_sinf],
                   "kenglik, px": bw.round(), "balandlik, px": bh.round()}))

def bashorat(tarmoq):
    """Xom chiqish -> (sinf logit lari (8400, 80), DFL logit lari (8400, 64), box lar (8400, 4) xyxy piksel)."""
    with torch.no_grad():
        _, ichki = tarmoq(x)
    z = ichki["boxes"][0].T
    d = (z.view(-1, 4, 16).softmax(-1) * torch.arange(16)).sum(-1) * qadam[:, None]   # DFL -> piksel masofa
    return ichki["scores"][0].T, z, torch.cat([anc - d[:, :2], anc + d[:, 2:]], 1)

tarmoq = model.model.eval()
anc, qadam = [], []
for H, s in [(80, 8), (40, 16), (20, 32)]:                        # 640x640 kirish: uch to'r
    yy, xx = torch.meshgrid(torch.arange(H) + 0.5, torch.arange(H) + 0.5, indexing="ij")
    anc.append(torch.stack([xx.flatten(), yy.flatten()], 1) * s)  # katak markazlari, pikselda
    qadam.append(torch.full((H * H,), float(s)))
anc, qadam = torch.cat(anc), torch.cat(qadam)                    # (8400, 2), (8400,)

logit, z, p_box = bashorat(tarmoq)
ball = logit.sigmoid()
print("kataklar:", len(anc), "| sinf logit lari:", tuple(logit.shape), "| box lar:", tuple(p_box.shape))

def ciou(a, b, eps=1e-7):
    """Complete IoU. a, b: (..., 4) xyxy."""
    w1, h1 = a[..., 2] - a[..., 0], a[..., 3] - a[..., 1] + eps
    w2, h2 = b[..., 2] - b[..., 0], b[..., 3] - b[..., 1] + eps
    kesishma = (torch.minimum(a[..., 2], b[..., 2]) - torch.maximum(a[..., 0], b[..., 0])).clamp(0) * \
               (torch.minimum(a[..., 3], b[..., 3]) - torch.maximum(a[..., 1], b[..., 1])).clamp(0)
    iou = kesishma / (w1 * h1 + w2 * h2 - kesishma + eps)
    cw = torch.maximum(a[..., 2], b[..., 2]) - torch.minimum(a[..., 0], b[..., 0])    # o'rab turuvchi box
    ch = torch.maximum(a[..., 3], b[..., 3]) - torch.minimum(a[..., 1], b[..., 1])
    c2 = cw ** 2 + ch ** 2 + eps                                                      # uning diagonali kvadrati
    rho2 = ((b[..., 0] + b[..., 2] - a[..., 0] - a[..., 2]) ** 2 + (b[..., 1] + b[..., 3] - a[..., 1] - a[..., 3]) ** 2) / 4
    v = 4 / math.pi ** 2 * (torch.atan(w2 / h2) - torch.atan(w1 / h1)) ** 2
    alfa = v / (v - iou + 1 + eps)
    return iou - rho2 / c2 - alfa * v

def iou(a, b):
    """Oddiy IoU (1-bob)."""
    kesishma = (torch.minimum(a[2], b[2]) - torch.maximum(a[0], b[0])).clamp(0) * \
               (torch.minimum(a[3], b[3]) - torch.maximum(a[1], b[1])).clamp(0)
    yuza = lambda q: (q[2] - q[0]) * (q[3] - q[1])
    return kesishma / (yuza(a) + yuza(b) - kesishma)

gt = torch.tensor([100.0, 100, 200, 200])                          # 100x100 lik GT
holatlar = {"markazi bir xil, kattaroq": [79.29, 79.29, 220.71, 220.71],
            "o'ngga siljigan":            [133.33, 100, 233.33, 200],
            "yuzi bir xil, shakli yotiq": [75, 116.67, 225, 183.33],
            "umuman tegmaydi":           [300, 100, 400, 200]}
show(pd.DataFrame([{"holat": k, "IoU": round(float(iou(gt, torch.tensor(b))), 3),
                    "CIoU": round(float(ciou(gt, torch.tensor(b))), 3)} for k, b in holatlar.items()]))

show(pd.DataFrame([{"s (sinf ehtimoli)": s, "u (box mosligi)": u, "t = s^0.5 * u^6": round(s ** 0.5 * u ** 6, 4)}
                   for s, u in [(0.9, 0.5), (0.9, 0.7), (0.3, 0.9), (0.9, 0.9)]]))

def tal(ball, p_box, gt_sinf, gt_box, topk=10, alfa=0.5, beta=6.0):
    """Bitta rasm uchun TAL. Qaytaradi: musbat (M, N) 0/1, t (M, N), u (M, N), ichida (M, N)."""
    M, N = len(gt_box), len(anc)
    markaz, wh = (gt_box[:, :2] + gt_box[:, 2:]) / 2, gt_box[:, 2:] - gt_box[:, :2]
    wh = torch.where(wh < 8, torch.tensor(16.0), wh)                                  # juda qisqa tomon -> 16 px
    g = torch.cat([markaz - wh / 2, markaz + wh / 2], 1)
    ichida = torch.cat([anc[None] - g[:, None, :2], g[:, None, 2:] - anc[None]], -1).amin(-1) > 1e-9   # 1-qadam
    s = ball[:, gt_sinf].T * ichida                                                   # (M, N)
    u = torch.zeros(M, N)
    u[ichida] = ciou(gt_box[:, None].expand(M, N, 4)[ichida], p_box[None].expand(M, N, 4)[ichida]).clamp(0)
    t = s.pow(alfa) * u.pow(beta)                                                     # 2-qadam
    musbat = torch.zeros(M, N).scatter_(1, t.topk(topk, dim=1).indices, 1.0) * ichida   # 3-qadam
    nizo = musbat.sum(0) > 1                                                          # 4-qadam
    if nizo.any():
        eng_mos = torch.zeros(M, N).scatter_(0, u.argmax(0, keepdim=True), 1.0)
        musbat = torch.where(nizo[None], eng_mos, musbat)
    return musbat, t, u, ichida

musbat, t, u, ichida = tal(ball, p_box, gt_sinf, gt_box)
fg = musbat.sum(0) > 0                                               # javobgar kataklar
gt_idx = musbat.argmax(0)                                            # har katak qaysi GT ga javobgar

tayinlovchi = TaskAlignedAssigner(topk=10, num_classes=80, alpha=0.5, beta=6.0, stride=[8, 16, 32])
_, _, u_maqsad, u_fg, u_idx = tayinlovchi(ball[None], p_box[None], anc, gt_sinf.view(1, -1, 1),
                                          gt_box[None], torch.ones(1, len(gt_box), 1))
print("javobgar kataklar: bizda", int(fg.sum()), "| ultralytics da", int(u_fg.sum()))
print("farq qilgan kataklar:", int((fg != u_fg[0]).sum()),
      "| GT raqami farq qilganlar:", int((gt_idx[fg] != u_idx[0][fg]).sum()))

daraja = np.where(np.arange(8400) < 6400, "P3", np.where(np.arange(8400) < 8000, "P4", "P5"))
qatorlar = []
for k in range(len(gt_box)):
    tanlangan = daraja[torch.nonzero(musbat[k]).flatten().numpy()]
    qatorlar.append({"GT": k, "sinf": nomlar[int(gt_sinf[k])], "nomzodlar": int(ichida[k].sum()),
                     "javobgar": len(tanlangan), **{p: int((tanlangan == p).sum()) for p in ("P3", "P4", "P5")}})
show(pd.DataFrame(qatorlar))

ranglar = plt.cm.tab10(np.arange(len(gt_box)))
_, axes = plt.subplots(1, 2, figsize=(13, 6.5), gridspec_kw={"width_ratios": [1, 1]})
for ax, (xlim, ylim, kattalik) in zip(axes, [((0, 640), (640, 0), 2.5), ((460, 640), (230, 95), 9)]):
    ax.imshow(lb[:, :, ::-1])
    for k, (b, r) in enumerate(zip(gt_box.tolist(), ranglar)):
        ax.add_patch(plt.Rectangle(b[:2], b[2] - b[0], b[3] - b[1], fill=False, color=r, lw=2))
        idx = torch.nonzero(musbat[k]).flatten()
        ax.scatter(anc[idx, 0], anc[idx, 1], s=qadam[idx] * kattalik, color=r, edgecolor="black", zorder=3)
    ax.set_xlim(*xlim)
    ax.set_ylim(*ylim)
    ax.axis("off")
axes[1].set_title("o'ng-yuqori burchak, kattalashtirilgan")
fig("tayinlash.png", "Rangli ramka — GT, shu rangdagi nuqtalar — unga javobgar kataklar markazi. Katta nuqta — P5, o'rtachasi — P4, kichik — P3.")

t_mus = t * musbat
norm = (t_mus * (u * musbat).amax(1, keepdim=True) / (t_mus.amax(1, keepdim=True) + 1e-9)).amax(0)   # (8400,)
maqsad = torch.zeros(8400, 80)
maqsad[fg, gt_sinf[gt_idx[fg]]] = norm[fg]
print("ultralytics maqsadlari bilan eng katta farq:", float((maqsad - u_maqsad[0]).abs().max()))

k0 = torch.nonzero(musbat[0]).flatten()                              # katta odamning 10 ta katagi
show(pd.DataFrame({"katak": k0.numpy(), "s": ball[k0, gt_sinf[0]].numpy(), "u (CIoU)": u[0, k0].numpy(),
                   "t": t[0, k0].numpy(), "maqsad y": norm[k0].numpy()}).sort_values("t", ascending=False).round(3), 10)

def yoqotish(logit, z, p_box):
    """Qo'lda: TAL -> maqsadlar -> uchta loss, koeffitsiyentlar bilan."""
    musbat, t, u, _ = tal(logit.sigmoid(), p_box, gt_sinf, gt_box)
    fg, gt_idx = musbat.sum(0) > 0, musbat.argmax(0)
    t_mus = t * musbat
    norm = (t_mus * (u * musbat).amax(1, keepdim=True) / (t_mus.amax(1, keepdim=True) + 1e-9)).amax(0)
    maqsad = torch.zeros_like(logit)
    maqsad[fg, gt_sinf[gt_idx[fg]]] = norm[fg]
    T = max(float(maqsad.sum()), 1.0)
    L_cls = F.binary_cross_entropy_with_logits(logit, maqsad, reduction="sum") / T
    w, t_box = maqsad.sum(1)[fg], gt_box[gt_idx[fg]]
    L_box = ((1 - ciou(p_box[fg], t_box)) * w).sum() / T
    d_haq = (torch.cat([anc[fg] - t_box[:, :2], t_box[:, 2:] - anc[fg]], 1) / qadam[fg, None]).clamp(0, 14.99)
    i = d_haq.long()                                                 # chap bin
    log_p = F.log_softmax(z[fg].view(-1, 4, 16), -1)
    ce = -(log_p.gather(-1, i[..., None])[..., 0] * (i + 1 - d_haq) + log_p.gather(-1, (i + 1)[..., None])[..., 0] * (d_haq - i))
    L_dfl = (ce.mean(1) * w).sum() / T
    return [7.5 * float(L_box), 0.5 * float(L_cls), 1.5 * float(L_dfl)]

batch = {"batch_idx": torch.zeros(len(gt_box)), "cls": gt_sinf.float(),
         "bboxes": torch.tensor(np.stack([xc, yc, bw, bh], 1) / 640, dtype=torch.float32)}   # ultralytics formati

torch.manual_seed(0)                                                 # tasodifiy vaznlar har safar bir xil bo'lsin
qatorlar = []
for nom_, net in [("o'qitilgan", tarmoq), ("o'qitilmagan", YOLO("yolo11n.yaml").model.eval())]:
    net.args = get_cfg(DEFAULT_CFG)                                  # loss koeffitsiyentlari shu yerdan olinadi
    with torch.no_grad():
        _, ichki = net(x)
        ultra = v8DetectionLoss(net).get_assigned_targets_and_loss(ichki, batch)[2].tolist()
    biz = yoqotish(*bashorat(net))
    for tur, qiymat in [("biz", biz), ("ultralytics", ultra)]:
        qatorlar.append({"model": nom_, "hisob": tur, "7.5 x box": qiymat[0], "0.5 x cls": qiymat[1],
                         "1.5 x dfl": qiymat[2], "jami": sum(qiymat)})
show(pd.DataFrame(qatorlar).round(4))

tarmoq26 = YOLO("weights/yolo26n.pt").model.eval()
tarmoq26.args = get_cfg(DEFAULT_CFG)
with torch.no_grad():
    _, ichki26 = tarmoq26(x)
qatorlar = []
for bosh, topk, topk2 in [("one2many", 10, None), ("one2one", 7, 1)]:
    kriteriy = v8DetectionLoss(tarmoq26, tal_topk=topk, tal_topk2=topk2)
    with torch.no_grad():
        (fg26, idx26, *_), _, _ = kriteriy.get_assigned_targets_and_loss(ichki26[bosh], batch)
    qatorlar.append({"bosh": bosh, "topk": topk, "topk2": topk2 or topk,
                     **{f"GT {k}": int((idx26[0][fg26[0]] == k).sum()) for k in range(len(gt_box))},
                     "DFL ishlatiladimi": kriteriy.use_dfl})
show(pd.DataFrame(qatorlar))

e2e = E2ELoss(tarmoq26)
print("epoxalar soni:", tarmoq26.args.epochs)
for epoxa in [0, 1, 25, 50, 75, 99]:
    o2m = e2e.decay(epoxa)
    print(f"{epoxa:3d} ta epoxadan keyin: one2many og'irligi {o2m:.3f}, one2one og'irligi {1 - o2m:.3f}")