Ishlatish va eksport: tezlik qayerdan keladi

import os
import time
import urllib.request
from pathlib import Path

import cv2
import numpy as np
import pandas as pd
import torch
import torchvision
import onnxruntime as ort
from ultralytics import YOLO
from ultralytics.data.augment import LetterBox
from ultralytics.engine.exporter import export_formats
from ultralytics.utils import ASSETS, LOGGER
from ultralytics.utils.metrics import ap_per_class

LOGGER.setLevel("ERROR")

model = YOLO("weights/yolo11n.pt")
kadr = cv2.imread(str(ASSETS / "bus.jpg"))                           # kameradan kelgan kadr ham xuddi shunday BGR massiv
r1 = model.predict(kadr, verbose=False)[0]
r2 = model.predict([ASSETS / "bus.jpg", ASSETS / "zidane.jpg"], verbose=False)
oqim = model.predict(ASSETS, stream=True, verbose=False)             # papka + stream=True: generator, xotirada bitta natija
print("numpy massivdan:", len(r1.boxes), "ta obyekt")
print("ro'yxatdan:     ", [len(r.boxes) for r in r2])
print("stream turi:    ", type(oqim).__name__, "->", [(Path(r.path).name, len(r.boxes)) for r in oqim])
print("\nbitta obyekt lug'at ko'rinishida:", r1.summary()[0])
odamlar = model.predict(ASSETS / "bus.jpg", classes=[0], verbose=False)[0]
print("classes=[0], faqat odamlar:", [odamlar.names[int(c)] for c in odamlar.boxes.cls])

rasmlar = [cv2.imread(str(p)) for p in sorted(Path("datasets/coco/images/val2017").iterdir())[:64]]
gpu = YOLO("weights/yolo11n.pt")
qatorlar = []
for b in (1, 8, 32):
    gpu.predict(rasmlar[:b], device=0, verbose=False)               # shu batch o'lchami uchun qizdirish
    tezlik = []
    torch.cuda.synchronize()
    t0 = time.perf_counter()
    for i in range(0, len(rasmlar), b):
        tezlik.append(gpu.predict(rasmlar[i:i + b], device=0, verbose=False)[0].speed)   # bosqichlar, bitta rasmga ms
    torch.cuda.synchronize()
    dt = time.perf_counter() - t0
    qatorlar.append({"batch": b, **{k: float(np.median([s[k] for s in tezlik])) for k in ("preprocess", "inference", "postprocess")},
                     "devor soati, ms/rasm": dt / len(rasmlar) * 1000, "rasm / sekund": len(rasmlar) / dt})
show(pd.DataFrame(qatorlar).round(2))

f = export_formats()
show(pd.DataFrame({k: f[k] for k in ("Format", "Argument", "Suffix", "CPU", "GPU")}), 20)

def eksport(pt, fayl, **sozlama):
    """Fayl yo'q bo'lsa eksport qiladi va kerakli nomga ko'chiradi (TensorRT bir necha daqiqa oladi)."""
    fayl = Path(fayl)
    if not fayl.exists():
        Path(YOLO(pt).export(**sozlama)).rename(fayl)
        if sozlama["format"] == "engine":
            Path(pt).with_suffix(".onnx").unlink(missing_ok=True)   # TensorRT oraliq ONNX faylini qoldiradi
    return str(fayl)

onnx_fayl = {n: eksport(f"weights/{n}.pt", f"weights/{n}_640.onnx", format="onnx", imgsz=640) for n in ("yolo11n", "yolo26n")}
for n, fayl in onnx_fayl.items():
    s = ort.InferenceSession(fayl, providers=["CPUExecutionProvider"])
    print(f"{n}: {Path(fayl).stat().st_size / 1e6:.1f} MB | kirish '{s.get_inputs()[0].name}' {s.get_inputs()[0].shape}"
          f" | chiqish {s.get_outputs()[0].shape}")

lb = LetterBox((640, 640), auto=False)(image=kadr)                  # qat'iy 640x640: to'liq kvadratgacha to'ldiramiz
x = (lb[:, :, ::-1].transpose(2, 0, 1)[None] / 255).astype(np.float32).copy()   # BGR->RGB, HWC->NCHW, 0..1
sessiya = ort.InferenceSession(onnx_fayl["yolo11n"], providers=["CPUExecutionProvider"])
y_onnx = sessiya.run(None, {"images": x})[0]
with torch.no_grad():
    y_torch = YOLO("weights/yolo11n.pt").model.eval()(torch.from_numpy(x))[0].numpy()
print("ONNX chiqishi:", y_onnx.shape, "| PyTorch bilan eng katta farq:", float(np.abs(y_onnx - y_torch).max()))

def mediana_ms(f, n=50):
    """f() ni 5 marta qizdirib, n marta o'lchaydi: mediana, ms."""
    for _ in range(5):
        f()
    vaqtlar = []
    for _ in range(n):
        t0 = time.perf_counter()
        f()
        vaqtlar.append(time.perf_counter() - t0)
    return float(np.median(vaqtlar) * 1000)

qatorlar = []
for n, fayl in onnx_fayl.items():
    s = ort.InferenceSession(fayl, providers=["CPUExecutionProvider"])
    net = YOLO(f"weights/{n}.pt").model.eval()
    xt = torch.from_numpy(x)
    with torch.no_grad():
        t_torch = mediana_ms(lambda: net(xt))
    qatorlar.append({"model": n, "PyTorch CPU, ms": t_torch, "ONNX Runtime CPU, ms": mediana_ms(lambda: s.run(None, {"images": x}))})
cpu_jadval = pd.DataFrame(qatorlar)
show(cpu_jadval.round(2))
t11, t26 = cpu_jadval["ONNX Runtime CPU, ms"]
print(f"ONNX Runtime da YOLO26n YOLO11n dan {(1 - t26 / t11) * 100:.0f}% tez | protsessor iplari (WSL): {os.cpu_count()}")

trt_kvadrat = eksport("weights/yolo11n.pt", "weights/yolo11n_640x640.engine", format="engine", imgsz=640, half=True, device=0)
trt_rect = eksport("weights/yolo11n.pt", "weights/yolo11n_640x480.engine", format="engine", imgsz=(640, 480), half=True, device=0)

variantlar = {"PyTorch FP32, 640x480 (rect)": (YOLO("weights/yolo11n.pt"), {}),
              "PyTorch FP32, 640x640":        (YOLO("weights/yolo11n.pt"), {"rect": False}),
              "PyTorch FP16, 640x640":        (YOLO("weights/yolo11n.pt"), {"rect": False, "half": True}),
              "TensorRT FP16, 640x640":       (YOLO(trt_kvadrat), {}),
              "TensorRT FP16, 640x480":       (YOLO(trt_rect), {})}
qatorlar = []
for nom, (m, sozlama) in variantlar.items():
    for _ in range(5):
        m.predict(kadr, device=0, verbose=False, **sozlama)
    natijalar = [m.predict(kadr, device=0, verbose=False, **sozlama)[0] for _ in range(50)]
    qatorlar.append({"variant": nom,
                     **{k: round(float(np.median([r.speed[k] for r in natijalar])), 2) for k in ("preprocess", "inference", "postprocess")},
                     "ishonchlar": " ".join(f"{c:.2f}" for c in natijalar[-1].boxes.conf.tolist())})
show(pd.DataFrame(qatorlar))

ppe = "out/train/ppe_coco/weights/best.pt"
ppe_onnx = eksport(ppe, "out/train/ppe_coco/weights/best_640.onnx", format="onnx", imgsz=640)
ppe_trt = eksport(ppe, "out/train/ppe_coco/weights/best_640x640.engine", format="engine", imgsz=640, half=True, device=0)

sinovlar = {"PyTorch FP32 (rect, standart)": (ppe, {}),
            "PyTorch FP32 (640x640)":        (ppe, {"rect": False, "batch": 1}),
            "ONNX FP32 (640x640)":           (ppe_onnx, {}),
            "TensorRT FP16 (640x640)":       (ppe_trt, {})}
qatorlar = []
for nom, (fayl, sozlama) in sinovlar.items():
    m = YOLO(fayl, task="detect").val(data="datasets/ppe.yaml", split="test", imgsz=640, device=0, plots=False,
                                      project=Path("out/val").resolve(), name="eksport", exist_ok=True, **sozlama)
    qatorlar.append({"model": nom, "mAP50": m.box.map50, "mAP50-95": m.box.map})
show(pd.DataFrame(qatorlar).round(4))

import mediapipe as mp
from mediapipe.tasks import python as mpt
from mediapipe.tasks.python import vision

mp_fayl = Path("weights/efficientdet_lite0.tflite")
if not mp_fayl.exists():
    urllib.request.urlretrieve("https://storage.googleapis.com/mediapipe-models/object_detector/"
                               "efficientdet_lite0/float32/latest/efficientdet_lite0.tflite", mp_fayl)
iou_chegaralar = np.linspace(0.5, 0.95, 10)
sinf_raqami = {v: k for k, v in model.names.items()}              # "person" -> 0

def tp_matritsa(p_box, p_sinf, g_box, g_sinf):
    """(bashoratlar, 10): har IoU chegarasida TP mi. 7-bobdagi moslash qoidasi."""
    tp = np.zeros((len(p_box), 10), bool)
    if len(p_box) == 0 or len(g_box) == 0:
        return tp
    iou = torchvision.ops.box_iou(torch.tensor(g_box, dtype=torch.float32), torch.tensor(p_box, dtype=torch.float32)).numpy()
    iou *= g_sinf[:, None] == p_sinf[None]                            # faqat sinfi mos juftliklar
    for j, chegara in enumerate(iou_chegaralar):
        juft = np.array(np.nonzero(iou >= chegara)).T
        if len(juft):
            juft = juft[iou[juft[:, 0], juft[:, 1]].argsort()[::-1]]
            juft = juft[np.unique(juft[:, 1], return_index=True)[1]]
            juft = juft[np.unique(juft[:, 0], return_index=True)[1]]
            tp[juft[:, 1], j] = True
    return tp

def baholash(bashorat, rasm_yollari):
    """bashorat(BGR rasm) -> (xyxy, ishonch, sinf). Qaytaradi: mAP50, mAP50-95, bitta rasmga o'rtacha ms."""
    tp, ishonch, sinf, gt_sinf, vaqt = [], [], [], [], []
    for yol in rasm_yollari:
        rasm = cv2.imread(str(yol))
        H, W = rasm.shape[:2]
        lf = Path("datasets/coco/labels/val2017") / f"{yol.stem}.txt"
        lab = np.loadtxt(lf, ndmin=2).reshape(-1, 5) if lf.exists() else np.zeros((0, 5))
        g_box = np.stack([(lab[:, 1] - lab[:, 3] / 2) * W, (lab[:, 2] - lab[:, 4] / 2) * H,
                          (lab[:, 1] + lab[:, 3] / 2) * W, (lab[:, 2] + lab[:, 4] / 2) * H], 1)
        t0 = time.perf_counter()
        p_box, p_ish, p_sinf = bashorat(rasm)
        vaqt.append(time.perf_counter() - t0)
        tp.append(tp_matritsa(p_box, p_sinf, g_box, lab[:, 0]))
        ishonch.append(p_ish)
        sinf.append(p_sinf)
        gt_sinf.append(lab[:, 0])
    ap = ap_per_class(np.concatenate(tp), np.concatenate(ishonch), np.concatenate(sinf), np.concatenate(gt_sinf))[5]
    return ap[:, 0].mean(), ap.mean(), float(np.mean(vaqt) * 1000)

def yolo_bashorat(m, imgsz):
    def f(rasm):
        b = m.predict(rasm, conf=0.001, iou=0.7, max_det=300, imgsz=imgsz, device="cpu", verbose=False)[0].boxes
        return b.xyxy.numpy(), b.conf.numpy(), b.cls.numpy()
    return f

def mp_bashorat(detektor):
    def f(rasm):
        d = detektor.detect(mp.Image(image_format=mp.ImageFormat.SRGB, data=rasm[:, :, ::-1].copy())).detections
        box = np.array([[q.bounding_box.origin_x, q.bounding_box.origin_y, q.bounding_box.origin_x + q.bounding_box.width,
                         q.bounding_box.origin_y + q.bounding_box.height] for q in d]).reshape(-1, 4)
        return box, np.array([q.categories[0].score for q in d]), np.array([sinf_raqami[q.categories[0].category_name] for q in d])
    return f

tanlov = sorted(Path("datasets/coco/images/val2017").iterdir())[:500]
sozlama = vision.ObjectDetectorOptions(base_options=mpt.BaseOptions(model_asset_path=str(mp_fayl)), score_threshold=0.0, max_results=100)
qatorlar = []
with vision.ObjectDetector.create_from_options(sozlama) as detektor:
    for nom, fn, hajm in [("YOLO11n, 640", yolo_bashorat(model, 640), "weights/yolo11n.pt"),
                          ("YOLO11n, 320", yolo_bashorat(model, 320), "weights/yolo11n.pt"),
                          ("MediaPipe EfficientDet-Lite0, 320", mp_bashorat(detektor), mp_fayl)]:
        map50, map5095, ms = baholash(fn, tanlov)
        qatorlar.append({"model": nom, "mAP50": map50, "mAP50-95": map5095, "CPU, ms/rasm": ms,
                         "fayl, MB": Path(hajm).stat().st_size / 1e6})
show(pd.DataFrame(qatorlar).round(3))