Delete raven/directml_inference.py

raven/directml_inference.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-import numpy as np
-import torch
-import torch.nn.functional as F
-from .onnx_runtime import open_session,run_foundation,run_fusion
-from .transforms import foundation_transform
-from .forensic_features import load_rgb,extract_handcrafted,spectral_map,camera_residual_map
-from .specialists import load_specialists_checkpoint
-from .dataset import FeatureNormalizer,BRANCH_KEYS
-from .anchors import AnchorSet
-from .calibration import MetaCalibrator,meta_features
-from .provenance import inspect_provenance
-from .model import RavenFusion
-
-
-def _specialist(im,ck):
-    spec,cam,sck=load_specialists_checkpoint(ck,"cpu"); size=int(sck["map_size"]); sm=torch.from_numpy(spectral_map(im,size)[None,None]).float(); cm=torch.from_numpy(camera_residual_map(im,size)[None,None]).float()
-    with torch.inference_mode():
-        ps=spec(sm); pc=cam(cm)
-        def m(pred,target):
-            err=torch.abs(pred-target); flat=err.flatten(1); return [float(flat.mean()),float(((pred-target)**2).flatten(1).mean()),float(1-F.cosine_similarity(pred.flatten(1),target.flatten(1),dim=1).mean()),float(torch.quantile(flat,.90))]
-        return np.asarray(m(ps,sm)+m(pc,cm),np.float32)
-
-
-def infer_directml(model_path:str,foundation_onnx:str,fusion_onnx:str,image_path:str,cpu_only:bool=False):
-    ck=torch.load(model_path,map_location="cpu",weights_only=False); im=load_rgb(image_path); tf=foundation_transform(224); x=tf(im)[None].numpy().astype(np.float32)
-    fs=open_session(foundation_onnx,prefer_directml=not cpu_only); fus=open_session(fusion_onnx,prefer_directml=not cpu_only); sem=run_foundation(fs,x)[0].astype(np.float32)
-    h=extract_handcrafted(im,ck["config"]["features"]); sp=_specialist(im,ck["specialists_checkpoint"]); raw={"semantic":sem,"camera":h["camera"],"spectral":h["spectral"],"patch":h["patch"],"specialist":sp}
-    norm=FeatureNormalizer.from_dict(ck["normalizer"]); anchors=AnchorSet.from_dict(ck["anchors"]); nf={k:norm.transform(k,raw[k])[None] for k in BRANCH_KEYS}; anch=anchors.score({k:raw[k][None] for k in BRANCH_KEYS}); q=h["quality"][None].astype(np.float32); luma=np.asarray([float(h["quality"][0])],np.float32)
-    oo=run_fusion(fus,{**nf,"quality":q,"anchors":anch,"luma":luma}); mx=meta_features(oo["logit_mean"],oo["logit_std"],oo["branch_mean"],oo["gates_mean"],anch,sp[None],q); cs=MetaCalibrator.from_dict(ck["calibrator"]).predict_stats(mx); prob=float(cs["mean"][0]); pstd=float(cs["std"][0]); plo=float(cs["lower"][0]); phi=float(cs["upper"][0]); rt=float(ck["real_threshold"]); at=float(ck["ai_threshold"]); prov=inspect_provenance(image_path)
-    if prov.get("ai_provenance"): verdict="AI"; reason="verified provenance"
-    elif plo>=at: verdict="AI"; reason="balanced calibration interval is above AI threshold"
-    elif phi<=rt: verdict="REAL"; reason="balanced calibration interval is below REAL threshold"
-    else: verdict="UNCERTAIN"; reason="calibration interval overlaps the decision region"
-    gates=np.asarray(oo["gates_mean"])[0]; branches=1/(1+np.exp(-np.asarray(oo["branch_mean"])[0])); names=list(RavenFusion.BRANCHES)
-    return {"verdict":verdict,"balanced_ai_probability":prob,"balanced_real_probability":1-prob,"ai_probability":prob,"probability_definition":"50:50 REAL/AI prior; not inflated by dataset counts","calibration_std":pstd,"balanced_ai_probability_interval_80":[plo,phi],"reason":reason,"providers":{"foundation":fs.get_providers(),"fusion":fus.get_providers()},"thresholds":{"REAL_max":rt,"AI_min":at},"routing_weights":{n:float(gates[i]) for i,n in enumerate(names)},"branch_evidence":{n:float(branches[i]) for i,n in enumerate(names)},"provenance":prov}