Add GPU telemetry to publish_job.py

publish_job.py

@@ -1,103 +1,68 @@
 # /// script
 # requires-python = ">=3.11"
-# dependencies = [
-#   "huggingface-hub>=1.0",
-#   "optimum[onnxruntime]>=2.0",
-#   "transformers>=5.0",
-#   "torch>=2.6",
-#   "onnx>=1.17",
-#   "onnxruntime>=1.21",
-#   "psutil>=6",
-# ]
+# dependencies = ["huggingface-hub>=0.34,<1.0", "transformers>=4.56,<4.58", "optimum[onnxruntime]>=2.1,<2.3", "onnx>=1.17", "onnxruntime>=1.20", "onnxconverter-common>=1.14", "psutil>=6", "nvidia-ml-py>=12.560"]
 # ///
 from __future__ import annotations
-import argparse, json, os, shutil, subprocess, tempfile, threading, time
+import argparse, atexit, json, os, shutil, subprocess, threading, time
 from pathlib import Path
-from typing import Any
 import psutil
 from huggingface_hub import HfApi, snapshot_download
 
-
-def emit(percent:int, stage:str, message:str):
-    print(json.dumps({"event":"progress","percent":percent,"stage":stage,"message":message}),flush=True)
+def emit(p,s,m): print(json.dumps({'event':'progress','percent':p,'stage':s,'message':m}),flush=True)
+def gpu_sample():
+ try:
+  import pynvml; pynvml.nvmlInit(); count=pynvml.nvmlDeviceGetCount(); names=[]; utils=[]; used=total=0; temps=[]
+  for i in range(count):
+   h=pynvml.nvmlDeviceGetHandleByIndex(i); n=pynvml.nvmlDeviceGetName(h); names.append(n.decode() if isinstance(n,bytes) else str(n)); u=pynvml.nvmlDeviceGetUtilizationRates(h); utils.append(float(u.gpu)); m=pynvml.nvmlDeviceGetMemoryInfo(h); used+=m.used; total+=m.total
+   try: temps.append(float(pynvml.nvmlDeviceGetTemperature(h,pynvml.NVML_TEMPERATURE_GPU)))
+   except Exception: pass
+  pynvml.nvmlShutdown(); return {'gpu_count':count,'gpu_name':' + '.join(names) or None,'gpu_util_percent':sum(utils)/len(utils) if utils else None,'vram_used_gb':used/1024**3 if total else None,'vram_total_gb':total/1024**3 if total else None,'vram_percent':100*used/total if total else None,'gpu_temperature_c':sum(temps)/len(temps) if temps else None}
+ except Exception:return {'gpu_count':0,'gpu_name':None,'gpu_util_percent':None,'vram_used_gb':None,'vram_total_gb':None,'vram_percent':None,'gpu_temperature_c':None}
 
 class Telemetry:
-    def __init__(self): self.stop=threading.Event(); self.thread=threading.Thread(target=self.run,daemon=True)
-    def start(self): self.thread.start(); return self
-    def close(self): self.stop.set(); self.thread.join(timeout=2)
-    def run(self):
-        psutil.cpu_percent(None)
-        while not self.stop.wait(2):
-            m=psutil.virtual_memory(); p:dict[str,Any]={"event":"telemetry","timestamp":time.time(),"cpu_percent":psutil.cpu_percent(None),"ram_percent":m.percent,"ram_used_gb":round((m.total-m.available)/1024**3,3),"ram_total_gb":round(m.total/1024**3,3),"gpu_count":0,"gpu_name":None,"gpu_util_percent":None,"vram_used_gb":None,"vram_total_gb":None,"vram_percent":None,"gpu_temperature_c":None}
-            try:
-                import pynvml
-                pynvml.nvmlInit(); n=pynvml.nvmlDeviceGetCount(); used=total=0; utils=[]; names=[]
-                for i in range(n):
-                    h=pynvml.nvmlDeviceGetHandleByIndex(i); mem=pynvml.nvmlDeviceGetMemoryInfo(h); used+=mem.used; total+=mem.total; utils.append(pynvml.nvmlDeviceGetUtilizationRates(h).gpu); name=pynvml.nvmlDeviceGetName(h); names.append(name.decode() if isinstance(name,bytes) else str(name))
-                p.update(gpu_count=n,gpu_name=" + ".join(names) or None,gpu_util_percent=sum(utils)/len(utils) if utils else None,vram_used_gb=round(used/1024**3,3) if total else None,vram_total_gb=round(total/1024**3,3) if total else None,vram_percent=100*used/total if total else None)
-                pynvml.nvmlShutdown()
-            except Exception: pass
-            print(json.dumps(p),flush=True)
-
-def parse_args():
-    ap=argparse.ArgumentParser(description="Export, optimize and publish an ONNX model")
-    ap.add_argument("--source",required=True); ap.add_argument("--output-repo",required=True); ap.add_argument("--task",default="auto"); ap.add_argument("--backend",default="onnxruntime"); ap.add_argument("--precision",default="fp16"); ap.add_argument("--quantization",default="none"); ap.add_argument("--opset",type=int,default=18); ap.add_argument("--opt-level",default="all"); ap.add_argument("--dynamic-shapes",action="store_true"); ap.add_argument("--external-data",action="store_true"); ap.add_argument("--private",action="store_true"); ap.add_argument("--dry-run",action="store_true")
-    return ap.parse_args()
-
-def source_path(source:str, token:str, root:Path, dry_run:bool)->Path|None:
-    candidate=Path(source)
-    if candidate.is_absolute() and candidate.exists(): return candidate
-    cached=Path("/cache")/source.lstrip("/")
-    if cached.exists(): return cached
-    if dry_run: return None
-    return Path(snapshot_download(source,repo_type="model",token=token,local_dir=root/"source"))
-
+ def __init__(self): self.stop=threading.Event(); self.t=threading.Thread(target=self.run,daemon=True)
+ def start(self): psutil.cpu_percent(None); self.t.start(); atexit.register(self.stop.set)
+ def run(self):
+  while not self.stop.wait(1):
+   m=psutil.virtual_memory(); payload={'event':'telemetry','timestamp':time.time(),'cpu_percent':psutil.cpu_percent(None),'ram_percent':m.percent,'ram_used_gb':round((m.total-m.available)/1024**3,3),'ram_total_gb':round(m.total/1024**3,3)}; payload.update(gpu_sample()); print(json.dumps(payload),flush=True)
+def resolve(source,token):
+ p=Path('/cache')/source.lstrip('/')
+ if p.exists(): return p
+ return Path(snapshot_download(source,token=token)) if '/' in source else p
 def main():
-    a=parse_args(); token=os.environ["HF_TOKEN"]; telemetry=Telemetry().start()
-    try:
-        emit(3,"inspect",f"Inspecting {a.source}")
-        api=HfApi(token=token)
-        remote_info=None
-        source_status="cache"
-        if not (Path(a.source).exists() or (Path('/cache')/a.source.lstrip('/')).exists()):
-            try: remote_info=api.model_info(a.source,token=token); source_status="Hub"
-            except Exception: source_status="planned output"
-        if a.dry_run:
-            emit(100,"completed",f"PublishJob dry-run valid · source={source_status} · target={a.output_repo}")
-            return
-        with tempfile.TemporaryDirectory() as tmp:
-            root=Path(tmp); src=source_path(a.source,token,root,False); assert src is not None
-            out=root/"onnx"; out.mkdir(parents=True)
-            existing=list(src.rglob("*.onnx"))
-            if existing:
-                emit(25,"collect",f"Copying {len(existing)} existing ONNX graph(s)")
-                for file in existing:
-                    target=out/file.name; shutil.copy2(file,target)
-                    data=file.with_name(file.name+"_data")
-                    if data.exists(): shutil.copy2(data,out/data.name)
-            else:
-                emit(20,"export",f"Exporting with Optimum · task={a.task} · opset={a.opset}")
-                command=["optimum-cli","export","onnx","--model",str(src),"--opset",str(a.opset)]
-                if a.task and a.task!="auto": command += ["--task",a.task]
-                command.append(str(out))
-                process=subprocess.Popen(command,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True)
-                assert process.stdout is not None
-                for line in process.stdout:
-                    print(line.rstrip(),flush=True)
-                if process.wait(): raise RuntimeError("Optimum ONNX export failed")
-            graphs=list(out.glob("*.onnx"))
-            if not graphs: raise RuntimeError("No ONNX graph was produced")
-            if a.quantization in {"dynamic","weight-only"} or a.precision=="int8":
-                emit(62,"quantize","Applying ONNX Runtime dynamic INT8 quantization")
-                from onnxruntime.quantization import QuantType, quantize_dynamic
-                for graph in list(graphs):
-                    quantized=graph.with_name(graph.stem+"-int8.onnx"); quantize_dynamic(str(graph),str(quantized),weight_type=QuantType.QInt8)
-                graphs=list(out.glob("*.onnx"))
-            manifest={"source":a.source,"output_repo":a.output_repo,"task":a.task,"backend":a.backend,"precision":a.precision,"quantization":a.quantization,"opset":a.opset,"opt_level":a.opt_level,"dynamic_shapes":a.dynamic_shapes,"external_data":a.external_data,"graphs":[g.name for g in graphs]}
-            (out/"publish_manifest.json").write_text(json.dumps(manifest,indent=2),encoding="utf-8")
-            emit(82,"upload",f"Uploading {len(graphs)} graph(s)")
-            api.create_repo(a.output_repo,repo_type="model",private=a.private,exist_ok=True,token=token)
-            api.upload_folder(folder_path=out,repo_id=a.output_repo,repo_type="model",token=token,commit_message="Publish ONNX runtime package")
-            emit(100,"completed",f"Published ONNX package to {a.output_repo}")
-    finally: telemetry.close()
-if __name__=="__main__": main()
+ ap=argparse.ArgumentParser(); ap.add_argument('--source',required=True); ap.add_argument('--output-repo',required=True); ap.add_argument('--task',default='auto'); ap.add_argument('--backend',default='onnxruntime'); ap.add_argument('--precision',default='fp16'); ap.add_argument('--quantization',default='none'); ap.add_argument('--opset',type=int,default=18); ap.add_argument('--dynamic-shapes',action='store_true'); ap.add_argument('--external-data',action='store_true'); ap.add_argument('--opt-level',default='all'); ap.add_argument('--private',action='store_true'); ap.add_argument('--dry-run',action='store_true'); a=ap.parse_args(); token=os.environ['HF_TOKEN']; Telemetry().start(); emit(5,'inspect',f'Inspecting {a.source}'); out=Path('/cache/publish')/a.output_repo.replace('/','__'); out.mkdir(parents=True,exist_ok=True)
+ local=Path('/cache')/a.source.lstrip('/'); existing=list(local.rglob('*.onnx')) if local.exists() else []
+ remote_files=[]
+ if not local.exists() and '/' in a.source:
+  try: remote_files=HfApi(token=token).list_repo_files(a.source,token=token)
+  except Exception: remote_files=[]
+ plan=vars(a)|{'local_source':str(local),'local_exists':local.exists(),'existing_onnx':[str(x) for x in existing],'remote_onnx':[x for x in remote_files if x.endswith('.onnx')]}; (out/'publish_plan.json').write_text(json.dumps(plan,indent=2))
+ if a.dry_run: emit(100,'completed',f"PublishJob dry-run validated; {len(existing)} local and {len(plan['remote_onnx'])} remote ONNX file(s) found"); return
+ source=resolve(a.source,token)
+ if existing:
+  emit(25,'copy','Copying existing ONNX package')
+  for f in existing: shutil.copy2(f,out/f.name)
+ else:
+  emit(20,'export','Exporting model to ONNX with Optimum')
+  cmd=['optimum-cli','export','onnx','--model',str(source),'--task',a.task,'--opset',str(a.opset),str(out)]; subprocess.run(cmd,check=True)
+ files=list(out.rglob('*.onnx'))
+ if not files: raise SystemExit('PublishJob produced no ONNX graph')
+ if a.precision=='fp16':
+  emit(58,'precision','Converting ONNX weights to FP16')
+  import onnx
+  from onnxconverter_common import float16
+  for f in files:
+   model=onnx.load(str(f)); model=float16.convert_float_to_float16(model,keep_io_types=True); onnx.save(model,str(f))
+ if a.quantization=='dynamic':
+  emit(68,'quantize','Applying dynamic INT8 quantization')
+  from onnxruntime.quantization import quantize_dynamic, QuantType
+  for f in list(out.rglob('*.onnx')):
+   target=f.with_name(f.stem+'-int8.onnx'); quantize_dynamic(str(f),str(target),weight_type=QuantType.QInt8)
+ emit(82,'validate','Validating exported ONNX sessions')
+ import onnxruntime as ort
+ validated=[]
+ for f in out.rglob('*.onnx'): ort.InferenceSession(str(f),providers=['CPUExecutionProvider']); validated.append(f.name)
+ (out/'publish_manifest.json').write_text(json.dumps({'source':a.source,'backend':a.backend,'precision':a.precision,'quantization':a.quantization,'files':validated},indent=2))
+ api=HfApi(token=token); api.create_repo(a.output_repo,repo_type='model',private=a.private,exist_ok=True,token=token); api.upload_folder(folder_path=out,repo_id=a.output_repo,repo_type='model',token=token,commit_message='Publish ONNX runtime package')
+ emit(100,'completed',f'Published {len(validated)} ONNX graph(s) to {a.output_repo}')
+if __name__=='__main__': main()