File size: 3,933 Bytes
5f0e48f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 | """Time per image of every deployment path, measured interleaved in one process: on the shared server the time per
run drifts between runs (one model: 5.6-11.1 ms), so each round times every path back to back and the report is the
median over rounds of each path minus the plain model in that round.
python bench_latency.py --base s2.pt --site lt_merged.pt --lora lt.pt --data br.yaml --device 0 [--batch 32] [--cpu]
--ref times one more plain model in the same rounds, e.g. the unpruned site model next to a pruned pair.
"""
import argparse
import copy
import statistics
import time
import torch
from deploy_route import BaseRouter, Router, fuse_all, run, stats
from gridkd import * # noqa: F401,F403
def main():
p = argparse.ArgumentParser()
p.add_argument("--base", required=True)
p.add_argument("--site", required=True, help="new site's merged model")
p.add_argument("--lora", required=True, help="new site's LoRA checkpoint: names the card layers")
p.add_argument("--data", required=True, help="any data.yaml: its val split only sizes the cards (timing does not depend on their values)")
p.add_argument("--rounds", type=int, default=15)
p.add_argument("--n", type=int, default=50)
p.add_argument("--device", default="0", help="GPU for the val that sizes the cards (and for timing without --cpu)")
p.add_argument("--batch", type=int, default=1)
p.add_argument("--cpu", action="store_true", help="time on the CPU in fp32 (threads: OMP_NUM_THREADS)")
p.add_argument("--ref", help="plain model to time alongside")
a = p.parse_args()
names = [n for n, x in load_plain(a.lora).model.named_modules() if isinstance(x, MultiLoRAConv)][:8]
sf = stats(load_plain(a.base), names, a.data, "val", a.device, 10)
fused_cards = [DiagGMM.fit(s, 4) for s in sf]
early_cards = fused_cards[:-1]
dev, dt = (torch.device("cpu"), torch.float) if a.cpu else (torch.device("cuda"), torch.half) # cuda: pinned by the val above
load = lambda w: fuse_all(load_plain(w).model).to(dev, dt).eval() # noqa: E731
m0, m1 = load(a.base), load(a.site)
early = Router((copy.deepcopy(m0), copy.deepcopy(m1)), names, [early_cards, early_cards], 0.0) # own copies: hooks stay apart
fused = BaseRouter((copy.deepcopy(m0), copy.deepcopy(m1)), names, [fused_cards, fused_cards], 0.0)
x = torch.rand(a.batch, 3, 640, 640, device=dev, dtype=dt)
sync = (lambda: None) if a.cpu else torch.cuda.synchronize
def kept(t):
fused.force = False
return fused(t)
def sent(t):
fused.force = True
return fused(t)
paths = {"one model": lambda t: run(m1, t, [], 0, len(m1.model)), "early-layer cards": early, "fused, kept on old site": kept,
"fused, sent to new site": sent, "both models in full": lambda t: (run(m0, t, [], 0, len(m0.model)), run(m1, t, [], 0, len(m1.model)))}
if a.ref:
r = load(a.ref)
paths["reference model"] = lambda t: run(r, t, [], 0, len(r.model))
ms = {k: [] for k in paths}
with torch.no_grad():
for f in paths.values(): # warm-up
for _ in range(20):
f(x)
for _ in range(a.rounds):
for k, f in paths.items():
sync()
t0 = time.perf_counter()
for _ in range(a.n):
f(x)
sync()
ms[k].append((time.perf_counter() - t0) / a.n / a.batch * 1e3)
base = ms["one model"]
print(f"{a.site} | {'cpu fp32' if a.cpu else 'gpu fp16'} | {a.rounds} rounds x {a.n} batches of {a.batch} | ms per image" + (f" | reference {a.ref}" if a.ref else ""))
for k, v in ms.items():
d = [x - y for x, y in zip(v, base)]
print(f" {k:26s} median {statistics.median(v):6.2f} ms (min {min(v):6.2f}, max {max(v):6.2f}) minus one model: median {statistics.median(d):+5.2f} ms")
if __name__ == "__main__":
main()
|