Upload scripts/audit_phase8_metadata.py with huggingface_hub

scripts/audit_phase8_metadata.py

@@ -0,0 +1,170 @@
+"""Phase 8: Metadata Audit — completeness, consistency, correctness."""
+import json, time
+from pathlib import Path
+from collections import Counter
+import numpy as np
+
+OUT = Path("scripts/audit_reports")
+DATASET = "dataset/entries_final_v3.json"
+AUDIT_DIR = Path.cwd() if Path.cwd().name == "Scandium-Dataset" else Path("/home/shamique/Scandium Labs SSB/Scandium-Dataset")
+
+severity_counts = {"CRITICAL": 0, "HIGH": 0, "MEDIUM": 0, "LOW": 0, "PASS": 0}
+findings = []
+
+def finding(severity, phase, check, status, detail):
+    severity_counts[severity] += 1
+    findings.append({"severity": severity, "phase": phase, "check": check, "status": status, "detail": str(detail)[:200]})
+    s = "🔴" if severity == "CRITICAL" else "🟠" if severity == "HIGH" else "🟡" if severity == "MEDIUM" else "🔵" if severity == "LOW" else "✅"
+    print(f"  {s} [{severity:8s}] {check}: {str(detail)[:120]}")
+
+REQUIRED_FIELDS = ["source_id", "formula", "elements", "source",
+                   "space_group", "volume", "density", "structure_json",
+                   "quality_score", "quality_sub_scores", "quality_flags",
+                   "tier", "provenance", "nsites", "band_gap", "formation_energy_per_atom",
+                   "families"]
+
+def main():
+    print("=" * 60)
+    print("  PHASE 8: METADATA AUDIT")
+    print("=" * 60)
+
+    with open(AUDIT_DIR / DATASET) as f:
+        entries = json.load(f)
+    N = len(entries)
+
+    # Field completeness
+    print(f"\n--- Field Completeness ---")
+    field_missing = Counter()
+    for field in REQUIRED_FIELDS:
+        for e in entries:
+            if field not in e or e[field] is None:
+                field_missing[field] += 1
+    
+    for field, count in sorted(field_missing.items()):
+        bad = count > 0
+        sev = "PASS"
+        if bad and count > N * 0.01:
+            sev = "HIGH" if count > N * 0.1 else "MEDIUM"
+        elif bad and count > 10:
+            sev = "LOW"
+        elif bad:
+            sev = "PASS"
+        finding(sev, "completeness", f"missing_{field}", f"{count:,} ({100*count/N:.1f}%)", "")
+
+    # Check tier distribution
+    print(f"\n--- Tier Distribution ---")
+    tier_counts = Counter(e.get("tier") for e in entries)
+    for tier, cnt in sorted(tier_counts.items()):
+        print(f"    {tier:12s}: {cnt:>7,}")
+    if tier_counts.get("raw") is None:
+        finding("LOW", "tiers", "no_raw_tier", "raw tier missing from frozen set", "")
+    
+    # Source distribution
+    print(f"\n--- Source Distribution ---")
+    src_counts = Counter(e.get("source") for e in entries)
+    for src, cnt in sorted(src_counts.items()):
+        print(f"    {src:8s}: {cnt:>7,} ({100*cnt/N:.1f}%)")
+    
+    # Family distribution
+    print(f"\n--- Family Distribution ---")
+    family_counts = Counter()
+    for e in entries:
+        for fam in e.get("families", []):
+            family_counts[fam] += 1
+    for fam, cnt in sorted(family_counts.most_common(20)):
+        print(f"    {fam:20s}: {cnt:>7,}")
+
+    # Provenance completeness
+    print(f"\n--- Provenance ---")
+    prov_fields = 0
+    for e in entries:
+        if e.get("provenance"):
+            prov_fields += 1
+    print(f"  Entries with provenance: {prov_fields:,} ({100*prov_fields/N:.1f}%)")
+    if prov_fields < N:
+        finding("HIGH", "provenance", "missing_provenance",
+                f"{N - prov_fields:,} entries ({100*(N-prov_fields)/N:.1f}%) missing", "")
+    else:
+        finding("PASS", "provenance", "all_have_provenance", "", "")
+
+    # Check duplicate_group metadata
+    dg_cnt = sum(1 for e in entries if e.get("duplicate_group") is not None)
+    print(f"\n  Entries with duplicate_group: {dg_cnt:,} ({100*dg_cnt/N:.1f}%)")
+
+    # Check that all entries have structure_json
+    no_struct = sum(1 for e in entries if not e.get("structure_json"))
+    if no_struct > 0:
+        finding("CRITICAL", "structure", "missing_structure",
+                f"{no_struct:,} ({100*no_struct/N:.1f}%)", "")
+    else:
+        finding("PASS", "structure", "all_have_structure", "", "")
+
+    # Check structured_formula parity
+    sf_missing = sum(1 for e in entries if not e.get("structured_formula"))
+    if sf_missing > 0:
+        finding("MEDIUM", "metadata", "missing_structured_formula",
+                f"{sf_missing:,} entries", "")
+    
+    # ID format consistency
+    print(f"\n--- ID Consistency ---")
+    id_formats = Counter()
+    for e in entries:
+        mid = e.get("source_id", "")
+        if mid.startswith("mp-"):
+            id_formats["mp-"] += 1
+        elif mid.startswith("oqmd-"):
+            id_formats["oqmd-"] += 1
+        elif mid.startswith("jv-") or mid.startswith("jarvis-"):
+            id_formats["jarvis"] += 1
+        else:
+            id_formats["other"] += 1
+    for fmt, cnt in sorted(id_formats.items()):
+        print(f"    {fmt:12s}: {cnt:>7,}")
+
+    if id_formats.get("other", 0) > 0:
+        finding("MEDIUM", "metadata", "nonstandard_ids",
+                f"{id_formats['other']:,} nonstandard IDs", "")
+
+    # Quality flags staleness (OQMD space_group flag vs actual space_group)
+    stale_flags = 0
+    for e in entries:
+        if e.get("source") == "oqmd" and e.get("space_group") is not None:
+            flags = e.get("quality_flags", [])
+            if "missing_spacegroup" in flags:
+                stale_flags += 1
+    if stale_flags > 100:
+        finding("MEDIUM", "metadata", "stale_quality_flags",
+                f"{stale_flags:,} OQMD entries flagged missing_spacegroup but SG now populated", "flags need recalculation")
+    elif stale_flags > 0:
+        finding("LOW", "metadata", "stale_quality_flags", f"{stale_flags} entries", "")
+    else:
+        finding("PASS", "metadata", "flags_current", "", "")
+
+    # Summary
+    print(f"\n{'=' * 60}")
+    print(f"  PHASE 8 SUMMARY")
+    print(f"  CRITICAL: {severity_counts['CRITICAL']}")
+    print(f"  HIGH:     {severity_counts['HIGH']}")
+    print(f"  MEDIUM:   {severity_counts['MEDIUM']}")
+    print(f"  LOW:      {severity_counts['LOW']}")
+    print(f"  PASS:     {severity_counts['PASS']}")
+    print(f"{'=' * 60}")
+
+    report = {
+        "phase": "Phase 8: Metadata Audit",
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "field_completeness": dict(field_missing),
+        "tier_distribution": dict(tier_counts),
+        "source_distribution": dict(src_counts),
+        "family_distribution": dict(family_counts),
+        "id_formats": dict(id_formats),
+        "stale_quality_flags": stale_flags,
+        "findings": findings,
+        "summary": dict(severity_counts),
+    }
+    with open(OUT / "phase8_metadata_audit.json", "w") as f:
+        json.dump(report, f, indent=2)
+    print(f"\n  Report: {OUT / 'phase8_metadata_audit.json'}")
+
+if __name__ == "__main__":
+    main()