| """Structured data, prediction, confusion, environment, and k-fold reports.""" |
|
|
| from __future__ import annotations |
|
|
| import json, platform, subprocess, sys |
| from datetime import datetime, timezone |
| from pathlib import Path |
| import numpy as np |
| import pandas as pd |
| from .core import json_safe |
| from .data import synthetic_mask |
|
|
|
|
| def environment_info(): |
| import torch |
| def git(*args): |
| try: return subprocess.run(["git",*args],capture_output=True,text=True,timeout=5).stdout.strip() |
| except Exception: return None |
| return {"timestamp_utc":datetime.now(timezone.utc).isoformat(),"cwd":str(Path.cwd()),"command":sys.argv, |
| "python":sys.version.replace("\n"," "),"platform":platform.platform(),"executable":sys.executable, |
| "torch":{"version":torch.__version__,"cuda_available":torch.cuda.is_available(), |
| "device":torch.cuda.get_device_name(0) if torch.cuda.is_available() else None}, |
| "git":{"commit":git("rev-parse","HEAD"),"branch":git("rev-parse","--abbrev-ref","HEAD"), |
| "status_short":(git("status","--short") or "").splitlines()}} |
|
|
|
|
| def distribution(df, class_names): |
| synth = synthetic_mask(df); ignored = df.get("ignore_metadata",pd.Series(False,index=df.index)).fillna(False).astype(bool).to_numpy() |
| return {"rows":len(df),"real_rows":int((~synth).sum()),"synthetic_rows":int(synth.sum()), |
| "ignore_metadata_rows":int(ignored.sum()), |
| "class_counts":df.label.value_counts().reindex(class_names,fill_value=0).astype(int).to_dict(), |
| "synthetic_class_counts":df.loc[synth,"label"].value_counts().reindex(class_names,fill_value=0).astype(int).to_dict()} |
|
|
|
|
| def save_data_summary(output_dir, full_df, train_df, val_df, class_names): |
| payload={"full":distribution(full_df,class_names),"train":distribution(train_df,class_names),"val":distribution(val_df,class_names), |
| "synthetic_train_only":bool(synthetic_mask(train_df).sum() and not synthetic_mask(val_df).sum())} |
| (output_dir/"data_summary.json").write_text(json.dumps(json_safe(payload),indent=2),encoding="utf-8") |
| lines=["# Split Summary",""] |
| for split in ("full","train","val"): |
| item=payload[split]; lines += [f"## {split.title()}","",f"- rows: {item['rows']}",f"- real: {item['real_rows']}",f"- synthetic: {item['synthetic_rows']}","","| class | count | synthetic |","|---|---:|---:|"] |
| lines += [f"| {name} | {count} | {item['synthetic_class_counts'][name]} |" for name,count in item["class_counts"].items()]; lines.append("") |
| (output_dir/"split_summary.md").write_text("\n".join(lines),encoding="utf-8") |
| return payload |
|
|
|
|
| def prediction_summary(prob, class_names): |
| pred=prob.argmax(1); sorted_prob=np.sort(prob,axis=1); confidence=sorted_prob[:,-1]; second=sorted_prob[:,-2] |
| entropy=-np.sum(prob*np.log(np.clip(prob,1e-12,1)),axis=1); counts=np.bincount(pred,minlength=len(class_names)) |
| return {"rows":len(prob),"predicted_class_counts":{n:int(counts[i]) for i,n in enumerate(class_names)}, |
| "mean_probability":{n:float(prob[:,i].mean()) for i,n in enumerate(class_names)}, |
| "mean_confidence":float(confidence.mean()),"median_confidence":float(np.median(confidence)), |
| "mean_top1_top2_gap":float((confidence-second).mean()),"mean_entropy":float(entropy.mean()), |
| "low_confidence_rows":int((confidence<.5).sum())} |
|
|
|
|
| def confusion_analysis(cm,class_names): |
| pairs=[] |
| for i,true in enumerate(class_names): |
| total=int(cm[i].sum()) |
| for j,pred in enumerate(class_names): |
| if i!=j and cm[i,j]: pairs.append({"true":true,"predicted":pred,"count":int(cm[i,j]),"rate_of_true":float(cm[i,j]/total) if total else 0}) |
| return {"top_confusion_pairs":sorted(pairs,key=lambda x:x["count"],reverse=True)[:20]} |
|
|
|
|
| def save_diagnostics(output_dir,args,data_summary,metrics,per_class,cm,prob,class_names,fold=None): |
| pred=prediction_summary(prob,class_names); conf=confusion_analysis(cm,class_names); warnings=[] |
| for row in per_class.to_dict("records"): |
| if row["support"]<=5: warnings.append({"severity":"medium","code":"tiny_validation_support","class":row["class"]}) |
| if row["recall_sensitivity"]==0: warnings.append({"severity":"high","code":"zero_recall","class":row["class"]}) |
| diag={"fold":fold,"warnings":warnings,"prediction_summary":pred,"confusion_analysis":conf} |
| for name,value in (("prediction_summary",pred),("confusion_analysis",conf),("run_diagnostics",diag)): |
| (output_dir/f"{name}.json").write_text(json.dumps(json_safe(value),indent=2),encoding="utf-8") |
| lines=["# Dermoscopic Run Report","",f"- fold: {fold}",f"- backbone: {args.backbone}",f"- metadata_mode: {args.metadata_mode}",f"- loss: {args.loss}","","## Metrics",""] |
| lines += [f"- {key}: {metrics.get(key)}" for key in ("accuracy","balanced_accuracy","f1_macro","dice_macro","roc_auc_macro_ovr","top3_accuracy")] |
| lines += ["","## Per class","","```",per_class.to_string(index=False),"```","","## Top confusions",""] |
| lines += [f"- {x['true']} -> {x['predicted']}: {x['count']} ({x['rate_of_true']:.1%})" for x in conf["top_confusion_pairs"][:12]] |
| lines += ["","## Warnings",""]+[f"- [{x['severity']}] {x['code']}: {x.get('class','')}" for x in warnings] |
| (output_dir/"run_report.md").write_text("\n".join(lines),encoding="utf-8") |
| return diag |
|
|
|
|
| def save_kfold_summary(metrics_list,output_dir): |
| keys=("best_selection_metric","best_val_tail_recall_macro","accuracy","balanced_accuracy","f1_macro","f1_weighted","dice_macro","roc_auc_macro_ovr","top3_accuracy") |
| rows=[{"fold":i,**{k:m.get(k) for k in keys}} for i,m in enumerate(metrics_list)] |
| frame=pd.DataFrame(rows); frame.to_csv(output_dir/"kfold_summary.csv",index=False) |
| payload={"folds":rows,"mean":{},"std":{}} |
| for key in keys: |
| values=pd.to_numeric(frame[key],errors="coerce").dropna(); payload["mean"][key]=None if values.empty else float(values.mean()); payload["std"][key]=None if values.empty else float(values.std(ddof=0)) |
| (output_dir/"kfold_summary.json").write_text(json.dumps(json_safe(payload),indent=2),encoding="utf-8") |
| (output_dir/"kfold_report.md").write_text("# K-fold Summary\n\n```\n"+frame.to_string(index=False)+"\n```\n",encoding="utf-8") |
| return payload |
|
|
