Upload folder using huggingface_hub

examples/benchmark/run_evaluation.py

@@ -0,0 +1,30 @@
+"""Example: Run benchmark evaluation with baseline."""
+import json, sys
+
+# Use the benchmark evaluate script
+sys.path.insert(0, "benchmark")
+from evaluate import load_dataset, load_split, generate_baseline, evaluate_predictions, per_family_metrics
+
+# Load dataset and split
+entries = load_dataset()
+split = load_split("random_80_10_10")
+print(f"Loaded {len(entries):,} entries")
+print(f"Split: train={len(split['train']):,}  val={len(split['val']):,}  test={len(split['test']):,}")
+
+# Generate mean baseline
+predictions = generate_baseline(entries, split, "mean")
+print(f"\nGenerated mean baseline predictions")
+
+# Evaluate
+overall = evaluate_predictions(entries, split, predictions)
+print(f"\nOverall Results:")
+for target, metrics in overall.items():
+    print(f"  {target}: MAE={metrics['mae']:.4f}  R²={metrics['r2']:.4f}  RMSE={metrics['rmse']:.4f}")
+
+# Per-family
+family_results = per_family_metrics(entries, split, predictions)
+print(f"\nPer-Family FE MAE:")
+for fam in sorted(family_results.keys()):
+    fe = family_results[fam].get("FE", {})
+    mae = fe.get("mae", float("nan"))
+    print(f"  {fam:25s}: {mae:.4f}")

examples/filter/filter_by_tier.py

@@ -0,0 +1,42 @@
+"""Example: Filter entries by tier and family."""
+import json
+from collections import Counter
+
+with open("dataset/entries_final_v3.json") as f:
+    entries = json.load(f)
+
+# Filter by tier
+gold = [e for e in entries if e.get("tier") == "gold"]
+strict_gold = [e for e in entries
+               if e.get("strict_gold", {}).get("is_strict_gold", False)]
+validated = [e for e in entries if e.get("tier") == "validated"]
+
+print(f"Gold:        {len(gold):>8,}")
+print(f"Strict Gold: {len(strict_gold):>8,}")
+print(f"Validated:   {len(validated):>8,}")
+
+# Filter by battery family
+battery_families = {"layered_oxide", "sulfide_sse", "halide_sse",
+                    "polyanion", "nasicon", "garnet", "borohydride"}
+battery = [e for e in entries
+           if set(e.get("families", [])) & battery_families]
+
+print(f"\nBattery subset: {len(battery):,}")
+
+# Filter by source
+for src in ["mp", "oqmd", "jarvis"]:
+    subset = [e for e in entries if e.get("source") == src]
+    print(f"  {src}: {len(subset):,} entries")
+
+# Combine filters
+battery_gold = [e for e in gold
+                if set(e.get("families", [])) & battery_families]
+print(f"\nBattery + Gold: {len(battery_gold):,}")
+
+# Quality score distribution
+scores = Counter()
+for e in gold:
+    scores[(e.get("quality_score", 0) // 10) * 10] += 1
+print(f"\nGold quality score distribution:")
+for k in sorted(scores.keys()):
+    print(f"  {k}-{k+9}: {scores[k]:,}")

examples/load/load_dataset.py

@@ -0,0 +1,28 @@
+"""Example: Load and explore the Scandium Dataset."""
+import json
+from collections import Counter
+
+# Load the full dataset
+with open("dataset/entries_final_v3.json") as f:
+    entries = json.load(f)
+
+print(f"Loaded {len(entries):,} entries")
+
+# Quick statistics
+tiers = Counter(e.get("tier", "unknown") for e in entries)
+sources = Counter(e.get("source", "unknown") for e in entries)
+formulas = len(set(e.get("formula", "") for e in entries))
+
+print(f"\nStatistics:")
+print(f"  Sources: {dict(sources)}")
+print(f"  Tiers: {dict(tiers)}")
+print(f"  Unique formulas: {formulas:,}")
+print(f"  Families: {len(set(f for e in entries for f in e.get('families', [])))}")
+
+# Sample entries
+print(f"\nSample entries:")
+for i in range(3):
+    e = entries[i]
+    print(f"  {e['formula']:20s} | source={e['source']:6s} | "
+          f"FE={e.get('formation_energy_per_atom', 0):.3f} | "
+          f"tier={e.get('tier', '?')}")

examples/statistics/compute_statistics.py

@@ -0,0 +1,32 @@
+"""Example: Compute per-family and per-source statistics."""
+import json
+import numpy as np
+from collections import Counter
+
+with open("dataset/entries_final_v3.json") as f:
+    entries = json.load(f)
+
+# Per-family statistics
+families = Counter(f for e in entries for f in e.get("families", ["unknown"]))
+print("Family Distribution:")
+for fam, count in families.most_common():
+    pct = 100 * count / len(entries)
+    print(f"  {fam:25s}: {count:>7,} ({pct:.1f}%)")
+
+# Per-source FE distribution
+print("\nFE Distribution by Source:")
+for src in ["mp", "oqmd", "jarvis"]:
+    subset = [e for e in entries if e.get("source") == src]
+    fe_vals = [e.get("formation_energy_per_atom", 0) for e in subset
+               if e.get("formation_energy_per_atom") is not None]
+    print(f"  {src:8s}: mean={np.mean(fe_vals):.3f}  "
+          f"median={np.median(fe_vals):.3f}  "
+          f"std={np.std(fe_vals):.3f}  "
+          f"N={len(fe_vals):,}")
+
+# Coverage analysis
+print("\nProperty Coverage:")
+for prop in ["formation_energy_per_atom", "energy_above_hull", "band_gap"]:
+    present = sum(1 for e in entries if e.get(prop) is not None)
+    print(f"  {prop:35s}: {present:>7,} / {len(entries):,} "
+          f"({100*present/len(entries):.1f}%)")

examples/visualization/plot_distributions.py

@@ -0,0 +1,41 @@
+"""Example: Visualize dataset distributions.
+
+Requires: matplotlib, numpy
+"""
+import json, numpy as np
+from collections import Counter
+
+with open("dataset/entries_final_v3.json") as f:
+    entries = json.load(f)
+
+# FE histogram
+fe_vals = np.array([e.get("formation_energy_per_atom", 0)
+                    for e in entries if e.get("formation_energy_per_atom") is not None])
+
+print("FE Distribution (eV/atom):")
+fe_range = (-5, 3)
+bins = np.linspace(fe_range[0], fe_range[1], 40)
+hist, edges = np.histogram(fe_vals, bins=bins)
+max_bar = max(hist)
+for i in range(len(hist)):
+    if hist[i] < max_bar * 0.01:
+        continue
+    bar_len = int(60 * hist[i] / max_bar)
+    print(f"  {edges[i]:+5.2f}: {'█' * bar_len} ({hist[i]:,})")
+
+# BG histogram
+bg_vals = np.array([e.get("band_gap", 0)
+                    for e in entries if e.get("band_gap") is not None])
+bg_nonzero = bg_vals[bg_vals > 0.01]
+print(f"\nBand Gap Distribution:")
+print(f"  Zero gap (metals): {np.sum(bg_vals <= 0.01):,} "
+      f"({100*np.sum(bg_vals <= 0.01)/len(bg_vals):.0f}%)")
+print(f"  Non-zero mean: {np.mean(bg_nonzero):.3f} eV")
+print(f"  Non-zero median: {np.median(bg_nonzero):.3f} eV")
+print(f"  Max: {np.max(bg_vals):.2f} eV")
+
+# Tier pie
+tiers = Counter(e.get("tier", "unknown") for e in entries)
+print(f"\nTier Distribution:")
+for tier, count in tiers.most_common():
+    print(f"  {tier:12s}: {count:>7,} ({100*count/len(entries):.1f}%)")