Upload scripts/qualitative_eval.py with huggingface_hub

scripts/qualitative_eval.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""Qualitative analysis: reconstruct Ruby code from teacher-forced GIN and check syntax.
+
+Uses the full pipeline: model → predict types + parents → build AST tree → Ruby pretty-print → syntax check.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+
+import torch
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from data_processing import ASTGraphConverter, ASTNodeEncoder, create_data_loaders
+from models import ASTAutoencoder
+from torch_geometric.data import Data
+
+RESULTS_DIR = "results/gin_deep_dive"
+DATASET_PATH = "dataset"
+ENCODER_WEIGHTS = "models/best_model.pt"
+NUM_SAMPLES = 200
+
+
+def run_ruby_script(script_path: str, stdin_data: str) -> str:
+    """Run a Ruby script with stdin and return stdout."""
+    try:
+        result = subprocess.run(
+            ["ruby", script_path],
+            input=stdin_data,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        return result.stdout.strip()
+    except Exception:
+        return ""
+
+
+def check_ruby_syntax(code: str) -> bool:
+    """Check if code is valid Ruby."""
+    if not code or not code.strip():
+        return False
+    try:
+        result = subprocess.run(
+            ["ruby", "scripts/check_syntax.rb"],
+            input=code,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def evaluate_model_full(model_path: str, label: str, hidden_dim: int,
+                        num_layers: int, decoder_conv_type: str,
+                        decoder_edge_mode: str) -> dict:
+    """Full evaluation: model → AST → Ruby code → syntax check."""
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    converter = ASTGraphConverter()
+
+    model = ASTAutoencoder(
+        encoder_input_dim=74,
+        node_output_dim=74,
+        hidden_dim=hidden_dim,
+        num_layers=num_layers,
+        conv_type="SAGE",
+        freeze_encoder=True,
+        encoder_weights_path=ENCODER_WEIGHTS,
+        decoder_conv_type=decoder_conv_type,
+        decoder_edge_mode=decoder_edge_mode,
+    ).to(device)
+
+    checkpoint = torch.load(model_path, map_location=device, weights_only=False)
+    model.decoder.load_state_dict(checkpoint["decoder_state_dict"])
+    model.eval()
+
+    val_path = os.path.join(DATASET_PATH, "val.jsonl")
+    _, val_loader = create_data_loaders(
+        val_path, val_path, batch_size=1, shuffle=False, num_workers=0
+    )
+
+    # Also load raw source for comparison
+    raw_sources = []
+    with open(val_path) as f:
+        for line in f:
+            d = json.loads(line)
+            raw_sources.append(d["raw_source"])
+
+    results = []
+    syntax_valid = 0
+    heuristic_valid = 0
+    total = 0
+
+    print(f"\nEvaluating {label} on {NUM_SAMPLES} samples...")
+
+    with torch.no_grad():
+        for batch in val_loader:
+            if total >= NUM_SAMPLES:
+                break
+
+            batch = batch.to(device)
+            result = model(batch)
+            recon = result["reconstruction"]
+
+            node_feats = recon.get("node_features") if isinstance(recon, dict) else None
+            parent_logits = recon.get("parent_logits") if isinstance(recon, dict) else None
+
+            if node_feats is None:
+                total += 1
+                continue
+
+            pred_types = node_feats.argmax(dim=-1)
+            orig_types = batch.x.argmax(dim=-1) if batch.x.dim() > 1 else batch.x
+
+            unique_pred = len(pred_types.unique())
+            type_match = (pred_types == orig_types).float().mean().item()
+            heuristic_ok = unique_pred > 2
+
+            # Build reconstructed AST tree from types + parents
+            reconstructed_code = ""
+            if parent_logits is not None:
+                parent_preds = parent_logits.squeeze(0).argmax(dim=-1)
+                node_map = {}
+                for i, type_idx in enumerate(pred_types.cpu().numpy()):
+                    nt = converter.node_encoder.node_types[type_idx] \
+                        if type_idx < len(converter.node_encoder.node_types) else "unknown"
+                    node_map[i] = {"type": nt, "children": []}
+
+                root_nodes = []
+                for i, parent_idx in enumerate(parent_preds.cpu().numpy()):
+                    pi = int(parent_idx)
+                    if i == pi or pi >= len(node_map):
+                        root_nodes.append(node_map[i])
+                    elif pi in node_map:
+                        node_map[pi]["children"].append(node_map[i])
+
+                if root_nodes:
+                    ast_json = json.dumps(root_nodes)
+                    reconstructed_code = run_ruby_script(
+                        "scripts/pretty_print_ast.rb", ast_json
+                    )
+
+            is_valid = check_ruby_syntax(reconstructed_code)
+
+            sample = {
+                "index": total,
+                "num_nodes": int(pred_types.shape[0]),
+                "type_accuracy": round(type_match, 4),
+                "heuristic_valid": heuristic_ok,
+                "syntax_valid": is_valid,
+                "original_code": raw_sources[total] if total < len(raw_sources) else "",
+                "reconstructed_code": reconstructed_code,
+                "pred_types": [converter.node_encoder.node_types[t]
+                               if t < len(converter.node_encoder.node_types) else "unknown"
+                               for t in pred_types.cpu().tolist()],
+            }
+            results.append(sample)
+
+            if heuristic_ok:
+                heuristic_valid += 1
+            if is_valid:
+                syntax_valid += 1
+            total += 1
+
+            if total % 50 == 0:
+                print(f"  {total}/{NUM_SAMPLES} done, "
+                      f"syntax_valid={syntax_valid}, heuristic_valid={heuristic_valid}")
+
+    heuristic_pct = (heuristic_valid / total * 100) if total > 0 else 0
+    syntax_pct = (syntax_valid / total * 100) if total > 0 else 0
+
+    print(f"\n{label}: heuristic={heuristic_pct:.1f}%, syntax={syntax_pct:.1f}% "
+          f"({syntax_valid}/{total})")
+
+    # Show examples of valid reconstructions
+    valid_examples = [r for r in results if r["syntax_valid"]]
+    print(f"\n--- Valid reconstructions ({len(valid_examples)} total) ---")
+    for r in valid_examples[:5]:
+        print(f"\nSample #{r['index']} ({r['num_nodes']} nodes, type_acc={r['type_accuracy']}):")
+        print(f"  ORIGINAL:      {r['original_code'][:80].strip()}")
+        print(f"  RECONSTRUCTED: {r['reconstructed_code'][:80].strip()}")
+
+    # Show best type-accuracy samples that failed syntax
+    failed_high_acc = sorted(
+        [r for r in results if not r["syntax_valid"] and r["type_accuracy"] > 0.9],
+        key=lambda x: -x["type_accuracy"],
+    )
+    if failed_high_acc:
+        print(f"\n--- High accuracy but invalid syntax ({len(failed_high_acc)} total) ---")
+        for r in failed_high_acc[:3]:
+            print(f"\nSample #{r['index']} (type_acc={r['type_accuracy']}):")
+            print(f"  ORIGINAL:      {r['original_code'][:80].strip()}")
+            print(f"  RECONSTRUCTED: {r['reconstructed_code'][:80].strip()}")
+            print(f"  PRED TYPES: {r['pred_types'][:12]}")
+
+    output = {
+        "label": label,
+        "total": total,
+        "heuristic_valid": heuristic_valid,
+        "heuristic_pct": round(heuristic_pct, 2),
+        "syntax_valid": syntax_valid,
+        "syntax_pct": round(syntax_pct, 2),
+        "valid_examples": valid_examples[:10],
+        "failed_high_acc": [
+            {k: v for k, v in r.items() if k != "pred_types"}
+            for r in failed_high_acc[:10]
+        ],
+    }
+
+    out_path = os.path.join(RESULTS_DIR, f"{label}_qualitative.json")
+    with open(out_path, "w") as f:
+        json.dump(output, f, indent=2)
+    print(f"\nSaved to {out_path}")
+    return output
+
+
+def main() -> None:
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+
+    configs = [
+        {
+            "model_path": os.path.join(RESULTS_DIR, "tf-gin-256-deep_decoder.pt"),
+            "label": "tf-gin-256-deep",
+            "hidden_dim": 256, "num_layers": 5,
+            "decoder_conv_type": "GIN", "decoder_edge_mode": "teacher_forced",
+        },
+        {
+            "model_path": os.path.join(RESULTS_DIR, "chain-gin-256_decoder.pt"),
+            "label": "chain-gin-256",
+            "hidden_dim": 256, "num_layers": 3,
+            "decoder_conv_type": "GIN", "decoder_edge_mode": "chain",
+        },
+    ]
+
+    all_results = []
+    for cfg in configs:
+        if not os.path.exists(cfg["model_path"]):
+            print(f"Skipping {cfg['label']}: no model at {cfg['model_path']}")
+            continue
+        result = evaluate_model_full(**cfg)
+        all_results.append(result)
+
+    print("\n" + "=" * 60)
+    print("FULL RECONSTRUCTION SUMMARY")
+    print("=" * 60)
+    for r in all_results:
+        print(f"  {r['label']:25s}: heuristic={r['heuristic_pct']:5.1f}%  "
+              f"syntax={r['syntax_pct']:5.1f}% ({r['syntax_valid']}/{r['total']})")
+
+
+if __name__ == "__main__":
+    main()