Apparat: bitta kompyuter nechta kamerani ko'taradi

import json
import re
import subprocess
import sys
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 scipy.optimize import linear_sum_assignment
from ultralytics import YOLO
from ultralytics.utils import LOGGER

LOGGER.setLevel("ERROR")
MANBA = "datasets/MOT17/train/MOT17-09-FRCNN/img1/%06d.jpg"
OUT = Path("out/apparat")
OUT.mkdir(parents=True, exist_ok=True)
KLIPLAR = {"1080p_h264_30fps": ("1920:1080", 30, ["-c:v", "libx264", "-b:v", "4000k", "-maxrate", "4000k", "-bufsize", "8000k"]),
           "1080p_h265_30fps": ("1920:1080", 30, ["-c:v", "libx265", "-b:v", "2000k", "-maxrate", "2000k", "-bufsize", "4000k",
                                                  "-x265-params", "log-level=error"]),
           "360p_h264_30fps": ("640:360", 30, ["-c:v", "libx264", "-b:v", "512k", "-maxrate", "512k", "-bufsize", "1024k"]),
           "1080p_h264_15fps": ("1920:1080", 15, ["-c:v", "libx264", "-b:v", "4000k", "-maxrate", "4000k", "-bufsize", "8000k"]),
           "360p_h264_15fps": ("640:360", 15, ["-c:v", "libx264", "-b:v", "512k", "-maxrate", "512k", "-bufsize", "1024k"])}
klip = {}
for nom, (olcham, fps, kod) in KLIPLAR.items():
    klip[nom] = OUT / f"MOT17-09_{nom}.mp4"
    if not klip[nom].exists():
        filtr = f"select=not(mod(n\\,2)),setpts=N/15/TB,scale={olcham}" if fps == 15 else f"scale={olcham}"
        subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-framerate", "30", "-i", MANBA, "-vf", filtr, "-r", str(fps), *kod,
                        "-g", str(2 * fps), "-pix_fmt", "yuv420p", str(klip[nom])], check=True)
show(pd.DataFrame([{"klip": n, "fayl, KB": f.stat().st_size // 1024} for n, f in klip.items()]))

def ffmpeg_dekod(fayl, dekoder=None, iplar=None, takror=4):
    buyruq = ["ffmpeg", "-hide_banner", "-benchmark", *(["-threads", str(iplar)] if iplar else []), *(["-c:v", dekoder] if dekoder else []),
              "-stream_loop", str(takror - 1), "-i", str(fayl), "-f", "null", "-"]
    r = subprocess.run(buyruq, capture_output=True, text=True, check=True)
    kadr = int(re.findall(r"frame=\s*(\d+)", r.stderr)[-1])
    cpu_vaqt, soat = map(float, re.search(r"utime=([\d.]+)s.*rtime=([\d.]+)s", r.stderr).groups())
    return kadr / soat, cpu_vaqt / soat

qatorlar = []
for nom in ("1080p_h264_30fps", "1080p_h265_30fps", "360p_h264_30fps"):
    kodek = "hevc" if "h265" in nom else "h264"
    for usul, dekoder, iplar in (("CPU, 1 ip", None, 1), ("CPU, hamma ip", None, None), ("GPU, NVDEC", f"{kodek}_cuvid", None)):
        kadr_s, yadro = ffmpeg_dekod(klip[nom], dekoder, iplar)
        qatorlar.append({"video": nom, "usul": usul, "kadr/s": kadr_s, "CPU yadro": yadro, "1 yadroga kadr/s": kadr_s / yadro})
show(pd.DataFrame(qatorlar).round(2))

def pythonga(fayl, usul, takror=4):
    t0, n = time.perf_counter(), 0
    if usul == "OpenCV (CPU)":
        for _ in range(takror):
            cap = cv2.VideoCapture(str(fayl))
            while cap.read()[0]:
                n += 1
        return n / (time.perf_counter() - t0)
    w, h, qoshimcha = (1920, 1080, []) if usul == "NVDEC, 1080p" else (640, 360, ["-resize", "640x360"])
    p = subprocess.Popen(["ffmpeg", "-loglevel", "error", "-c:v", "h264_cuvid", *qoshimcha, "-stream_loop", str(takror - 1), "-i", str(fayl),
                          "-f", "rawvideo", "-pix_fmt", "bgr24", "-"], stdout=subprocess.PIPE, bufsize=w * h * 3 * 4)
    while len(p.stdout.read(w * h * 3)) == w * h * 3:                      # har kadr: w*h*3 bayt BGR
        n += 1
    p.wait()
    return n / (time.perf_counter() - t0)

show(pd.DataFrame([{"Python ga kadr olish": u, "kadr/s": pythonga(klip["1080p_h264_30fps"], u)}
                   for u in ("OpenCV (CPU)", "NVDEC, 1080p", "NVDEC, 640x360 ga kichraytirib")]).round(0))

dvigatel = Path("weights/yolo11n_384x640_b16.engine")
if not dvigatel.exists():
    Path(YOLO("weights/yolo11n.pt").export(format="engine", imgsz=(384, 640), half=True, dynamic=True, batch=16, device=0)).rename(dvigatel)
    Path("weights/yolo11n.onnx").unlink(missing_ok=True)                  # eksportning oraliq fayli
kadrlar = [cv2.imread(str(p)) for p in sorted(Path("datasets/MOT17/train/MOT17-09-FRCNN/img1").iterdir())[:64]]

def ms_kadr(model, batch, **kw):
    for _ in range(3):
        model.predict(kadrlar[:batch], verbose=False, **kw)              # qizdirish
    n, t0 = 0, time.perf_counter()
    while time.perf_counter() - t0 < 4:
        for i in range(0, 64, batch):
            model.predict(kadrlar[i:i + batch], verbose=False, **kw)
            n += batch
    return (time.perf_counter() - t0) / n * 1000

pt, trt = YOLO("weights/yolo11n.pt"), YOLO(str(dvigatel), task="detect")
pt_cpu = YOLO("weights/yolo11n.pt")                                       # alohida nusxa: model birinchi chaqiruvdagi qurilmada qoladi
sinovlar = [("PyTorch FP16, GPU", pt, 640, b, dict(half=True, device=0)) for b in (1, 8)] + \
           [("PyTorch FP16, GPU", pt, 1280, b, dict(half=True, device=0)) for b in (1, 8)] + \
           [("TensorRT FP16, GPU", trt, (384, 640), b, dict(device=0)) for b in (1, 8, 16)] + \
           [("PyTorch, faqat CPU", pt_cpu, 640, 1, dict(device="cpu"))]
qatorlar = []
for nom, model, imgsz, batch, kw in sinovlar:
    ms = ms_kadr(model, batch, imgsz=imgsz, classes=[0], **kw)
    qatorlar.append({"rejim": nom, "imgsz": str(imgsz), "batch": batch, "ms/kadr": ms, "kadr/s": 1000 / ms})
model_jadval = pd.DataFrame(qatorlar)
show(model_jadval.round(2))

gt = np.loadtxt("datasets/MOT17/train/MOT17-09-FRCNN/gt/gt.txt", delimiter=",")
gt = gt[gt[:, 7] == 1]
yaxshi = (gt[:, 8] >= 0.8) & (gt[:, 2] >= 0) & (gt[:, 3] >= 0) & (gt[:, 2] + gt[:, 4] <= 1920) & (gt[:, 3] + gt[:, 5] <= 1080)

def recall(fayl):
    cap, k, tp, jami = cv2.VideoCapture(str(fayl)), 0, 0, 0
    while True:
        ok, rasm = cap.read()
        if not ok:
            return 100 * tp / jami
        k += 1
        s = 1920 / rasm.shape[1]                                          # 360p box larini 1080p koordinataga qaytaramiz
        D = pt.predict(rasm, imgsz=640, conf=0.25, classes=[0], device=0, verbose=False)[0].boxes.xyxy.cpu().numpy() * s
        m = gt[:, 0] == k
        G = np.c_[gt[m, 2:4], gt[m, 2:4] + gt[m, 4:6]]
        t = np.zeros(len(G), bool)
        if len(G) and len(D):
            M = torchvision.ops.box_iou(torch.tensor(G), torch.tensor(D, dtype=torch.float64)).numpy()
            r, c = linear_sum_assignment(-M)
            t[r[M[r, c] >= 0.5]] = True
        tp, jami = tp + t[yaxshi[m]].sum(), jami + yaxshi[m].sum()

show(pd.DataFrame([{"oqim (imgsz 640)": n, "recall, %": recall(klip[n])} for n in ("1080p_h264_30fps", "360p_h264_30fps")]).round(1))

# Bitta ishchi jarayon: N ta soxta kamera (real vaqtda 15 kadr/s), YOLO11n va har kameraga ByteTrack.
# Natija — bitta JSON qator. Misol: python kod/18_kamera_ishchisi.py --usul sub --kameralar 32
import argparse
import json
import os
import subprocess
import threading
import time

import numpy as np
import cv2
import psutil
from ultralytics import YOLO
from ultralytics.trackers import BYTETracker
from ultralytics.utils import LOGGER, YAML, IterableSimpleNamespace
from ultralytics.utils.checks import check_yaml

LOGGER.setLevel("ERROR")
FPS = 15
KLIP = {"cpu": "out/apparat/MOT17-09_1080p_h264_15fps.mp4",              # asosiy oqim, OpenCV dekodlaydi
        "gpu": "out/apparat/MOT17-09_1080p_h264_15fps.mp4",              # asosiy oqim, NVDEC dekodlaydi va 640x360 ga kichraytiradi
        "sub": "out/apparat/MOT17-09_360p_h264_15fps.mp4"}               # ikkinchi oqim, OpenCV dekodlaydi


class Kamera(threading.Thread):
    """Real vaqtda kadr beradigan soxta kamera. Faqat oxirgi kadr saqlanadi: olinmay almashtirilgani — tashlangan kadr."""
    def __init__(self, usul):
        super().__init__(daemon=True)
        self.usul, self.kadr, self.berildi, self.olindi, self.ish = usul, None, 0, 0, True
        self.qulf = threading.Lock()

    def run(self):
        if self.usul == "gpu":
            p = subprocess.Popen(["ffmpeg", "-loglevel", "error", "-re", "-c:v", "h264_cuvid", "-resize", "640x360", "-stream_loop", "-1",
                                  "-i", KLIP["gpu"], "-f", "rawvideo", "-pix_fmt", "bgr24", "-"], stdout=subprocess.PIPE)
            while self.ish:                                              # -re: ffmpeg o'zi real vaqtda beradi
                b = p.stdout.read(640 * 360 * 3)
                if len(b) < 640 * 360 * 3:
                    break
                self.qoy(np.frombuffer(b, np.uint8).reshape(360, 640, 3))
            p.kill()
            return
        cap, keyingi = cv2.VideoCapture(KLIP[self.usul]), time.perf_counter()
        while self.ish:
            ok, rasm = cap.read()
            if not ok:                                                   # video tugadi — boshidan
                cap = cv2.VideoCapture(KLIP[self.usul])
                continue
            keyingi += 1 / FPS
            time.sleep(max(0.0, keyingi - time.perf_counter()))
            self.qoy(rasm)

    def qoy(self, rasm):
        with self.qulf:
            self.kadr, self.berildi = rasm, self.berildi + 1

    def ol(self):
        with self.qulf:
            rasm, self.kadr = self.kadr, None
        self.olindi += rasm is not None
        return rasm


def main():
    p = argparse.ArgumentParser()
    p.add_argument("--usul", choices=list(KLIP), default="sub")
    p.add_argument("--kameralar", type=int, default=16)
    p.add_argument("--soniya", type=float, default=20)
    p.add_argument("--model", default="weights/yolo11n_384x640_b16.engine")
    p.add_argument("--qurilma", default="0")
    a = p.parse_args()

    model = YOLO(a.model, task="detect")
    qurilma = "cpu" if a.qurilma == "cpu" else int(a.qurilma)
    for b in range(1, 17):                                               # har batch o'lchami uchun qizdiramiz
        model.predict([np.zeros((360, 640, 3), np.uint8)] * b, imgsz=(384, 640), device=qurilma, verbose=False)
    bt = IterableSimpleNamespace(**YAML.load(check_yaml("bytetrack.yaml")))
    kameralar = [Kamera(a.usul) for _ in range(a.kameralar)]
    trackerlar = [BYTETracker(bt, frame_rate=FPS) for _ in kameralar]
    for k in kameralar:
        k.start()
    time.sleep(2)
    for k in kameralar:
        k.berildi = k.olindi = 0
    smi = subprocess.Popen(["nvidia-smi", "--query-gpu=utilization.gpu,utilization.decoder,memory.used",
                            "--format=csv,noheader,nounits", "-lms", "500"], stdout=subprocess.PIPE, text=True)
    psutil.cpu_percent(None)
    t0 = time.perf_counter()
    while time.perf_counter() - t0 < a.soniya:
        tayyor = [(i, r) for i, k in enumerate(kameralar) if (r := k.ol()) is not None]
        if not tayyor:
            time.sleep(0.001)
            continue
        for j in range(0, len(tayyor), 16):                              # dvigatel 16 tagacha batch qabul qiladi
            qism = tayyor[j:j + 16]
            natija = model.predict([r for _, r in qism], imgsz=(384, 640), device=qurilma, verbose=False, classes=[0])
            for (i, rasm), r in zip(qism, natija):
                trackerlar[i].update(r.boxes.cpu().numpy(), rasm)
    vaqt = time.perf_counter() - t0
    cpu = psutil.cpu_percent(None)
    smi.terminate()
    gpu = np.array([[float(x) for x in q.split(",")] for q in smi.stdout.read().split("\n") if q.strip()])
    for k in kameralar:
        k.ish = False
    for k in kameralar:
        k.join(timeout=2)                                                # ffmpeg jarayonlari ham yopiladi
    berildi = sum(k.berildi for k in kameralar) / vaqt / len(kameralar)
    ishlandi = sum(k.olindi for k in kameralar) / vaqt / len(kameralar)
    print(json.dumps({"berildi": berildi, "ishlandi": ishlandi, "tashlandi": 100 * (1 - ishlandi / berildi), "cpu": cpu,
                      "gpu": gpu[:, 0].mean(), "nvdec": gpu[:, 1].mean(), "gpu_xotira": gpu[:, 2].max(),
                      "ram": psutil.Process(os.getpid()).memory_info().rss / 2**20}))


if __name__ == "__main__":
    main()

def gpu_xotira():
    return float(subprocess.run(["nvidia-smi", "--query-gpu=memory.used", "--format=csv,noheader,nounits"],
                                capture_output=True, text=True).stdout)

def ishchilar(usul, kameralar, nusxa=1, **kw):
    """nusxa ta ishchi jarayonni parallel ishga tushiradi, har biri `kameralar` ta kamera bilan."""
    buyruq = [sys.executable, "kod/18_kamera_ishchisi.py", "--usul", usul, "--kameralar", str(kameralar),
              *[x for k, v in kw.items() for x in (f"--{k}", str(v))]]
    jarayonlar = [subprocess.Popen(buyruq, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True) for _ in range(nusxa)]
    return [json.loads(p.communicate()[0].strip().splitlines()[-1]) for p in jarayonlar]

asos = gpu_xotira()
print(f"sinovdan oldin GPU xotirasi band: {asos:.0f} MB (16 GB dan)")
NOMI = {"cpu": "1080p, OpenCV (CPU)", "gpu": "1080p, NVDEC + kichraytirish", "sub": "360p ikkinchi oqim, OpenCV"}
qatorlar = []
for usul in NOMI:
    for n in (1, 16, 32, 48, 64):
        r = ishchilar(usul, n)[0]
        qatorlar.append({"kirish": NOMI[usul], "kameralar": n, "kameraga ishlangan kadr/s": r["ishlandi"], "tashlandi, %": r["tashlandi"],
                         "CPU, %": r["cpu"], "GPU, %": r["gpu"], "NVDEC, %": r["nvdec"], "GPU xotirasi, MB": r["gpu_xotira"]})
sigim = pd.DataFrame(qatorlar)
show(sigim.round(1))

_, ax = plt.subplots(figsize=(8, 4.5))
for usul, nom in NOMI.items():
    q = sigim[sigim["kirish"] == nom]
    ax.plot(q["kameralar"], q["kameraga ishlangan kadr/s"], marker="o", label=nom)
ax.axhline(15, color="gray", ls="--", lw=0.8)
ax.set_xlabel("kameralar soni (bitta jarayon)")
ax.set_ylabel("har kameraga ishlangan kadr/s")
ax.legend(fontsize=8)
fig("sigim.png", "Bitta Python jarayoni: kameralar ko'paygan sari har kameraga qancha kadr yetadi (kameralar sekundiga 15 kadr beradi).")

qatorlar = []
for nusxa in (1, 2, 3):
    natija = ishchilar("sub", 32, nusxa)
    qatorlar.append({"jarayonlar": nusxa, "jami kameralar": 32 * nusxa, "kameraga ishlangan kadr/s": np.mean([r["ishlandi"] for r in natija]),
                     "jami ishlangan kadr/s": sum(r["ishlandi"] for r in natija) * 32, "GPU, %": natija[0]["gpu"], "CPU, %": natija[0]["cpu"],
                     "GPU xotirasi, MB (jarayonga)": (max(r["gpu_xotira"] for r in natija) - asos) / nusxa,
                     "RAM, MB (jarayonga)": np.mean([r["ram"] for r in natija])})
show(pd.DataFrame(qatorlar).round(1))

show(pd.DataFrame([{"kameralar": n, **{k: v for k, v in ishchilar("sub", n, model="weights/yolo11n.pt", qurilma="cpu", soniya=15)[0].items()
                                          if k in ("ishlandi", "tashlandi", "cpu")}} for n in (1, 2, 4)]).round(1))