Upload folder using huggingface_hub

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/README.md

@@ -0,0 +1,5 @@
+# Issue 43 XCOMET Destructive MLP 95% Gate Artifacts
+
+This package contains restored issue #42 percentile damage inputs, cumulative MLP masks, NTREX generation dumps, XCOMET scores, summaries, and logs for the destructive <=5% recovery gate.
+
+Upstream HY-MT and XCOMET model weights are not included.

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_no_mask.json

@@ -0,0 +1,24 @@
+{
+  "model": "tencent/HY-MT1.5-1.8B",
+  "n_layers": 32,
+  "hidden_size": 2048,
+  "d_ffn": 6144,
+  "row_slice": {
+    "start_idx": 0,
+    "end_idx": 1012
+  },
+  "n_rows": 1012,
+  "results": {
+    "no_mask": {
+      "scores": {
+        "chrFpp": 54.224041106849185,
+        "chrF": 56.928538294695194,
+        "BLEU": 25.785229280531734,
+        "n": 1012
+      },
+      "elapsed_s": 120.06071972846985,
+      "dump_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/no_mask.jsonl",
+      "channels": 0
+    }
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_10.json

@@ -0,0 +1,26 @@
+{
+  "model": "tencent/HY-MT1.5-1.8B",
+  "n_layers": 32,
+  "hidden_size": 2048,
+  "d_ffn": 6144,
+  "row_slice": {
+    "start_idx": 0,
+    "end_idx": 1012
+  },
+  "n_rows": 1012,
+  "results": {
+    "percentile_top_10": {
+      "scores": {
+        "chrFpp": 2.023711437925785,
+        "chrF": 2.6477265882046366,
+        "BLEU": 0.002859284356231794,
+        "n": 1012
+      },
+      "elapsed_s": 488.18473625183105,
+      "dump_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_10.jsonl",
+      "channels": 19660,
+      "mask_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/selection/percentile/masks/percentile_top_10.full.npz",
+      "intervention": "nuke-zero"
+    }
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_15.json

@@ -0,0 +1,26 @@
+{
+  "model": "tencent/HY-MT1.5-1.8B",
+  "n_layers": 32,
+  "hidden_size": 2048,
+  "d_ffn": 6144,
+  "row_slice": {
+    "start_idx": 0,
+    "end_idx": 1012
+  },
+  "n_rows": 1012,
+  "results": {
+    "percentile_top_15": {
+      "scores": {
+        "chrFpp": 1.0764037131822992,
+        "chrF": 1.4352049509097324,
+        "BLEU": 0.0009640701642685707,
+        "n": 1012
+      },
+      "elapsed_s": 474.4585359096527,
+      "dump_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_15.jsonl",
+      "channels": 29491,
+      "mask_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/selection/percentile/masks/percentile_top_15.full.npz",
+      "intervention": "nuke-zero"
+    }
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_20.json

@@ -0,0 +1,26 @@
+{
+  "model": "tencent/HY-MT1.5-1.8B",
+  "n_layers": 32,
+  "hidden_size": 2048,
+  "d_ffn": 6144,
+  "row_slice": {
+    "start_idx": 0,
+    "end_idx": 1012
+  },
+  "n_rows": 1012,
+  "results": {
+    "percentile_top_20": {
+      "scores": {
+        "chrFpp": 2.4641771477317875,
+        "chrF": 2.6459489632437827,
+        "BLEU": 0.007639825625700025,
+        "n": 1012
+      },
+      "elapsed_s": 505.30048990249634,
+      "dump_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_20.jsonl",
+      "channels": 39321,
+      "mask_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/selection/percentile/masks/percentile_top_20.full.npz",
+      "intervention": "nuke-zero"
+    }
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_30.json

@@ -0,0 +1,26 @@
+{
+  "model": "tencent/HY-MT1.5-1.8B",
+  "n_layers": 32,
+  "hidden_size": 2048,
+  "d_ffn": 6144,
+  "row_slice": {
+    "start_idx": 0,
+    "end_idx": 1012
+  },
+  "n_rows": 1012,
+  "results": {
+    "percentile_top_30": {
+      "scores": {
+        "chrFpp": 3.1316565972832366,
+        "chrF": 4.172057644643041,
+        "BLEU": 0.0008254288439485306,
+        "n": 1012
+      },
+      "elapsed_s": 497.1354627609253,
+      "dump_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_30.jsonl",
+      "channels": 58982,
+      "mask_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/selection/percentile/masks/percentile_top_30.full.npz",
+      "intervention": "nuke-zero"
+    }
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_40.json

@@ -0,0 +1,26 @@
+{
+  "model": "tencent/HY-MT1.5-1.8B",
+  "n_layers": 32,
+  "hidden_size": 2048,
+  "d_ffn": 6144,
+  "row_slice": {
+    "start_idx": 0,
+    "end_idx": 1012
+  },
+  "n_rows": 1012,
+  "results": {
+    "percentile_top_40": {
+      "scores": {
+        "chrFpp": 2.0259324848441826,
+        "chrF": 2.701243313125577,
+        "BLEU": 0.000277549379833518,
+        "n": 1012
+      },
+      "elapsed_s": 493.63351464271545,
+      "dump_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_40.jsonl",
+      "channels": 78643,
+      "mask_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/selection/percentile/masks/percentile_top_40.full.npz",
+      "intervention": "nuke-zero"
+    }
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_50.json

@@ -0,0 +1,26 @@
+{
+  "model": "tencent/HY-MT1.5-1.8B",
+  "n_layers": 32,
+  "hidden_size": 2048,
+  "d_ffn": 6144,
+  "row_slice": {
+    "start_idx": 0,
+    "end_idx": 1012
+  },
+  "n_rows": 1012,
+  "results": {
+    "percentile_top_50": {
+      "scores": {
+        "chrFpp": 0.3801321408444973,
+        "chrF": 0.490406237031587,
+        "BLEU": 0.0033661885320217834,
+        "n": 1012
+      },
+      "elapsed_s": 513.6594152450562,
+      "dump_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_50.jsonl",
+      "channels": 98304,
+      "mask_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/selection/percentile/masks/percentile_top_50.full.npz",
+      "intervention": "nuke-zero"
+    }
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/build_ntrex.log

@@ -0,0 +1,6 @@
+
+NTREX-128 columns sample: ['sna_Latn', 'est_Latn', 'glg_Latn', 'bem_Latn', 'nob_Latn', 'zul_Latn', 'hye_Armn', 'nep_Deva'] ...
+NTREX-128 size: 1997 rows
+  src column: eng_Latn
+  tgt column: por_Latn
+wrote 1012 pairs -> /root/runs/ntrex_eval/ntrex_en2pt.jsonl

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_no_mask.log

@@ -0,0 +1,2 @@
+The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.
+{"name": "no_mask", "scores": {"chrFpp": 54.224041106849185, "chrF": 56.928538294695194, "BLEU": 25.785229280531734, "n": 1012}}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_10.log

@@ -0,0 +1,2 @@
+The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.
+{"name": "percentile_top_10", "channels": 19660, "scores": {"chrFpp": 2.023711437925785, "chrF": 2.6477265882046366, "BLEU": 0.002859284356231794, "n": 1012}}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_15.log

@@ -0,0 +1,2 @@
+The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.
+{"name": "percentile_top_15", "channels": 29491, "scores": {"chrFpp": 1.0764037131822992, "chrF": 1.4352049509097324, "BLEU": 0.0009640701642685707, "n": 1012}}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_20.log

@@ -0,0 +1,2 @@
+The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.
+{"name": "percentile_top_20", "channels": 39321, "scores": {"chrFpp": 2.4641771477317875, "chrF": 2.6459489632437827, "BLEU": 0.007639825625700025, "n": 1012}}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_30.log

@@ -0,0 +1,2 @@
+The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.
+{"name": "percentile_top_30", "channels": 58982, "scores": {"chrFpp": 3.1316565972832366, "chrF": 4.172057644643041, "BLEU": 0.0008254288439485306, "n": 1012}}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_40.log

@@ -0,0 +1,2 @@
+The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.
+{"name": "percentile_top_40", "channels": 78643, "scores": {"chrFpp": 2.0259324848441826, "chrF": 2.701243313125577, "BLEU": 0.000277549379833518, "n": 1012}}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_50.log

@@ -0,0 +1,2 @@
+The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.
+{"name": "percentile_top_50", "channels": 98304, "scores": {"chrFpp": 0.3801321408444973, "chrF": 0.490406237031587, "BLEU": 0.0033661885320217834, "n": 1012}}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/hf_download_issue42.log

@@ -0,0 +1,4 @@
+
+Download complete. Moving file to /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/restored/issue42/circuit-shotting/artifacts/percentile_proxy/issue42_percentile_proxy_20260518T110628Z/damage/percentile_results.jsonl
+
+/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/restored/issue42

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/issue43_progress.log

@@ -0,0 +1,23 @@
+[2026-05-18T11:47:45+00:00] issue43 start XCOMET destructive MLP gate gpus=0 1 2 3 top_ns=10,15,20,30,40,50 target=0.05
+[2026-05-18T11:47:45+00:00] build NTREX EN->PT held-out jsonl
+[2026-05-18T11:47:49+00:00] restore issue42 percentile damage results from HF
+[2026-05-18T11:47:50+00:00] build cumulative percentile masks through top 50
+[2026-05-18T11:48:03+00:00] generate NTREX hypotheses for no-mask and candidate nukes over 4 GPUs
+[2026-05-18T12:05:23+00:00] start 4 XCOMET services sequentially
+[2026-05-18T12:05:23+00:00] start XCOMET service idx=0 gpu=0 port=10001
+[2026-05-18T12:08:10+00:00] XCOMET service idx=0 healthy on port=10001
+[2026-05-18T12:08:10+00:00] start XCOMET service idx=1 gpu=1 port=10002
+[2026-05-18T12:11:12+00:00] XCOMET service idx=1 healthy on port=10002
+[2026-05-18T12:11:12+00:00] start XCOMET service idx=2 gpu=2 port=10003
+[2026-05-18T12:14:14+00:00] XCOMET service idx=2 healthy on port=10003
+[2026-05-18T12:14:14+00:00] start XCOMET service idx=3 gpu=3 port=10004
+[2026-05-18T12:17:16+00:00] XCOMET service idx=3 healthy on port=10004
+[2026-05-18T12:17:16+00:00] XCOMET score no_mask
+[2026-05-18T12:38:49+00:00] XCOMET score percentile_top_10
+[2026-05-18T13:01:32+00:00] XCOMET score percentile_top_15
+[2026-05-18T13:23:15+00:00] XCOMET score percentile_top_20
+[2026-05-18T13:47:42+00:00] XCOMET score percentile_top_30
+[2026-05-18T14:10:27+00:00] XCOMET score percentile_top_40
+[2026-05-18T14:33:38+00:00] XCOMET score percentile_top_50
+[2026-05-18T14:56:43+00:00] target recovery 0.05 not reached by scored candidates
+[2026-05-18T14:56:43+00:00] package and upload issue43 artifacts

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/nohup.log

@@ -0,0 +1,23 @@
+[2026-05-18T11:47:45+00:00] issue43 start XCOMET destructive MLP gate gpus=0 1 2 3 top_ns=10,15,20,30,40,50 target=0.05
+[2026-05-18T11:47:45+00:00] build NTREX EN->PT held-out jsonl
+[2026-05-18T11:47:49+00:00] restore issue42 percentile damage results from HF
+[2026-05-18T11:47:50+00:00] build cumulative percentile masks through top 50
+[2026-05-18T11:48:03+00:00] generate NTREX hypotheses for no-mask and candidate nukes over 4 GPUs
+[2026-05-18T12:05:23+00:00] start 4 XCOMET services sequentially
+[2026-05-18T12:05:23+00:00] start XCOMET service idx=0 gpu=0 port=10001
+[2026-05-18T12:08:10+00:00] XCOMET service idx=0 healthy on port=10001
+[2026-05-18T12:08:10+00:00] start XCOMET service idx=1 gpu=1 port=10002
+[2026-05-18T12:11:12+00:00] XCOMET service idx=1 healthy on port=10002
+[2026-05-18T12:11:12+00:00] start XCOMET service idx=2 gpu=2 port=10003
+[2026-05-18T12:14:14+00:00] XCOMET service idx=2 healthy on port=10003
+[2026-05-18T12:14:14+00:00] start XCOMET service idx=3 gpu=3 port=10004
+[2026-05-18T12:17:16+00:00] XCOMET service idx=3 healthy on port=10004
+[2026-05-18T12:17:16+00:00] XCOMET score no_mask
+[2026-05-18T12:38:49+00:00] XCOMET score percentile_top_10
+[2026-05-18T13:01:32+00:00] XCOMET score percentile_top_15
+[2026-05-18T13:23:15+00:00] XCOMET score percentile_top_20
+[2026-05-18T13:47:42+00:00] XCOMET score percentile_top_30
+[2026-05-18T14:10:27+00:00] XCOMET score percentile_top_40
+[2026-05-18T14:33:38+00:00] XCOMET score percentile_top_50
+[2026-05-18T14:56:43+00:00] target recovery 0.05 not reached by scored candidates
+[2026-05-18T14:56:43+00:00] package and upload issue43 artifacts

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/select_percentile_masks.log

@@ -0,0 +1,6 @@
+{
+  "top_n": 50,
+  "final_mix": "percentile_top_50",
+  "channels": 98304,
+  "out_dir": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/selection/percentile"
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/summarize_issue43.log

@@ -0,0 +1,5 @@
+{
+  "out_json": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/summaries/issue43_summary.json",
+  "out_md": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/summaries/issue43_summary.md",
+  "gate_passed": false
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_no_mask.log

@@ -0,0 +1,17 @@
+{
+  "out_json": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/xcomet/no_mask.json",
+  "summary": {
+    "source_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/no_mask.jsonl",
+    "comet_model": "Unbabel/XCOMET-XXL",
+    "checkpoint_path": "/root/.cache/huggingface/hub/models--Unbabel--XCOMET-XXL/snapshots/873bac1b1c461e410c4a6e379f6790d3d1c7c214/checkpoints/model.ckpt",
+    "n": 1012,
+    "threshold": 0.99,
+    "system_score": 0.9281014436671856,
+    "passed": 382,
+    "elapsed_seconds": 1293.3849756717682,
+    "batch_size": 1,
+    "chunk_size": 8,
+    "shard_count": 4,
+    "throughput_seg_per_s": 0.7824429835580732
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_10.log

@@ -0,0 +1,17 @@
+{
+  "out_json": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/xcomet/percentile_top_10.json",
+  "summary": {
+    "source_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_10.jsonl",
+    "comet_model": "Unbabel/XCOMET-XXL",
+    "checkpoint_path": "/root/.cache/huggingface/hub/models--Unbabel--XCOMET-XXL/snapshots/873bac1b1c461e410c4a6e379f6790d3d1c7c214/checkpoints/model.ckpt",
+    "n": 1012,
+    "threshold": 0.99,
+    "system_score": 0.18256553325603309,
+    "passed": 0,
+    "elapsed_seconds": 1362.0329356193542,
+    "batch_size": 1,
+    "chunk_size": 8,
+    "shard_count": 4,
+    "throughput_seg_per_s": 0.7430069951280501
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_15.log

@@ -0,0 +1,17 @@
+{
+  "out_json": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/xcomet/percentile_top_15.json",
+  "summary": {
+    "source_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_15.jsonl",
+    "comet_model": "Unbabel/XCOMET-XXL",
+    "checkpoint_path": "/root/.cache/huggingface/hub/models--Unbabel--XCOMET-XXL/snapshots/873bac1b1c461e410c4a6e379f6790d3d1c7c214/checkpoints/model.ckpt",
+    "n": 1012,
+    "threshold": 0.99,
+    "system_score": 0.2529226868034234,
+    "passed": 0,
+    "elapsed_seconds": 1303.2930221557617,
+    "batch_size": 1,
+    "chunk_size": 8,
+    "shard_count": 4,
+    "throughput_seg_per_s": 0.7764946038115651
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_20.log

@@ -0,0 +1,17 @@
+{
+  "out_json": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/xcomet/percentile_top_20.json",
+  "summary": {
+    "source_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_20.jsonl",
+    "comet_model": "Unbabel/XCOMET-XXL",
+    "checkpoint_path": "/root/.cache/huggingface/hub/models--Unbabel--XCOMET-XXL/snapshots/873bac1b1c461e410c4a6e379f6790d3d1c7c214/checkpoints/model.ckpt",
+    "n": 1012,
+    "threshold": 0.99,
+    "system_score": 0.19338692443559438,
+    "passed": 0,
+    "elapsed_seconds": 1466.9191575050354,
+    "batch_size": 1,
+    "chunk_size": 8,
+    "shard_count": 4,
+    "throughput_seg_per_s": 0.6898812343103803
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_30.log

@@ -0,0 +1,17 @@
+{
+  "out_json": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/xcomet/percentile_top_30.json",
+  "summary": {
+    "source_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_30.jsonl",
+    "comet_model": "Unbabel/XCOMET-XXL",
+    "checkpoint_path": "/root/.cache/huggingface/hub/models--Unbabel--XCOMET-XXL/snapshots/873bac1b1c461e410c4a6e379f6790d3d1c7c214/checkpoints/model.ckpt",
+    "n": 1012,
+    "threshold": 0.99,
+    "system_score": 0.189112861187974,
+    "passed": 0,
+    "elapsed_seconds": 1364.2606618404388,
+    "batch_size": 1,
+    "chunk_size": 8,
+    "shard_count": 4,
+    "throughput_seg_per_s": 0.7417937256583261
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_40.log

@@ -0,0 +1,17 @@
+{
+  "out_json": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/xcomet/percentile_top_40.json",
+  "summary": {
+    "source_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_40.jsonl",
+    "comet_model": "Unbabel/XCOMET-XXL",
+    "checkpoint_path": "/root/.cache/huggingface/hub/models--Unbabel--XCOMET-XXL/snapshots/873bac1b1c461e410c4a6e379f6790d3d1c7c214/checkpoints/model.ckpt",
+    "n": 1012,
+    "threshold": 0.99,
+    "system_score": 0.2072743144836056,
+    "passed": 0,
+    "elapsed_seconds": 1390.8875968456268,
+    "batch_size": 1,
+    "chunk_size": 8,
+    "shard_count": 4,
+    "throughput_seg_per_s": 0.7275929423971723
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_50.log

@@ -0,0 +1,17 @@
+{
+  "out_json": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/xcomet/percentile_top_50.json",
+  "summary": {
+    "source_path": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f/dumps/ntrex/percentile_top_50.jsonl",
+    "comet_model": "Unbabel/XCOMET-XXL",
+    "checkpoint_path": "/root/.cache/huggingface/hub/models--Unbabel--XCOMET-XXL/snapshots/873bac1b1c461e410c4a6e379f6790d3d1c7c214/checkpoints/model.ckpt",
+    "n": 1012,
+    "threshold": 0.99,
+    "system_score": 0.2053742483847226,
+    "passed": 0,
+    "elapsed_seconds": 1385.4018139839172,
+    "batch_size": 1,
+    "chunk_size": 8,
+    "shard_count": 4,
+    "throughput_seg_per_s": 0.7304739957505484
+  }
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/manifests/SHA256SUMS

@@ -0,0 +1,156 @@
+bf03e35db27513749409d858e713f1ef51f923abd5920fef087de4536e5f57c6  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/dumps/ntrex/no_mask.jsonl
+e4c27fbac5f60ba9e154ffe927ae03f20791e217b1d9738b9b51ae683f794e55  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/dumps/ntrex/percentile_top_10.jsonl
+2cdd46c4c57cc0817af81c94358e36e8bb4f43579322949623d2501382030404  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/dumps/ntrex/percentile_top_15.jsonl
+63a31568ca89897cb7bd484e72f17bedd8e16d85f097d916dce274debfb7c5fe  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/dumps/ntrex/percentile_top_20.jsonl
+1648e848ccd27150747ebdc76881a86e4f8c70b2da8fc1d7d5becf0484a3128f  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/dumps/ntrex/percentile_top_30.jsonl
+9eb493e8c1861a698fa21ad5d0f6f7db068a4f02eee469f0c981b79793c69194  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/dumps/ntrex/percentile_top_40.jsonl
+cd0f0e295c2b2b70ba3b54bbaf711308db319c2cfa3f4e0633f7f102b7f2f0e9  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/dumps/ntrex/percentile_top_50.jsonl
+1b4ef683f1089e4cd0ba8b8df4c7ca11390987a3e3135d55c3bdaeee255aa4b5  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_no_mask.json
+9580eabfc9f46a63a964ef4dbeff8d676fa8db814a267824624a1a33e0be5f8b  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_10.json
+81cc9cef22f4011d085a9d83b4389f70a807aec1451e79d15058a03f47567793  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_15.json
+15f3f451d6e3a3280b9d9f6480b0abb4b361975b831673f446cdaa8b4fbad7de  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_20.json
+e48acda7dc495a470be129f90276d0a4e698595ac10fd067669d172d15989f43  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_30.json
+4d337a64bf32dc7ed47cdfe5664cef78232826070b9a0c9a797c9cd1a423ae5e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_40.json
+f32eb6ec2a007a41ef9fef6f069619cb3f047513a3998ecc7993bb6ea7ef625d  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/eval/ntrex_percentile_top_50.json
+4bff1faaab87a6eabbed6d7b30a15c8f46ae29ecce69bedcc314a0a828721eb3  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/build_ntrex.log
+ed7583ebf37db02c54690bdbbaac912bf63900d3a2e676aeae768b6935756c08  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_no_mask.log
+fb2d734883aa003e4a686dbc7c0c097d0373625086bc6af1b68ce0ab33591862  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_10.log
+5b174d3f0cbe9051c4341bb49d8038c2babb9bdd476a48e8cff636cec567a31b  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_15.log
+dc78cdf39f737c15726508816c42fd3af86d446dd9ec67527fefe9390ecaa531  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_20.log
+aca0653b344477538a90d1ba3329687ddd51bf84764b470bcc50f074d67571c4  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_30.log
+dfb0c2fd6f665cd30bc83928dc0c625a9fe2ed1a18dfc8e7ceb21b4e397421a6  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_40.log
+19e3e62ec4849398c938268f4d1f3b4ff1d5727313543efa47fd6595c3f96906  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/eval_ntrex_percentile_top_50.log
+9a7e3fc70dfaae02d4d218f3c4f8ca860678b21bfd873d17b04b90706ae8d05d  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/hf_download_issue42.log
+a92e11642586654d7c009f34a234934dd5bd01ac6180e86fbb815aa95ef88b64  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/issue43_progress.log
+a92e11642586654d7c009f34a234934dd5bd01ac6180e86fbb815aa95ef88b64  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/nohup.log
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/package_issue43_hf_upload.log
+a2027fa025a2c5ee5429755301fbc875fc3074eeefbd6c381933b8ed5dc49ffc  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/select_percentile_masks.log
+8a96844569862f0c722918e6f66cec9678f590da04fbd4e6766296292425cc0b  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/summarize_issue43.log
+4b13ddc672704c8fe4ccfcf227f95760a63c0117739b6d52644bda36e5981f2e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_no_mask.log
+486ba93c6f6e8ec6add921d78b00d918696ca23c085dee3e0380829f978a2d1d  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_10.log
+8c55645dad49e6ab461140c118aa859d0ef22a020cc1ea2c5882f221a51f145c  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_15.log
+0d9f3fbc70fbf1e5d52e620d3f4b39075d735af48b87c269bbe28259a245f4e0  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_20.log
+983b18afd417007558f42fb0a1b6abb3f671dfc1a1d3e92035abeb68b19b7b86  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_30.log
+f664d90365b11c852e6a34f5c4a69eea55012da7454f4c3fd662f0b7cb6a5022  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_40.log
+3fbf697c27209bda0bb1f1b2fe60b10121726609488408f6ce151e7235f34630  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/logs/xcomet_percentile_top_50.log
+d6823fa3e74320bbae7433645b11ab1109489d73c6eafb08272d3af866bd4a4e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/manifests/SHA256SUMS
+684888c0ebb17f374298b65ee2807526c066094c701bcc7ebbe1c1095f494fc1  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/restored/issue42/.cache/huggingface/.gitignore
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/restored/issue42/.cache/huggingface/download/circuit-shotting/artifacts/percentile_proxy/issue42_percentile_proxy_20260518T110628Z/damage/percentile_results.jsonl.lock
+60b1fae66f3219f1b916b490fce08f36d74209ae7a19a445d37bb4bc52c43355  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/restored/issue42/.cache/huggingface/download/circuit-shotting/artifacts/percentile_proxy/issue42_percentile_proxy_20260518T110628Z/damage/percentile_results.jsonl.metadata
+dd945e5ed7f681cb522fb979401367a407a65b76560d8bc10375d974958f5b0c  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/restored/issue42/circuit-shotting/artifacts/percentile_proxy/issue42_percentile_proxy_20260518T110628Z/damage/percentile_results.jsonl
+66cf52044faf04ad1afa04e99e7249cae65b760d2f5ccddd7efd4057f328b3fc  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/actdelta_mlp_common.py
+a197f22e29b086f8e637982d26b762fd9e5dce2fb5b70bf8b68e3b08d4988d0d  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/build_ntrex_en2pt_jsonl.py
+6986306655c0c67c27934f87dd8cb4147756d45f1c93168cbfccad5c812f4ac2  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/evaluate_mlp_nuke_translation.py
+bf2c867b371954b03a0c559aae99aec9184f4d91fab28380314186e97ceb0877  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/issue43_xcomet_destructive_mlp_runner.sh
+00fd9564ec740ea851cfce4b1fe747b65ff8c496b6882c8a7fe9aa4c0c991b87  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/package_issue43_hf_upload.sh
+31a662571b9792487ba674810c6e545193b61214bc1951a65a2a5edd07def55b  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/score_xcomet_sharded.py
+1f4862a56ec1ccdf4cc8fc47d2c84aeae4baa90645ac0d6e22d28547b67f60bc  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/select_percentile_mlp_mix.py
+65a0b0fc8ce3fcd78752e78497d28653bffd0b7f50f51177ecc364282c12380b  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/summarize_issue43_xcomet_destructive_mlp.py
+59e5b31759fdc1b19c9f39edf8ed72f8c1a61b17930d8b7418892cc519481bc5  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/xcomet_service.py
+4f22910781440a38985ff19ce889e1757b11d9e8a62f4a114a2a4b8b8cb8589e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/cumulative_percentile_mixes.jsonl
+5c8d140828eefea1d2dd4565eb0a64a78b7c33381b1cdb37d83c6a00e17f723b  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_1.full.npz
+17f7a4853934f8dd8639d4deda4fa5124976a7cf52f7863762e27bbb9cbef577  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_10.full.npz
+d1faadfbb41b9770b56b674a0ceb1d6645fc75769053412c385835189ba007c8  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_11.full.npz
+f230209755b1201e62b116647467324e47d2f826793277f236fe14f9e7ba8da6  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_12.full.npz
+ab90f8e7b2a292f5fad5faa1585c79cd3064ec70cac815cfb095060d87475560  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_13.full.npz
+0024c3f3b86c937dec7fba9b4fb5caab382a035af41523de77699dcfc284bbc7  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_14.full.npz
+81d2fc2324e67f86e6d23a913de7c159dbe7b588e77460f0fa45df9e52564645  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_15.full.npz
+3ebcb44ab4282429b283f9bfb15a2a21ca9f2e595fde05968e6ad223e995b802  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_16.full.npz
+17c43e70cc13ff5e8534210ebf19a7bc1d878fa05b310dac2a966992e94e65d9  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_17.full.npz
+627f7ec469c3c825725d9a31e4b6078601e25bcba1ca5a4d1111359fa88dd3b5  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_18.full.npz
+677336ea8ba1a06b3f6a3c47bec76caa36647963b31b761c2b4c8fe6ce171fc8  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_19.full.npz
+b6b1652ddd55f816922d4dc6cec11ea2320aeb96acc63e8788307ac311783149  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_2.full.npz
+a82f3092f3039a04e117072bd32595d27ae7e24a6fc3c183d6b5caf9aa5080a1  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_20.full.npz
+74719057a36ed06a293f9f9efdfaed45d85aa6a3aa9954843b14d8d486a53ef6  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_21.full.npz
+7438d493c049547171c635bb0edd9535358231e11fadf55c76eac13776775718  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_22.full.npz
+675209220e2b35338fa3ac5a49f5cde1bbeceea08ab06db8d25036b6ed71b1f7  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_23.full.npz
+1f126f38f1b9e8c3b38df1a91edec94d21d42e3c51e24e8d4364f39e3127cffa  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_24.full.npz
+4434c72fe48518425d81be74b7c9f1f6f7916b80af85c0c0eb72178712e3224c  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_25.full.npz
+ea5640917e9c5a92a3bd3c45aa25e067a180fc4705054de549fffe2009aa4a18  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_26.full.npz
+b7056c26479fba2d5158d2c5d432f5a2f8c62b94bb2b21244ced4fdbe4ae32af  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_27.full.npz
+a2f329416585f756d6ac71e28a594f559110108ab9054403a2552e1baf910541  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_28.full.npz
+2aadcb6995549350ba5a230b6fdb3d7ff5f10f81b36603668b83a75f53b29a38  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_29.full.npz
+de5cb7822203180456edf209db34b7109028056c207d24877d17a87bbdd308a7  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_3.full.npz
+354c52928f404b2de9bb804c6487a2f05904492323e950e84d6d0dbaa47f3f00  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_30.full.npz
+e9b46fd6a1324036a6a015bab112dbc484378a8f1345dc444f75e79c50da6954  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_31.full.npz
+ec7bb63f8c500d3fac7ae8c8a002aa039f6c7a16f25ef18f806844e96d81dbf8  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_32.full.npz
+cebe62766804d5ae0effd998c592492d90e0ab890e05fe9772804d8176f31f76  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_33.full.npz
+481852b4577cf5f5e5364fb8137c7caa6081ccf3d8bdd28d3d628e5e8444f5a3  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_34.full.npz
+59d410cb15bd754af8e4723f183de6077def99beb59e24070051aca0619f3b05  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_35.full.npz
+c5fd2dbceeac7bec00a7143f8ce94ef35ace529240129b89f5595230edcd3521  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_36.full.npz
+d5bb34560b3a388e05d398dbeed580148641156ba0212e1870c65cfbce8c02cf  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_37.full.npz
+057f70177328bfdad742d42f39dbf434707f8eae9052ff76f912a9c0fe14a285  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_38.full.npz
+b3849bd3077f8233c89caa7100bbdb4adf132f1d6a3732c5845bf5bd628c4a4f  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_39.full.npz
+a7f79c8a23373952cd3935d884cce05df8129617814fd5f9326b07e9084d51a0  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_4.full.npz
+167e27856a5c8c9f815da2dabbac641377283dee7be53a520d69fcf9e01c698e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_40.full.npz
+20571cdfb7f44a0dadfeb549722b0a8bed5f6f243199b2b38a68c0d63cb349db  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_41.full.npz
+4476b82ae250966876383ef21fa881508d55473f91905e4d56840aab17b2e5cb  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_42.full.npz
+2451ad932683d8df2b26555432b66210ba6ebbbf3c427e74222844e2ae3f0110  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_43.full.npz
+0457b7531724466793b42f9404563102b4c3a5ae8e4de43d46d15bec690e2f0d  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_44.full.npz
+fb6cdd69de1bab002ec84844ba7d5eab25c9376bdb48fbcba3608f3b06e716a0  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_45.full.npz
+e65373edb08ccffcf22f22b97c8f08e20d6cb26935b1af13d9e72ced14e4406b  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_46.full.npz
+95b7874a2d5a03e2699057ccecdbb6488ed12826a7ef80014daf7fdb77ef0eb8  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_47.full.npz
+91779723996b2950ac9155050bc5fd095731014a0b144a42560eff57b8137075  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_48.full.npz
+d80ea0110b439434a459f45bcbb0c8e58b6a935b352e7921f7506c00b7287c2a  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_49.full.npz
+91db480bef3c2d90e6a328388e8ff7a3eea37d1daa20dede217e8f17cedba684  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_5.full.npz
+4ba7c4273f45d2aff93fea932498705c1c35562fe3d6b10683afc497f4b4f9fc  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_50.full.npz
+976c5b4e4ef988ecb5deeb5dd8757dd55ac3c4a73cd3c99ffac69d028b0a5344  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_6.full.npz
+a8db5459270a6e49d25bc3851b66eadac6a14b2f14bf88f72fa98f00fa97fa0a  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_7.full.npz
+3fdf1d3adce3b0c10b0a336ed92d1fb46a5aa886810966d1ee439a388ef27107  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_8.full.npz
+bbbfe35c68966ab423fc5e02bcf50ba7e05c373ffb11c2a9a40e726150e2508c  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_9.full.npz
+c23669745250b3d2e42175ca87fe488a0e02e0b62df7b4cf9c8e59f077699d4e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/ranked_percentiles.jsonl
+32fce4ab5b52ffcf073a03751aae372139ffee8f7ab90cf3d2193251351a60b4  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/selection_summary.json
+29520c3c91d5b84b3a09a427143946fa44dea0cdf353f0cb13b7646b45ea8fb5  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/scored_candidate_names.txt
+8dcdeb8cb722edac2fefa43d630b8cda8d3cdc7753bcd364b9d1d783e5d37470  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/services/xcomet_0/health.json
+67a7cad6dce93e577f4b52ebba936cc02c8bfda892e3f34126a042b6d0baade5  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/services/xcomet_0/service.log
+1273f6bfd4aeed397577e989d0bfd6648554361ae737dfd07dfe69e20d65f694  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/services/xcomet_1/health.json
+91a2577d397aca4b7043aeb8f5a5b3ceba483bcbedebd652189ffa96798fba64  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/services/xcomet_1/service.log
+af08ac8453219c2b017faf7e1acf67366f3a01e07fac341a65041d1c11536537  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/services/xcomet_2/health.json
+267a155c763505d50cb0e6c799acc282ad30292d5e5309fd78c6253adcb0aea5  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/services/xcomet_2/service.log
+9865ee9d76bd567aec86d9ce3a760b83f83811a0503137da3a4c0c38ca667e68  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/services/xcomet_3/health.json
+c64f00da643fbbf2742cee2c11a6b6774a95817157df8d75c58c486c133967f9  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/services/xcomet_3/service.log
+9dd8f6e8ce2e726be8c81f945a941dee17fb57a1ccd1de31386ede9436cd1bb0  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/spec/issue43_xcomet_destructive_mlp_95.json
+cdf6da89b51de1b46ea8dcbddb8d94fef1dee2cbd0191617492253db202bcc22  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/summaries/issue43_summary.json
+53704cb9dd95b4cfadc0e774a186cd2d9601e762920c36825c3ef6eb54cd79fe  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/summaries/issue43_summary.md
+72b66ea94a79b14a84b6bcb07496a5e283a591ae3826bea3b1b8e4e80b2b2370  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/no_mask.json
+a89fffa1159a8a15c69f59cb471558b979fc67fd24c4941b7734e83ce8184808  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/no_mask.scored_pool.jsonl
+8fbbb547210aa768978ceef5465cb83cd121d73431eb0ac3687e8ec434b49a8e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_10.json
+821689c3afd4fe7c3a5e3580f4e902603537fac00157d97c26ea9f04cb4c11f1  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_10.scored_pool.jsonl
+2f574b71134ad16eaf7e223f17c9e53d76cb387f702c794a93daf9a12331158e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_15.json
+19d6092bf78e3fe52a063d64865a15a573f2df0f3937c440d93ce136604f2687  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_15.scored_pool.jsonl
+8d8c8f9143aac3026718887a2da067981fa1778fe125aadd89aacd079d4bac69  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_20.json
+2dee4ea2c88cdf70a0e9c9b6d598d68b80bbf07a15a023e72cdef9a8f892ea8c  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_20.scored_pool.jsonl
+6cfe391ef3df9c430f225f34f1e7439e4abe9a1b98848291e7568851e4ab735b  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_30.json
+701c412978268ee2b0b04da294eb56b58b1123d11d62165b7e07ff1c255493e9  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_30.scored_pool.jsonl
+098320152d96efb8285905dd3ab2e12365d3ef425a82de3f1ea0c37283915328  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_40.json
+5d3d801ac701eeff3acc2b842e47b157de5a6d2915a6e45a68ffffc00e7a3651  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_40.scored_pool.jsonl
+0474fb737a5376ff4c3160f0e5109397fd73c5c1e4d344584d5b0358e5314816  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_50.json
+c4b7ccea505da4fb4f2ad72ae29950f6a8d6095b63db77226f3969ed6ea9b159  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet/percentile_top_50.scored_pool.jsonl
+d030b00f9b46fe19739abc996bf23b2b45dd9cbb5c7d51a33d1049ece3ab2839  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/no_mask/shard_000.jsonl
+32b1e0ab478400d1bb2c559b408fb5aa7c597a55a8be5cc970b132b9d27251d2  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/no_mask/shard_001.jsonl
+4702c0ce4c54d104a525e5e1d3d6bb76c30227316daee9ea21fcb774d15cfb7f  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/no_mask/shard_002.jsonl
+e2b0b47f5bf3dd02168e37fbc7333b31c209b07d3b2e386e7e9d001c6274fa0a  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/no_mask/shard_003.jsonl
+fb88d62a3179000b60ea39929c1130a93c7264b707f0b64acf872bf432a95382  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_10/shard_000.jsonl
+83007298cc8773c5d780d557365ed6638ca033b98f2c0aec4e70c4e99ee16567  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_10/shard_001.jsonl
+5db8be6ab00eb9a0a388493bdc03fd720236b0682eabcafafe944c51cc26bd8e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_10/shard_002.jsonl
+b9a07b6c03d282caf1d6b6e09a544341369b58c65006801530134d66e89fc894  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_10/shard_003.jsonl
+5efa75f7f99adf5ac8853256a0ebb21ec2ffd3ce440ba7fb560086613a8967f7  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_15/shard_000.jsonl
+42ada2b08fa04f4e4e2a9510529fb12953aec4fee1166d4352581e5374fc03d7  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_15/shard_001.jsonl
+3dd4e44508b879ff543aff3538119534a2e99854200869da8e26f5ebd19cc5e4  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_15/shard_002.jsonl
+a62dfd04a459a9461477ee69ef0208140ee6f2549e217822d382df8d92855e1f  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_15/shard_003.jsonl
+3a940d7d4580900319b224f2c958a9ec1dfc3b7ece98a893ee24e15fbdcca3a5  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_20/shard_000.jsonl
+3768f1ecf04f6b7a61bb42cd38c4b7292c4118cdffe71a72be2298c5f4d5e5ce  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_20/shard_001.jsonl
+7915f91d85f2c0fb5da84e1b896e07bcca38e9c507a3ec29ed7bf047c5a880b5  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_20/shard_002.jsonl
+c68b062b29275272dc1a008406943e9ff45b18db62feb84e8a7558d9457e74b6  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_20/shard_003.jsonl
+e28ca48003ea9be16fafe40dfa826da2bf84907d001dc5d876d96d3682c7b7d0  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_30/shard_000.jsonl
+e040bdb8c1d0ecbe1d0fbd14bb960f6cfb61ad8ce298092972e23749681bbde6  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_30/shard_001.jsonl
+7b8f6de5990de040c5de5fec3cab323e8107d8a2899f353dd726b8a160a32b6a  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_30/shard_002.jsonl
+22cd35c1179e20b2f2267fc81142fd6bd54db978280ed370a0d000f891ac9a7c  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_30/shard_003.jsonl
+26a6990df9efad918f6e9a82cc82ec581c6f468d20527ed9604c1264ac9ebd67  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_40/shard_000.jsonl
+3669717be70bbc2cd0b724292e1e4c08e997839fd600627b4084d569333d9f4e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_40/shard_001.jsonl
+be25af1409f2e28ba98a4749b0685393bca8bd941d4b8803d8d0e62aa2ac23f9  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_40/shard_002.jsonl
+a5e57a349474cf83ef15263d7de772d72b861374ed509cbb0093d649556e22a2  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_40/shard_003.jsonl
+69067d66f32aebda09bf894d76018b930b3173e85a78e11584ac4f25add9f5f3  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_50/shard_000.jsonl
+755ebbfc08943794a73dd87d2918e534d4048b78c451a1e10a3bff9a518b4dc2  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_50/shard_001.jsonl
+1b5b15f3b407d90a6eeeff44cc2fea085aeb94e380d3505e54dfc2d95e23d5dd  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_50/shard_002.jsonl
+7df04fa406a768952c782ad4cdf85f3d50fdb4cd91877963f1fa3f23291d383e  /root/runs/issue43_xcomet_destructive_mlp_95_038f04f/package/issue43_xcomet_destructive_mlp_95_20260518T145643Z/xcomet_shards/percentile_top_50/shard_003.jsonl

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/manifests/manifest.json

@@ -0,0 +1,7 @@
+{
+  "upload_prefix": "issue43_xcomet_destructive_mlp_95_20260518T145643Z",
+  "run_root": "/root/runs/issue43_xcomet_destructive_mlp_95_038f04f",
+  "file_count": 156,
+  "bytes": 39404709,
+  "weights_policy": "Includes experiment masks, generated hypotheses, XCOMET summaries/scored rows, scripts, specs, and logs. Excludes upstream HY-MT/XCOMET weights, HF caches, API keys, and service tokens."
+}

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/actdelta_mlp_common.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Shared helpers for ActDeltaLoRA MLP MVC experiments."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from translation_io import DEFAULT_PROMPT_STYLE, Pair, load_flores_devtest_any
+from translation_region_student import (
+    collate_translation,
+    decoder_root,
+    encode_supervised_row,
+    load_mask_npz,
+    save_mask_npz,
+    text_config,
+)
+
+
+@dataclass(frozen=True)
+class Candidate:
+    name: str
+    ranges: tuple[tuple[int, int], ...]
+    meta: dict[str, Any]
+
+
+def dtype_from_name(name: str) -> torch.dtype:
+    return {
+        "float32": torch.float32,
+        "float16": torch.float16,
+        "bfloat16": torch.bfloat16,
+    }[name]
+
+
+def mlp_total(n_layers: int, d_ffn: int) -> int:
+    return int(n_layers) * int(d_ffn)
+
+
+def flat_to_layer_channel(flat_idx: int, d_ffn: int) -> tuple[int, int]:
+    return int(flat_idx) // int(d_ffn), int(flat_idx) % int(d_ffn)
+
+
+def sector_ranges(total: int, sectors: int) -> list[tuple[int, int]]:
+    return [
+        (int(total * i // sectors), int(total * (i + 1) // sectors))
+        for i in range(sectors)
+    ]
+
+
+def split_range(start: int, end: int, parts: int) -> list[tuple[int, int]]:
+    size = end - start
+    return [
+        (start + int(size * i // parts), start + int(size * (i + 1) // parts))
+        for i in range(parts)
+    ]
+
+
+def normalize_ranges(ranges: Iterable[tuple[int, int]]) -> tuple[tuple[int, int], ...]:
+    out = []
+    for start, end in ranges:
+        start = int(start)
+        end = int(end)
+        if end > start:
+            out.append((start, end))
+    return tuple(out)
+
+
+def mask_from_ranges(ranges: Iterable[tuple[int, int]], n_layers: int,
+                     d_ffn: int) -> dict[int, torch.Tensor]:
+    mask = {layer: torch.zeros(d_ffn, dtype=torch.bool) for layer in range(n_layers)}
+    total = mlp_total(n_layers, d_ffn)
+    for raw_start, raw_end in ranges:
+        start = max(0, int(raw_start))
+        end = min(total, int(raw_end))
+        for flat in range(start, end):
+            layer, channel = flat_to_layer_channel(flat, d_ffn)
+            mask[layer][channel] = True
+    return mask
+
+
+def count_mask(mask: dict[int, torch.Tensor]) -> int:
+    return int(sum(int(v.sum().item()) for v in mask.values()))
+
+
+def mask_to_ranges(mask: dict[int, torch.Tensor], d_ffn: int) -> list[tuple[int, int]]:
+    flats: list[int] = []
+    for layer, values in sorted(mask.items()):
+        idx = torch.nonzero(values.cpu(), as_tuple=False).flatten().tolist()
+        flats.extend([int(layer) * d_ffn + int(i) for i in idx])
+    if not flats:
+        return []
+    flats.sort()
+    ranges: list[tuple[int, int]] = []
+    start = prev = flats[0]
+    for flat in flats[1:]:
+        if flat == prev + 1:
+            prev = flat
+            continue
+        ranges.append((start, prev + 1))
+        start = prev = flat
+    ranges.append((start, prev + 1))
+    return ranges
+
+
+def load_candidate_jsonl(path: str | Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with Path(path).open() as f:
+        for line in f:
+            if line.strip():
+                rows.append(json.loads(line))
+    return rows
+
+
+def write_jsonl(path: str | Path, rows: Iterable[dict[str, Any]]) -> None:
+    out = Path(path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    with out.open("w") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def load_pairs(path: str | None, *, src_lang: str = "eng_Latn",
+               tgt_lang: str = "por_Latn", max_rows: int | None = None) -> list[Pair]:
+    if path is None:
+        return load_flores_devtest_any(
+            src_lang=src_lang,
+            tgt_lang=tgt_lang,
+            max_examples=max_rows,
+        )
+    rows: list[Pair] = []
+    with Path(path).open() as f:
+        for line in f:
+            if not line.strip():
+                continue
+            raw = json.loads(line)
+            src = (raw.get("en") or raw.get("src") or "").strip()
+            tgt = (raw.get("model_hyp") or raw.get("pt") or raw.get("tgt") or "").strip()
+            if src and tgt:
+                rows.append(Pair(src=src, tgt=tgt))
+                if max_rows is not None and len(rows) >= max_rows:
+                    break
+    return rows
+
+
+def build_supervised_examples(pairs: list[Pair], tokenizer, *, target_language: str,
+                              prompt_style: str = DEFAULT_PROMPT_STYLE,
+                              max_seq_length: int = 1024) -> list[dict[str, Any]]:
+    examples: list[dict[str, Any]] = []
+    for pair in pairs:
+        row = {"en": pair.src, "target": pair.tgt, "raw": {"en": pair.src, "pt": pair.tgt}}
+        enc = encode_supervised_row(
+            row,
+            tokenizer,
+            target_language=target_language,
+            prompt_style=prompt_style,
+            max_seq_length=max_seq_length,
+            kl_on="answer",
+        )
+        if enc is not None:
+            examples.append(enc)
+    return examples
+
+
+def iter_batches(examples: list[dict[str, Any]], *, batch_size: int, pad_id: int):
+    for start in range(0, len(examples), batch_size):
+        yield collate_translation(examples[start:start + batch_size], pad_id)
+
+
+def move_batch(batch: dict[str, Any], device: str) -> dict[str, Any]:
+    return {k: v.to(device) if torch.is_tensor(v) else v for k, v in batch.items()}
+
+
+def tokenwise_kl(teacher_logits: torch.Tensor, student_logits: torch.Tensor,
+                 logit_mask: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    mask = logit_mask[:, :-1]
+    t_logits = teacher_logits[:, :-1, :]
+    s_logits = student_logits[:, :-1, :]
+    log_t = F.log_softmax(t_logits, dim=-1)
+    prob_t = log_t.exp()
+    log_s = F.log_softmax(s_logits, dim=-1)
+    kl = (prob_t * (log_t - log_s)).sum(dim=-1)
+    return kl, mask
+
+
+def sentence_kl_values(teacher_logits: torch.Tensor, student_logits: torch.Tensor,
+                       logit_mask: torch.Tensor) -> list[float]:
+    kl, mask = tokenwise_kl(teacher_logits, student_logits, logit_mask)
+    values: list[float] = []
+    for row_idx in range(kl.shape[0]):
+        row_mask = mask[row_idx]
+        if bool(row_mask.any().item()):
+            values.append(float(kl[row_idx][row_mask].mean().detach().cpu().item()))
+        else:
+            values.append(0.0)
+    return values
+
+
+def install_mlp_nuke_hooks(model, nuke_mask: dict[int, torch.Tensor],
+                           *, device: str, dtype: torch.dtype) -> list[Any]:
+    hooks: list[Any] = []
+    root = decoder_root(model)
+    for layer_idx, layer in enumerate(root.layers):
+        selected = nuke_mask[layer_idx].to(device)
+        if not bool(selected.any().item()):
+            continue
+        keep = (~selected).to(dtype=dtype).view(1, 1, -1)
+
+        def make_hook(keep: torch.Tensor):
+            def hook_fn(module, hook_args):
+                act = hook_args[0]
+                return (act * keep,) + hook_args[1:]
+            return hook_fn
+
+        hooks.append(layer.mlp.down_proj.register_forward_pre_hook(make_hook(keep)))
+    return hooks
+
+
+def install_mlp_keep_only_hooks(model, keep_mask: dict[int, torch.Tensor],
+                                *, device: str, dtype: torch.dtype) -> list[Any]:
+    """Keep selected MLP down-proj input channels and zero every other MLP channel."""
+    hooks: list[Any] = []
+    root = decoder_root(model)
+    for layer_idx, layer in enumerate(root.layers):
+        keep = keep_mask[layer_idx].to(device=device, dtype=dtype).view(1, 1, -1)
+
+        def make_hook(keep: torch.Tensor):
+            def hook_fn(module, hook_args):
+                act = hook_args[0]
+                return (act * keep,) + hook_args[1:]
+            return hook_fn
+
+        hooks.append(layer.mlp.down_proj.register_forward_pre_hook(make_hook(keep)))
+    return hooks
+
+
+def save_mask_for_candidate(out_dir: Path, candidate: Candidate, n_layers: int,
+                            d_ffn: int) -> str:
+    mask = mask_from_ranges(candidate.ranges, n_layers, d_ffn)
+    path = out_dir / f"{candidate.name}.full.npz"
+    save_mask_npz(path, mask)
+    return str(path)
+
+
+def model_mlp_shape(model) -> tuple[int, int, int]:
+    cfg = text_config(model)
+    return int(cfg.num_hidden_layers), int(cfg.hidden_size), int(cfg.intermediate_size)

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/build_ntrex_en2pt_jsonl.py

@@ -0,0 +1,35 @@
+"""Dump NTREX-128 en->pt to a jsonl for our gen+score pipeline.
+Truncates to 1012 rows to match the FLORES devtest size for apples-to-apples."""
+import json, sys
+from pathlib import Path
+from datasets import load_dataset
+
+ds = load_dataset("mteb/NTREX", split="test")
+print(f"NTREX-128 columns sample: {list(ds.column_names)[:8]} ...")
+print(f"NTREX-128 size: {len(ds)} rows")
+
+# Find en + pt column names
+src_col = next((c for c in ds.column_names if c == "eng" or c == "eng_Latn" or c == "en"), None)
+tgt_col = next((c for c in ds.column_names if c == "por" or c == "por_Latn" or c == "pt" or c == "por-BR" or c == "por_BR" or c == "por-PT"), None)
+print(f"  src column: {src_col}")
+print(f"  tgt column: {tgt_col}")
+
+assert src_col and tgt_col, f"Could not auto-detect en/pt columns. Available: {ds.column_names}"
+
+pairs = []
+for row in ds:
+    s, t = row.get(src_col), row.get(tgt_col)
+    if not s or not t:
+        continue
+    pairs.append((s.strip(), t.strip()))
+    if len(pairs) >= 1012:
+        break
+
+out = Path("/root/runs/ntrex_eval/ntrex_en2pt.jsonl")
+out.parent.mkdir(parents=True, exist_ok=True)
+with open(out, "w") as f:
+    for i, (en, pt) in enumerate(pairs):
+        f.write(json.dumps({"id": i, "en": en, "pt": pt,
+                            "category": "ntrex_test", "tag": "heldout"},
+                           ensure_ascii=False) + "\n")
+print(f"wrote {len(pairs)} pairs -> {out}")

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/evaluate_mlp_nuke_translation.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""Evaluate HY-MT EN->PT generation with selected MLP channels zero-nuked."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import sacrebleu
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from actdelta_mlp_common import (
+    count_mask,
+    dtype_from_name,
+    install_mlp_keep_only_hooks,
+    install_mlp_nuke_hooks,
+    load_pairs,
+    model_mlp_shape,
+)
+from translation_io import DEFAULT_PROMPT_STYLE, generate_translations
+from translation_region_student import load_mask_npz
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--model", default="tencent/HY-MT1.5-1.8B")
+    p.add_argument("--mask", action="append", default=[], metavar="NAME:PATH")
+    p.add_argument("--out-json", required=True)
+    p.add_argument("--dump-dir", required=True)
+    p.add_argument("--input-jsonl", default=None)
+    p.add_argument("--max-rows", type=int, default=None)
+    p.add_argument("--start-idx", type=int, default=0)
+    p.add_argument("--end-idx", type=int, default=None)
+    p.add_argument("--batch-size", type=int, default=32)
+    p.add_argument("--max-new-tokens", type=int, default=384)
+    p.add_argument("--target-language", default="Portuguese")
+    p.add_argument("--prompt-style", default=DEFAULT_PROMPT_STYLE)
+    p.add_argument("--src-lang", default="eng_Latn")
+    p.add_argument("--tgt-lang", default="por_Latn")
+    p.add_argument("--device", default="cuda")
+    p.add_argument("--dtype", default="bfloat16", choices=["float32", "float16", "bfloat16"])
+    p.add_argument("--include-no-mask", action="store_true")
+    p.add_argument("--intervention", default="nuke-zero", choices=["nuke-zero", "keep-only"],
+                   help="nuke-zero zeros selected channels; keep-only zeros every non-selected MLP channel.")
+    p.add_argument("--category", default="actdelta_eval")
+    p.add_argument("--tag", default="heldout")
+    return p.parse_args()
+
+
+def parse_mask_specs(values: list[str]) -> list[tuple[str, Path]]:
+    out = []
+    for value in values:
+        if ":" not in value:
+            raise ValueError(f"--mask must be NAME:PATH, got {value!r}")
+        name, path = value.split(":", 1)
+        out.append((name, Path(path)))
+    return out
+
+
+def dump_hyps(path: Path, pairs, hyps: list[str], *, mask_name: str, extra: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w") as f:
+        for idx, (pair, hyp) in enumerate(zip(pairs, hyps)):
+            f.write(json.dumps({
+                "id": idx,
+                "en": pair.src,
+                "pt": pair.tgt,
+                "model_hyp": hyp,
+                "category": extra.get("category", "actdelta_eval"),
+                "tag": extra.get("tag", "heldout"),
+                "mask_name": mask_name,
+                **{k: v for k, v in extra.items() if k not in {"category", "tag"}},
+            }, ensure_ascii=False) + "\n")
+
+
+def score(hyps: list[str], refs: list[str]) -> dict:
+    return {
+        "chrFpp": float(sacrebleu.corpus_chrf(hyps, [refs], word_order=2).score),
+        "chrF": float(sacrebleu.corpus_chrf(hyps, [refs], word_order=0).score),
+        "BLEU": float(sacrebleu.corpus_bleu(hyps, [refs]).score),
+        "n": len(hyps),
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    dtype = dtype_from_name(args.dtype)
+    out_path = Path(args.out_json)
+    dump_dir = Path(args.dump_dir)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    dump_dir.mkdir(parents=True, exist_ok=True)
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    model = AutoModelForCausalLM.from_pretrained(
+        args.model,
+        dtype=dtype,
+        attn_implementation="eager",
+    ).to(args.device).eval()
+    model.config.use_cache = True
+    for param in model.parameters():
+        param.requires_grad_(False)
+
+    n_layers, hidden_size, d_ffn = model_mlp_shape(model)
+    all_pairs = load_pairs(
+        args.input_jsonl,
+        src_lang=args.src_lang,
+        tgt_lang=args.tgt_lang,
+        max_rows=None,
+    )
+    end_idx = args.end_idx if args.end_idx is not None else len(all_pairs)
+    pairs = all_pairs[args.start_idx:end_idx]
+    if args.max_rows is not None:
+        pairs = pairs[:args.max_rows]
+    sources = [pair.src for pair in pairs]
+    refs = [pair.tgt for pair in pairs]
+
+    results = {}
+    if args.include_no_mask:
+        t0 = time.time()
+        hyps = generate_translations(
+            model,
+            tokenizer,
+            sources,
+            target_language=args.target_language,
+            prompt_style=args.prompt_style,
+            batch_size=args.batch_size,
+            max_new_tokens=args.max_new_tokens,
+            do_sample=False,
+            device=args.device,
+        )
+        scores = score(hyps, refs)
+        dump_path = dump_dir / "no_mask.jsonl"
+        dump_hyps(dump_path, pairs, hyps, mask_name="no_mask",
+                  extra={"category": args.category, "tag": args.tag, "method": "no_mask"})
+        results["no_mask"] = {
+            "scores": scores,
+            "elapsed_s": time.time() - t0,
+            "dump_path": str(dump_path),
+            "channels": 0,
+        }
+        print(json.dumps({"name": "no_mask", "scores": scores}), flush=True)
+
+    for name, mask_path in parse_mask_specs(args.mask):
+        mask = load_mask_npz(mask_path, n_layers, d_ffn)
+        channels = count_mask(mask)
+        t0 = time.time()
+        if args.intervention == "nuke-zero":
+            hooks = install_mlp_nuke_hooks(model, mask, device=args.device, dtype=dtype)
+            method = "mlp_nuke_zero"
+        else:
+            hooks = install_mlp_keep_only_hooks(model, mask, device=args.device, dtype=dtype)
+            method = "mlp_keep_only_zero"
+        try:
+            hyps = generate_translations(
+                model,
+                tokenizer,
+                sources,
+                target_language=args.target_language,
+                prompt_style=args.prompt_style,
+                batch_size=args.batch_size,
+                max_new_tokens=args.max_new_tokens,
+                do_sample=False,
+                device=args.device,
+            )
+        finally:
+            for hook in hooks:
+                hook.remove()
+        scores = score(hyps, refs)
+        dump_path = dump_dir / f"{name}.jsonl"
+        dump_hyps(
+            dump_path,
+            pairs,
+            hyps,
+            mask_name=name,
+            extra={
+                "category": args.category,
+                "tag": args.tag,
+                "method": method,
+                "intervention": args.intervention,
+                "channels": channels,
+                "mask_path": str(mask_path),
+            },
+        )
+        results[name] = {
+            "scores": scores,
+            "elapsed_s": time.time() - t0,
+            "dump_path": str(dump_path),
+            "channels": channels,
+            "mask_path": str(mask_path),
+            "intervention": args.intervention,
+        }
+        print(json.dumps({"name": name, "channels": channels, "scores": scores}), flush=True)
+
+    payload = {
+        "model": args.model,
+        "n_layers": n_layers,
+        "hidden_size": hidden_size,
+        "d_ffn": d_ffn,
+        "row_slice": {"start_idx": args.start_idx, "end_idx": end_idx},
+        "n_rows": len(pairs),
+        "results": results,
+    }
+    out_path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+
+
+if __name__ == "__main__":
+    main()

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/issue43_xcomet_destructive_mlp_runner.sh

@@ -0,0 +1,326 @@
+#!/usr/bin/env bash
+# Issue #43: XCOMET-confirm destructive MLP mining to <=5% recovery.
+set -euo pipefail
+
+export TOKENIZERS_PARALLELISM="${TOKENIZERS_PARALLELISM:-false}"
+export TORCH_ALLOW_TF32_CUBLAS_OVERRIDE="${TORCH_ALLOW_TF32_CUBLAS_OVERRIDE:-1}"
+
+REPO_DIR="${REPO_DIR:-/root/work/circuit-shotting}"
+cd "$REPO_DIR"
+
+MODEL="${MODEL:-tencent/HY-MT1.5-1.8B}"
+RUN_ROOT="${RUN_ROOT:-/root/runs/issue43_xcomet_destructive_mlp_95}"
+NTREX_JSONL="${NTREX_JSONL:-/root/runs/ntrex_eval/ntrex_en2pt.jsonl}"
+ISSUE42_HF_REPO="${ISSUE42_HF_REPO:-TokenBender/circuit-discovery}"
+ISSUE42_RESULTS_PATH="${ISSUE42_RESULTS_PATH:-circuit-shotting/artifacts/percentile_proxy/issue42_percentile_proxy_20260518T110628Z/damage/percentile_results.jsonl}"
+TOP_NS="${TOP_NS:-10,15,20,30,40,50}"
+TARGET_RECOVERY="${TARGET_RECOVERY:-0.05}"
+GPU_LIST="${GPU_LIST:-}"
+EVAL_MAX_ROWS="${EVAL_MAX_ROWS:-}"
+BATCH_SIZE_GEN="${BATCH_SIZE_GEN:-32}"
+MAX_NEW_TOKENS="${MAX_NEW_TOKENS:-384}"
+XCOMET_SERVICE_BASE_PORT="${XCOMET_SERVICE_BASE_PORT:-10001}"
+XCOMET_MODEL="${XCOMET_MODEL:-Unbabel/XCOMET-XXL}"
+XCOMET_BATCH_SIZE="${XCOMET_BATCH_SIZE:-4}"
+XCOMET_CHUNK_SIZE="${XCOMET_CHUNK_SIZE:-16}"
+XCOMET_SERVICE_LOAD_TIMEOUT_S="${XCOMET_SERVICE_LOAD_TIMEOUT_S:-1800}"
+UPLOAD_AFTER="${UPLOAD_AFTER:-0}"
+
+mkdir -p "$RUN_ROOT"/{logs,restored,selection,eval,dumps/ntrex,xcomet,xcomet_shards,services,summaries,package}
+
+mark() {
+  echo "[$(date -Iseconds)] $*" | tee -a "$RUN_ROOT/logs/issue43_progress.log"
+}
+
+run_python() {
+  python3 "$@"
+}
+
+detect_gpus() {
+  if [[ -n "$GPU_LIST" ]]; then
+    echo "$GPU_LIST" | tr ',' ' '
+    return
+  fi
+  nvidia-smi --query-gpu=index --format=csv,noheader | tr '\n' ' '
+}
+
+read -r -a GPU_ARRAY <<<"$(detect_gpus)"
+GPU_COUNT="${#GPU_ARRAY[@]}"
+if ((GPU_COUNT < 1)); then
+  echo "no GPUs found" >&2
+  exit 2
+fi
+
+wait_pids() {
+  local failed=0
+  for pid in "$@"; do
+    if ! wait "$pid"; then
+      failed=1
+    fi
+  done
+  return "$failed"
+}
+
+max_top_n() {
+  python3 - "$TOP_NS" <<'PY'
+import sys
+vals = [int(x) for x in sys.argv[1].replace(",", " ").split() if x.strip()]
+print(max(vals))
+PY
+}
+
+candidate_names() {
+  python3 - "$TOP_NS" <<'PY'
+import sys
+vals = [int(x) for x in sys.argv[1].replace(",", " ").split() if x.strip()]
+for value in vals:
+    print(f"percentile_top_{value}")
+PY
+}
+
+build_ntrex() {
+  if [[ -f "$NTREX_JSONL" ]]; then
+    return 0
+  fi
+  mark "build NTREX EN->PT held-out jsonl"
+  run_python build_ntrex_en2pt_jsonl.py > "$RUN_ROOT/logs/build_ntrex.log" 2>&1
+}
+
+restore_and_select_masks() {
+  local restored="$RUN_ROOT/restored/issue42/$ISSUE42_RESULTS_PATH"
+  if [[ ! -s "$restored" ]]; then
+    mark "restore issue42 percentile damage results from HF"
+    hf download "$ISSUE42_HF_REPO" \
+      --repo-type dataset \
+      --include "$ISSUE42_RESULTS_PATH" \
+      --local-dir "$RUN_ROOT/restored/issue42" \
+      > "$RUN_ROOT/logs/hf_download_issue42.log" 2>&1
+  fi
+  if [[ ! -s "$RUN_ROOT/selection/percentile/selection_summary.json" ]]; then
+    mark "build cumulative percentile masks through top $(max_top_n)"
+    run_python select_percentile_mlp_mix.py \
+      --chunk-results "$restored" \
+      --out-dir "$RUN_ROOT/selection/percentile" \
+      --top-n "$(max_top_n)" \
+      > "$RUN_ROOT/logs/select_percentile_masks.log" 2>&1
+  fi
+  candidate_names > "$RUN_ROOT/selection/scored_candidate_names.txt"
+}
+
+run_generation_job() {
+  local gpu="$1"
+  local name="$2"
+  local mask_path="${3:-}"
+  local out="$RUN_ROOT/eval/ntrex_${name}.json"
+  if [[ -s "$out" && -s "$RUN_ROOT/dumps/ntrex/${name}.jsonl" ]]; then
+    return 0
+  fi
+  if [[ "$name" == "no_mask" ]]; then
+    CUDA_VISIBLE_DEVICES="$gpu" run_python evaluate_mlp_nuke_translation.py \
+      --model "$MODEL" \
+      --input-jsonl "$NTREX_JSONL" \
+      --out-json "$out" \
+      --dump-dir "$RUN_ROOT/dumps/ntrex" \
+      ${EVAL_MAX_ROWS:+--max-rows "$EVAL_MAX_ROWS"} \
+      --batch-size "$BATCH_SIZE_GEN" \
+      --max-new-tokens "$MAX_NEW_TOKENS" \
+      --include-no-mask \
+      --category "ntrex_test" \
+      --tag "heldout" \
+      > "$RUN_ROOT/logs/eval_ntrex_${name}.log" 2>&1
+  else
+    CUDA_VISIBLE_DEVICES="$gpu" run_python evaluate_mlp_nuke_translation.py \
+      --model "$MODEL" \
+      --input-jsonl "$NTREX_JSONL" \
+      --out-json "$out" \
+      --dump-dir "$RUN_ROOT/dumps/ntrex" \
+      --mask "${name}:${mask_path}" \
+      ${EVAL_MAX_ROWS:+--max-rows "$EVAL_MAX_ROWS"} \
+      --batch-size "$BATCH_SIZE_GEN" \
+      --max-new-tokens "$MAX_NEW_TOKENS" \
+      --category "ntrex_test" \
+      --tag "heldout" \
+      > "$RUN_ROOT/logs/eval_ntrex_${name}.log" 2>&1
+  fi
+}
+
+generate_candidates() {
+  mark "generate NTREX hypotheses for no-mask and candidate nukes over $GPU_COUNT GPUs"
+  local pids=()
+  local idx=0
+  local gpu
+  gpu="${GPU_ARRAY[$((idx % GPU_COUNT))]}"
+  run_generation_job "$gpu" "no_mask" &
+  pids+=("$!")
+  idx=$((idx + 1))
+  while read -r name; do
+    [[ -n "$name" ]] || continue
+    gpu="${GPU_ARRAY[$((idx % GPU_COUNT))]}"
+    run_generation_job "$gpu" "$name" "$RUN_ROOT/selection/percentile/masks/${name}.full.npz" &
+    pids+=("$!")
+    idx=$((idx + 1))
+    if ((${#pids[@]} >= GPU_COUNT)); then
+      wait_pids "${pids[@]}"
+      pids=()
+    fi
+  done < <(candidate_names)
+  if ((${#pids[@]})); then
+    wait_pids "${pids[@]}"
+  fi
+}
+
+start_xcomet_service() {
+  local service_idx="$1"
+  local gpu="$2"
+  local port="$3"
+  local service_root="$RUN_ROOT/services/xcomet_${service_idx}"
+  mkdir -p "$service_root"
+  if [[ ! -s "$service_root/service.token" ]]; then
+    run_python - "$service_root/service.token" <<'PY'
+import secrets, sys
+from pathlib import Path
+p = Path(sys.argv[1])
+p.write_text(secrets.token_urlsafe(32))
+p.chmod(0o600)
+PY
+  fi
+  if [[ -s "$service_root/service.pid" ]] && kill -0 "$(cat "$service_root/service.pid")" 2>/dev/null; then
+    return 0
+  fi
+  mark "start XCOMET service idx=$service_idx gpu=$gpu port=$port"
+  CUDA_VISIBLE_DEVICES="$gpu" XCOMET_SERVICE_TOKEN="$(cat "$service_root/service.token")" \
+    nohup python3 xcomet_service.py \
+      --host 0.0.0.0 --port "$port" \
+      --comet-model "$XCOMET_MODEL" \
+      --run-root "$service_root" \
+      --default-batch-size "$XCOMET_BATCH_SIZE" \
+      --default-chunk-size "$XCOMET_CHUNK_SIZE" \
+      --max-worker-batch-size "$XCOMET_BATCH_SIZE" \
+      --max-batch-rows "$XCOMET_CHUNK_SIZE" \
+      --max-batch-wait-ms 100 \
+      --max-queue-rows 4096 \
+      --queue-timeout-s 7200 \
+      --float32-matmul-precision high \
+      --load-on-start \
+      > "$service_root/service.log" 2>&1 &
+  echo "$!" > "$service_root/service.pid"
+}
+
+wait_xcomet_service() {
+  local service_idx="$1"
+  local port="$2"
+  local service_root="$RUN_ROOT/services/xcomet_${service_idx}"
+  local start_ts now elapsed
+  start_ts="$(date +%s)"
+  while true; do
+    if [[ -s "$service_root/service.pid" ]] && ! kill -0 "$(cat "$service_root/service.pid")" 2>/dev/null; then
+      tail -n 200 "$service_root/service.log" >&2 || true
+      return 1
+    fi
+    if curl -fsS -H "Authorization: Bearer $(cat "$service_root/service.token")" \
+      "http://127.0.0.1:${port}/health" > "$service_root/health.json" 2>/dev/null; then
+      if grep -q '"model_loaded": true' "$service_root/health.json"; then
+        mark "XCOMET service idx=$service_idx healthy on port=$port"
+        return 0
+      fi
+    fi
+    now="$(date +%s)"
+    elapsed=$((now - start_ts))
+    if ((elapsed > XCOMET_SERVICE_LOAD_TIMEOUT_S)); then
+      tail -n 200 "$service_root/service.log" >&2 || true
+      return 1
+    fi
+    sleep 15
+  done
+}
+
+start_xcomet_services() {
+  mark "start $GPU_COUNT XCOMET services sequentially"
+  for ((j=0; j<GPU_COUNT; j++)); do
+    start_xcomet_service "$j" "${GPU_ARRAY[$j]}" "$((XCOMET_SERVICE_BASE_PORT + j))"
+    wait_xcomet_service "$j" "$((XCOMET_SERVICE_BASE_PORT + j))"
+  done
+}
+
+score_xcomet_name() {
+  local name="$1"
+  local hyps="$RUN_ROOT/dumps/ntrex/${name}.jsonl"
+  local out="$RUN_ROOT/xcomet/${name}.json"
+  if [[ -s "$out" ]]; then
+    return 0
+  fi
+  local service_args=()
+  for ((j=0; j<GPU_COUNT; j++)); do
+    service_args+=(--service "$j,http://127.0.0.1:$((XCOMET_SERVICE_BASE_PORT + j)),$RUN_ROOT/services/xcomet_${j}/service.token")
+  done
+  mark "XCOMET score $name"
+  run_python score_xcomet_sharded.py \
+    --hyps-jsonl "$hyps" \
+    --out-json "$out" \
+    --out-jsonl "$RUN_ROOT/xcomet/${name}.scored_pool.jsonl" \
+    --shard-dir "$RUN_ROOT/xcomet_shards/$name" \
+    --request-id "issue43_${name}" \
+    --system-name "issue43_${name}" \
+    --batch-size "$XCOMET_BATCH_SIZE" \
+    --chunk-size "$XCOMET_CHUNK_SIZE" \
+    --timeout-s 7200 \
+    "${service_args[@]}" \
+    > "$RUN_ROOT/logs/xcomet_${name}.log" 2>&1
+}
+
+summarize() {
+  run_python summarize_issue43_xcomet_destructive_mlp.py \
+    --run-root "$RUN_ROOT" \
+    --target-recovery "$TARGET_RECOVERY" \
+    --out-json "$RUN_ROOT/summaries/issue43_summary.json" \
+    --out-md "$RUN_ROOT/summaries/issue43_summary.md" \
+    > "$RUN_ROOT/logs/summarize_issue43.log" 2>&1
+}
+
+gate_passed() {
+  python3 - "$RUN_ROOT/summaries/issue43_summary.json" <<'PY'
+import json, sys
+payload = json.load(open(sys.argv[1]))
+raise SystemExit(0 if payload.get("gate_passed") else 1)
+PY
+}
+
+score_until_gate() {
+  start_xcomet_services
+  score_xcomet_name "no_mask"
+  summarize
+  while read -r name; do
+    [[ -n "$name" ]] || continue
+    score_xcomet_name "$name"
+    summarize
+    if gate_passed; then
+      mark "target reached by $name; stop further XCOMET scoring"
+      return 0
+    fi
+  done < <(candidate_names)
+  mark "target recovery $TARGET_RECOVERY not reached by scored candidates"
+  return 3
+}
+
+package_upload() {
+  if [[ "$UPLOAD_AFTER" == "1" || "$UPLOAD_AFTER" == "true" ]]; then
+    mark "package and upload issue43 artifacts"
+    RUN_ROOT="$RUN_ROOT" REPO_DIR="$REPO_DIR" bash scripts/package_issue43_hf_upload.sh \
+      > "$RUN_ROOT/logs/package_issue43_hf_upload.log" 2>&1
+  fi
+}
+
+mark "issue43 start XCOMET destructive MLP gate gpus=${GPU_ARRAY[*]} top_ns=$TOP_NS target=$TARGET_RECOVERY"
+build_ntrex
+restore_and_select_masks
+generate_candidates
+set +e
+score_until_gate
+status="$?"
+set -e
+summarize
+package_upload
+if [[ "$status" != "0" ]]; then
+  exit "$status"
+fi
+mark "issue43 done"

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/package_issue43_hf_upload.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+# Package and upload issue #43 XCOMET destructive MLP artifacts.
+set -euo pipefail
+
+RUN_ROOT="${RUN_ROOT:-/root/runs/issue43_xcomet_destructive_mlp_95}"
+REPO_DIR="${REPO_DIR:-/root/work/circuit-shotting}"
+STAMP="$(date -u +%Y%m%dT%H%M%SZ)"
+UPLOAD_PREFIX="${UPLOAD_PREFIX:-issue43_xcomet_destructive_mlp_95_$STAMP}"
+SYNTH_HF_REPO="${SYNTH_HF_REPO:-TokenBender/synth-data-en-pt-circuit}"
+CIRCUIT_HF_REPO="${CIRCUIT_HF_REPO:-TokenBender/circuit-discovery}"
+UPLOAD_DIR="$RUN_ROOT/package/$UPLOAD_PREFIX"
+
+rm -rf "$UPLOAD_DIR"
+mkdir -p "$UPLOAD_DIR"/{spec,scripts,restored,selection,eval,dumps,xcomet,xcomet_shards,summaries,logs,services,manifests}
+
+copy_if_present() {
+  local src="$1"
+  local dst="$2"
+  if [[ -e "$src" ]]; then
+    mkdir -p "$(dirname "$dst")"
+    cp -a "$src" "$dst"
+  fi
+}
+
+copy_if_present "$REPO_DIR/configs/issue43_xcomet_destructive_mlp_95.json" "$UPLOAD_DIR/spec/issue43_xcomet_destructive_mlp_95.json"
+
+for path in \
+  actdelta_mlp_common.py \
+  build_ntrex_en2pt_jsonl.py \
+  evaluate_mlp_nuke_translation.py \
+  issue43_xcomet_destructive_mlp_runner.sh \
+  score_xcomet_sharded.py \
+  select_percentile_mlp_mix.py \
+  summarize_issue43_xcomet_destructive_mlp.py \
+  xcomet_service.py \
+  scripts/package_issue43_hf_upload.sh; do
+  copy_if_present "$REPO_DIR/$path" "$UPLOAD_DIR/scripts/$(basename "$path")"
+done
+
+cp -a "$RUN_ROOT/restored"/* "$UPLOAD_DIR/restored/" 2>/dev/null || true
+cp -a "$RUN_ROOT/selection"/* "$UPLOAD_DIR/selection/" 2>/dev/null || true
+cp -a "$RUN_ROOT/eval"/* "$UPLOAD_DIR/eval/" 2>/dev/null || true
+cp -a "$RUN_ROOT/xcomet"/* "$UPLOAD_DIR/xcomet/" 2>/dev/null || true
+cp -a "$RUN_ROOT/xcomet_shards"/* "$UPLOAD_DIR/xcomet_shards/" 2>/dev/null || true
+cp -a "$RUN_ROOT/summaries"/* "$UPLOAD_DIR/summaries/" 2>/dev/null || true
+cp -a "$RUN_ROOT/logs"/* "$UPLOAD_DIR/logs/" 2>/dev/null || true
+
+find "$RUN_ROOT/dumps" -maxdepth 3 -type f -name '*.jsonl' -print0 2>/dev/null \
+  | while IFS= read -r -d '' file; do
+      rel="${file#$RUN_ROOT/dumps/}"
+      copy_if_present "$file" "$UPLOAD_DIR/dumps/$rel"
+    done
+
+find "$RUN_ROOT/services" -maxdepth 2 -type f \( -name 'service.log' -o -name 'health.json' \) -print0 2>/dev/null \
+  | while IFS= read -r -d '' file; do
+      rel="${file#$RUN_ROOT/services/}"
+      copy_if_present "$file" "$UPLOAD_DIR/services/$rel"
+    done
+
+find "$UPLOAD_DIR" -type f -print0 | sort -z | xargs -0 sha256sum > "$UPLOAD_DIR/manifests/SHA256SUMS"
+python3 - "$UPLOAD_DIR" "$RUN_ROOT" "$UPLOAD_PREFIX" <<'PY'
+import json, sys
+from pathlib import Path
+upload = Path(sys.argv[1])
+run_root = Path(sys.argv[2])
+prefix = sys.argv[3]
+files = [p for p in upload.rglob("*") if p.is_file()]
+manifest = {
+    "upload_prefix": prefix,
+    "run_root": str(run_root),
+    "file_count": len(files),
+    "bytes": sum(p.stat().st_size for p in files),
+    "weights_policy": "Includes experiment masks, generated hypotheses, XCOMET summaries/scored rows, scripts, specs, and logs. Excludes upstream HY-MT/XCOMET weights, HF caches, API keys, and service tokens.",
+}
+(upload / "manifests" / "manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")
+(upload / "README.md").write_text(
+    "# Issue 43 XCOMET Destructive MLP 95% Gate Artifacts\n\n"
+    "This package contains restored issue #42 percentile damage inputs, cumulative MLP masks, "
+    "NTREX generation dumps, XCOMET scores, summaries, and logs for the destructive <=5% recovery gate.\n\n"
+    "Upstream HY-MT and XCOMET model weights are not included.\n"
+)
+PY
+
+hf upload "$SYNTH_HF_REPO" "$UPLOAD_DIR" "$UPLOAD_PREFIX" --repo-type dataset
+hf upload "$CIRCUIT_HF_REPO" "$UPLOAD_DIR" "circuit-shotting/artifacts/xcomet_destructive_mlp_95/$UPLOAD_PREFIX" --repo-type dataset
+
+echo "$UPLOAD_PREFIX"

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/score_xcomet_sharded.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Score one hypothesis file by sharding it across all XCOMET services."""
+
+from __future__ import annotations
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import json
+import statistics
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--hyps-jsonl", required=True)
+    p.add_argument("--out-json", required=True)
+    p.add_argument("--out-jsonl", required=True)
+    p.add_argument("--shard-dir", required=True)
+    p.add_argument("--service", action="append", required=True,
+                   help="Service spec idx,base_url,token_file. Repeat once per GPU.")
+    p.add_argument("--request-id", default=None)
+    p.add_argument("--system-name", default=None)
+    p.add_argument("--batch-size", type=int, default=1)
+    p.add_argument("--chunk-size", type=int, default=16)
+    p.add_argument("--timeout-s", type=float, default=7200)
+    p.add_argument("--threshold", type=float, default=0.99)
+    return p.parse_args()
+
+
+def load_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows = []
+    with path.open() as f:
+        for idx, line in enumerate(f):
+            if not line.strip():
+                continue
+            row = json.loads(line)
+            row.setdefault("id", idx)
+            rows.append(row)
+    return rows
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def parse_service(spec: str) -> dict[str, Any]:
+    parts = spec.split(",", 2)
+    if len(parts) != 3:
+        raise ValueError(f"bad --service {spec!r}; expected idx,base_url,token_file")
+    idx, base_url, token_file = parts
+    return {
+        "idx": int(idx),
+        "base_url": base_url.rstrip("/"),
+        "token_file": token_file,
+        "token": Path(token_file).read_text().strip(),
+    }
+
+
+def request_json(method: str, url: str, token: str, payload: dict[str, Any] | None,
+                 timeout: float) -> dict[str, Any]:
+    body = None if payload is None else json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, data=body, method=method)
+    req.add_header("Authorization", f"Bearer {token}")
+    if body is not None:
+        req.add_header("Content-Type", "application/json")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as exc:
+        text = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"{url} failed {exc.code}: {text}") from exc
+
+
+def score_shard(service: dict[str, Any], shard_path: Path, *, request_id: str,
+                system_name: str, batch_size: int, chunk_size: int,
+                timeout_s: float) -> dict[str, Any]:
+    base = service["base_url"]
+    token = service["token"]
+    health = request_json("GET", f"{base}/health", token, None, timeout=30)
+    payload = {
+        "hyps_jsonl": str(shard_path),
+        "request_id": request_id,
+        "system_name": system_name,
+        "batch_size": batch_size,
+        "chunk_size": chunk_size,
+        "timeout_s": timeout_s,
+        "return_rows": False,
+    }
+    result = request_json("POST", f"{base}/score-dataset", token, payload, timeout=timeout_s + 60)
+    return {
+        "service": {
+            "idx": service["idx"],
+            "base_url": base,
+            "health": {
+                "model_loaded": health.get("model_loaded"),
+                "comet_model": health.get("comet_model"),
+                "cuda": health.get("cuda"),
+            },
+        },
+        "shard_path": str(shard_path),
+        **result,
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    services = [parse_service(spec) for spec in args.service]
+    if not services:
+        raise ValueError("at least one --service is required")
+    rows = load_jsonl(Path(args.hyps_jsonl))
+    if not rows:
+        raise ValueError(f"no rows in {args.hyps_jsonl}")
+
+    shard_dir = Path(args.shard_dir)
+    shard_dir.mkdir(parents=True, exist_ok=True)
+    request_root = args.request_id or Path(args.hyps_jsonl).stem
+    system_name = args.system_name or Path(args.hyps_jsonl).stem
+
+    shard_paths: list[Path] = []
+    for shard_idx, service in enumerate(services):
+        shard_rows = rows[shard_idx::len(services)]
+        shard_path = shard_dir / f"shard_{shard_idx:03d}.jsonl"
+        write_jsonl(shard_path, shard_rows)
+        shard_paths.append(shard_path)
+
+    t0 = time.time()
+    shard_results: list[dict[str, Any]] = []
+    with ThreadPoolExecutor(max_workers=len(services)) as executor:
+        futures = []
+        for shard_idx, (service, shard_path) in enumerate(zip(services, shard_paths)):
+            futures.append(executor.submit(
+                score_shard,
+                service,
+                shard_path,
+                request_id=f"{request_root}_shard{shard_idx:03d}",
+                system_name=f"{system_name}_shard{shard_idx:03d}",
+                batch_size=args.batch_size,
+                chunk_size=args.chunk_size,
+                timeout_s=args.timeout_s,
+            ))
+        for future in as_completed(futures):
+            shard_results.append(future.result())
+
+    scored_rows: list[dict[str, Any]] = []
+    for result in shard_results:
+        out_jsonl = result.get("outputs", {}).get("out_jsonl")
+        if not out_jsonl:
+            raise ValueError(f"shard result missing outputs.out_jsonl: {result}")
+        for row in load_jsonl(Path(out_jsonl)):
+            row["system"] = system_name
+            scored_rows.append(row)
+    scored_rows.sort(key=lambda row: int(row.get("row_id", row.get("id", 0))))
+
+    scores = [float(row["score"]) for row in scored_rows]
+    out_jsonl = Path(args.out_jsonl)
+    write_jsonl(out_jsonl, scored_rows)
+    summary = {
+        "source_path": args.hyps_jsonl,
+        "comet_model": shard_results[0].get("summary", {}).get("comet_model"),
+        "checkpoint_path": shard_results[0].get("summary", {}).get("checkpoint_path"),
+        "n": len(scored_rows),
+        "threshold": args.threshold,
+        "system_score": statistics.fmean(scores),
+        "passed": sum(1 for score in scores if score >= args.threshold),
+        "elapsed_seconds": time.time() - t0,
+        "batch_size": args.batch_size,
+        "chunk_size": args.chunk_size,
+        "shard_count": len(services),
+        "throughput_seg_per_s": len(scored_rows) / max(time.time() - t0, 1e-9),
+    }
+    payload = {
+        "health": [result["service"] for result in sorted(shard_results, key=lambda row: row["service"]["idx"])],
+        "summary": summary,
+        "outputs": {
+            "out_jsonl": str(out_jsonl),
+            "shard_dir": str(shard_dir),
+        },
+        "shards": sorted(shard_results, key=lambda row: row["service"]["idx"]),
+    }
+    out_json = Path(args.out_json)
+    out_json.parent.mkdir(parents=True, exist_ok=True)
+    out_json.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+    print(json.dumps({"out_json": str(out_json), "summary": summary}, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/select_percentile_mlp_mix.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Select destructive 1%ile MLP chunks and emit cumulative union masks."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from actdelta_mlp_common import (
+    Candidate,
+    count_mask,
+    load_candidate_jsonl,
+    mask_from_ranges,
+    mlp_total,
+    normalize_ranges,
+    save_mask_npz,
+    write_jsonl,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--chunk-results", required=True)
+    p.add_argument("--out-dir", required=True)
+    p.add_argument("--n-layers", type=int, default=32)
+    p.add_argument("--d-ffn", type=int, default=6144)
+    p.add_argument("--top-n", type=int, default=20)
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    out_dir = Path(args.out_dir)
+    mask_dir = out_dir / "masks"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    mask_dir.mkdir(parents=True, exist_ok=True)
+
+    rows = load_candidate_jsonl(args.chunk_results)
+    ranked = sorted(rows, key=lambda row: float(row["score"]), reverse=True)
+    write_jsonl(out_dir / "ranked_percentiles.jsonl", ranked)
+
+    cumulative_rows = []
+    for top_n in range(1, min(args.top_n, len(ranked)) + 1):
+        selected = ranked[:top_n]
+        ranges = []
+        for row in selected:
+            ranges.extend((int(start), int(end)) for start, end in row["ranges"])
+        ranges = normalize_ranges(ranges)
+        name = f"percentile_top_{top_n}"
+        candidate = Candidate(
+            name=name,
+            ranges=ranges,
+            meta={"top_n": top_n, "chunk_names": [row["name"] for row in selected]},
+        )
+        mask = mask_from_ranges(candidate.ranges, args.n_layers, args.d_ffn)
+        mask_path = mask_dir / f"{name}.full.npz"
+        save_mask_npz(mask_path, mask)
+        cumulative_rows.append({
+            "name": name,
+            "top_n": top_n,
+            "ranges": [list(r) for r in candidate.ranges],
+            "channels": count_mask(mask),
+            "channel_fraction": count_mask(mask) / max(mlp_total(args.n_layers, args.d_ffn), 1),
+            "chunk_names": candidate.meta["chunk_names"],
+            "mask_path": str(mask_path),
+            "selected_chunks": [
+                {
+                    "rank": idx + 1,
+                    "name": row["name"],
+                    "score": row["score"],
+                    "mean_sentence_kl": row["mean_sentence_kl"],
+                    "tail90_sentence_kl": row["tail90_sentence_kl"],
+                    "channels": row["channels"],
+                    "ranges": row["ranges"],
+                }
+                for idx, row in enumerate(selected)
+            ],
+        })
+    write_jsonl(out_dir / "cumulative_percentile_mixes.jsonl", cumulative_rows)
+    final = cumulative_rows[-1] if cumulative_rows else None
+
+    summary = {
+        "n_layers": args.n_layers,
+        "d_ffn": args.d_ffn,
+        "mlp_total": mlp_total(args.n_layers, args.d_ffn),
+        "top_n": args.top_n,
+        "ranked_percentiles_jsonl": str(out_dir / "ranked_percentiles.jsonl"),
+        "cumulative_percentile_mixes_jsonl": str(out_dir / "cumulative_percentile_mixes.jsonl"),
+        "final_mix": final,
+    }
+    (out_dir / "selection_summary.json").write_text(
+        json.dumps(summary, indent=2, ensure_ascii=False) + "\n"
+    )
+    print(json.dumps({
+        "top_n": args.top_n,
+        "final_mix": None if final is None else final["name"],
+        "channels": None if final is None else final["channels"],
+        "out_dir": str(out_dir),
+    }, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/summarize_issue43_xcomet_destructive_mlp.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""Summarize issue #43 XCOMET destructive MLP gate results."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+PRIOR_ANCHOR = {
+    "name": "issue39_final_mix_top_3",
+    "channels": 5898,
+    "channel_fraction": 5898 / 196608,
+    "xcomet": 0.14186869932268653,
+    "recovery": 0.15275785974445857,
+}
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--run-root", required=True)
+    p.add_argument("--target-recovery", type=float, default=0.05)
+    p.add_argument("--out-json", required=True)
+    p.add_argument("--out-md", required=True)
+    return p.parse_args()
+
+
+def maybe_json(path: Path) -> Any | None:
+    if not path.exists():
+        return None
+    with path.open() as f:
+        return json.load(f)
+
+
+def xcomet_score(path: Path) -> float | None:
+    payload = maybe_json(path)
+    if not payload:
+        return None
+    return payload.get("summary", {}).get("system_score")
+
+
+def load_selection_rows(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    if not path.exists():
+        return rows
+    with path.open() as f:
+        for line in f:
+            if line.strip():
+                rows.append(json.loads(line))
+    return rows
+
+
+def eval_row(root: Path, name: str) -> dict[str, Any]:
+    payload = maybe_json(root / "eval" / f"ntrex_{name}.json") or {}
+    result = (payload.get("results") or {}).get(name) or {}
+    return {
+        "name": name,
+        "channels": result.get("channels"),
+        "channel_fraction": None if result.get("channels") is None else result.get("channels") / 196608,
+        "chrFpp": (result.get("scores") or {}).get("chrFpp"),
+        "BLEU": (result.get("scores") or {}).get("BLEU"),
+        "dump_path": result.get("dump_path"),
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    root = Path(args.run_root)
+    out_json = Path(args.out_json)
+    out_md = Path(args.out_md)
+    out_json.parent.mkdir(parents=True, exist_ok=True)
+    out_md.parent.mkdir(parents=True, exist_ok=True)
+
+    selection_rows = load_selection_rows(root / "selection" / "percentile" / "cumulative_percentile_mixes.jsonl")
+    names_path = root / "selection" / "scored_candidate_names.txt"
+    if names_path.exists():
+        candidate_names = [line.strip() for line in names_path.read_text().splitlines() if line.strip()]
+    else:
+        candidate_names = [row["name"] for row in selection_rows]
+    candidate_meta = {row["name"]: row for row in selection_rows}
+
+    no_mask_eval = maybe_json(root / "eval" / "ntrex_no_mask.json") or {}
+    no_mask_result = (no_mask_eval.get("results") or {}).get("no_mask") or {}
+    baseline_xcomet = xcomet_score(root / "xcomet" / "no_mask.json")
+
+    rows: list[dict[str, Any]] = []
+    for name in candidate_names:
+        row = eval_row(root, name)
+        meta = candidate_meta.get(name) or {}
+        row["top_n"] = meta.get("top_n")
+        row["chunk_names"] = meta.get("chunk_names")
+        row["xcomet"] = xcomet_score(root / "xcomet" / f"{name}.json")
+        if baseline_xcomet and row["xcomet"] is not None:
+            row["recovery"] = row["xcomet"] / baseline_xcomet
+            row["destruction"] = 1.0 - row["recovery"]
+            row["passes_target"] = row["recovery"] <= args.target_recovery
+        else:
+            row["recovery"] = None
+            row["destruction"] = None
+            row["passes_target"] = False
+        rows.append(row)
+
+    scored_rows = [row for row in rows if row["xcomet"] is not None]
+    passing = [row for row in scored_rows if row["passes_target"]]
+    passing.sort(key=lambda row: (row.get("channels") or 10**18, row.get("top_n") or 10**18))
+    best = passing[0] if passing else None
+
+    payload = {
+        "run_root": str(root),
+        "target_recovery": args.target_recovery,
+        "no_mask": {
+            "xcomet": baseline_xcomet,
+            "chrFpp": (no_mask_result.get("scores") or {}).get("chrFpp"),
+            "BLEU": (no_mask_result.get("scores") or {}).get("BLEU"),
+            "dump_path": no_mask_result.get("dump_path"),
+        },
+        "prior_anchor": PRIOR_ANCHOR,
+        "candidates": rows,
+        "best_passing": best,
+        "gate_passed": best is not None,
+    }
+    out_json.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+
+    lines = [
+        "# Issue 43 XCOMET Destructive MLP 95% Gate",
+        "",
+        f"- Target recovery: `{args.target_recovery}`",
+        f"- No-mask XCOMET: `{baseline_xcomet}`",
+        f"- Gate passed: `{best is not None}`",
+    ]
+    if best:
+        lines.extend([
+            f"- Smallest passing candidate: `{best['name']}`",
+            f"- Passing channels: `{best.get('channels')}`",
+            f"- Passing recovery: `{best.get('recovery')}`",
+            f"- Passing destruction: `{best.get('destruction')}`",
+        ])
+    lines.extend([
+        "",
+        "## Prior Anchor",
+        "",
+        "| anchor | channels | XCOMET | recovery | destruction |",
+        "|---|---:|---:|---:|---:|",
+        (
+            f"| `{PRIOR_ANCHOR['name']}` | `{PRIOR_ANCHOR['channels']}` | "
+            f"`{PRIOR_ANCHOR['xcomet']}` | `{PRIOR_ANCHOR['recovery']}` | "
+            f"`{1.0 - PRIOR_ANCHOR['recovery']}` |"
+        ),
+        "",
+        "## XCOMET Candidates",
+        "",
+        "| candidate | top_n | channels | chrF++ | BLEU | XCOMET | recovery | destruction | pass |",
+        "|---|---:|---:|---:|---:|---:|---:|---:|---|",
+    ])
+    for row in rows:
+        lines.append(
+            f"| `{row['name']}` | `{row.get('top_n')}` | `{row.get('channels')}` | "
+            f"`{row.get('chrFpp')}` | `{row.get('BLEU')}` | `{row.get('xcomet')}` | "
+            f"`{row.get('recovery')}` | `{row.get('destruction')}` | "
+            f"`{row.get('passes_target')}` |"
+        )
+    out_md.write_text("\n".join(lines) + "\n")
+    print(json.dumps({"out_json": str(out_json), "out_md": str(out_md), "gate_passed": best is not None}, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/scripts/xcomet_service.py

@@ -0,0 +1,560 @@
+#!/usr/bin/env python3
+"""Long-running HTTP service for XCOMET/COMET scoring and dataset export."""
+
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+import json
+import os
+import queue
+import statistics
+import threading
+import time
+import uuid
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import torch
+
+from build_xcomet_ft_dataset import (
+    build_preferences,
+    build_repairs,
+    build_sft,
+    load_jsonl,
+    normalize_pool,
+    score_distribution,
+    write_jsonl,
+)
+from score_xcomet_pool import prediction_extras, resolve_checkpoint
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--host", default="0.0.0.0")
+    p.add_argument("--port", type=int, default=20000)
+    p.add_argument("--comet-model", default=os.environ.get("COMET_MODEL", "Unbabel/XCOMET-XXL"))
+    p.add_argument("--checkpoint-path", default=os.environ.get("XCOMET_CKPT_PATH"))
+    p.add_argument("--run-root", default=os.environ.get("RUN_ROOT", "/root/runs/xcomet_service"))
+    p.add_argument("--default-batch-size", type=int, default=int(os.environ.get("XCOMET_BATCH", "4")))
+    p.add_argument("--default-chunk-size", type=int, default=int(os.environ.get("XCOMET_CHUNK", "32")))
+    p.add_argument("--max-worker-batch-size", type=int, default=int(os.environ.get("XCOMET_MAX_WORKER_BATCH", os.environ.get("XCOMET_BATCH", "4"))))
+    p.add_argument("--max-batch-rows", type=int, default=int(os.environ.get("XCOMET_MAX_BATCH_ROWS", os.environ.get("XCOMET_CHUNK", "32"))))
+    p.add_argument("--max-batch-wait-ms", type=int, default=int(os.environ.get("XCOMET_MAX_BATCH_WAIT_MS", "100")))
+    p.add_argument("--max-queue-rows", type=int, default=int(os.environ.get("XCOMET_MAX_QUEUE_ROWS", "4096")))
+    p.add_argument("--queue-timeout-s", type=float, default=float(os.environ.get("XCOMET_QUEUE_TIMEOUT_S", "1800")))
+    p.add_argument("--float32-matmul-precision", choices=["highest", "high", "medium"], default=os.environ.get("XCOMET_FLOAT32_MATMUL_PRECISION", "high"))
+    p.add_argument("--threshold", type=float, default=float(os.environ.get("XCOMET_THRESHOLD", "0.99")))
+    p.add_argument("--auth-token", default=os.environ.get("XCOMET_SERVICE_TOKEN"))
+    p.add_argument("--load-on-start", action="store_true")
+    return p.parse_args()
+
+
+@dataclass(frozen=True)
+class ScoreResult:
+    score: float
+    extra: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class ScoreUnit:
+    job: "ScoreJob"
+    index: int
+    data: dict[str, Any]
+    batch_size: int
+    enqueued_at: float
+
+
+class ScoreJob:
+    def __init__(self, size: int):
+        self.results: list[ScoreResult | None] = [None] * size
+        self.remaining = size
+        self.error: BaseException | None = None
+        self.event = threading.Event()
+        self.lock = threading.Lock()
+
+    def record(self, index: int, result: ScoreResult) -> None:
+        with self.lock:
+            if self.error is not None:
+                return
+            self.results[index] = result
+            self.remaining -= 1
+            if self.remaining == 0:
+                self.event.set()
+
+    def fail(self, exc: BaseException) -> None:
+        with self.lock:
+            if self.error is None:
+                self.error = exc
+            self.event.set()
+
+
+class ScoringBatcher:
+    """Single GPU worker with dynamic row batching across HTTP callers."""
+
+    def __init__(self, state: "ServiceState"):
+        self.state = state
+        self.work: queue.Queue[ScoreUnit] = queue.Queue(maxsize=state.args.max_queue_rows)
+        self.max_rows = max(1, state.args.max_batch_rows)
+        self.max_worker_batch_size = max(1, state.args.max_worker_batch_size)
+        self.max_wait_seconds = max(0.0, state.args.max_batch_wait_ms / 1000.0)
+        self.stats_lock = threading.Lock()
+        self.active_batch_rows = 0
+        self.completed_batches = 0
+        self.completed_rows = 0
+        self.failed_batches = 0
+        self.last_batch_rows = 0
+        self.last_batch_seconds: float | None = None
+        self.last_batch_started_at: float | None = None
+        self.last_error: str | None = None
+        self.worker = threading.Thread(target=self._worker_loop, name="xcomet-gpu-worker", daemon=True)
+        self.worker.start()
+
+    def status(self) -> dict[str, Any]:
+        with self.stats_lock:
+            return {
+                "pending_rows": self.work.qsize(),
+                "active_batch_rows": self.active_batch_rows,
+                "completed_batches": self.completed_batches,
+                "completed_rows": self.completed_rows,
+                "failed_batches": self.failed_batches,
+                "last_batch_rows": self.last_batch_rows,
+                "last_batch_seconds": self.last_batch_seconds,
+                "last_batch_started_at": self.last_batch_started_at,
+                "last_error": self.last_error,
+                "max_batch_rows": self.max_rows,
+                "max_worker_batch_size": self.max_worker_batch_size,
+                "max_batch_wait_ms": int(self.max_wait_seconds * 1000),
+                "max_queue_rows": self.work.maxsize,
+            }
+
+    def score(self, data: list[dict[str, Any]], batch_size: int, timeout_s: float | None) -> list[ScoreResult]:
+        job = ScoreJob(len(data))
+        deadline = None if timeout_s is None else time.time() + timeout_s
+        for index, item in enumerate(data):
+            remaining = None if deadline is None else max(0.0, deadline - time.time())
+            try:
+                self.work.put(
+                    ScoreUnit(job=job, index=index, data=item, batch_size=batch_size, enqueued_at=time.time()),
+                    timeout=remaining,
+                )
+            except queue.Full as exc:
+                job.fail(TimeoutError("timed out while queueing rows for scoring"))
+                raise TimeoutError("timed out while queueing rows for scoring") from exc
+
+        wait_timeout = None if deadline is None else max(0.0, deadline - time.time())
+        if not job.event.wait(wait_timeout):
+            job.fail(TimeoutError("timed out while waiting for scoring"))
+            raise TimeoutError("timed out while waiting for scoring")
+        if job.error is not None:
+            raise job.error
+        results = [result for result in job.results if result is not None]
+        if len(results) != len(data):
+            raise RuntimeError("scoring worker returned an incomplete result set")
+        return results
+
+    def _worker_loop(self) -> None:
+        while True:
+            first = self.work.get()
+            units = [first]
+            deadline = time.time() + self.max_wait_seconds
+            while len(units) < self.max_rows:
+                timeout = max(0.0, deadline - time.time())
+                if timeout == 0.0:
+                    break
+                try:
+                    units.append(self.work.get(timeout=timeout))
+                except queue.Empty:
+                    break
+            self._predict_units(units)
+            for _ in units:
+                self.work.task_done()
+
+    def _predict_units(self, units: list[ScoreUnit]) -> None:
+        started = time.time()
+        with self.stats_lock:
+            self.active_batch_rows = len(units)
+            self.last_batch_started_at = started
+        try:
+            self.state.load_model()
+            batch_size = min(max(unit.batch_size for unit in units), self.max_worker_batch_size)
+            preds = self.state.model.predict(
+                [unit.data for unit in units],
+                batch_size=batch_size,
+                gpus=1,
+                progress_bar=False,
+            )
+            scores = [float(s) for s in preds["scores"]]
+            extras = prediction_extras(preds, 0, len(units))
+            for unit, score, extra in zip(units, scores, extras, strict=True):
+                unit.job.record(unit.index, ScoreResult(score=score, extra=extra or {}))
+            elapsed = time.time() - started
+            with self.stats_lock:
+                self.completed_batches += 1
+                self.completed_rows += len(units)
+                self.last_batch_rows = len(units)
+                self.last_batch_seconds = elapsed
+                self.last_error = None
+        except Exception as exc:  # noqa: BLE001 - return scoring failures to callers
+            with self.stats_lock:
+                self.failed_batches += 1
+                self.last_error = f"{type(exc).__name__}: {exc}"
+            for unit in units:
+                unit.job.fail(exc)
+        finally:
+            with self.stats_lock:
+                self.active_batch_rows = 0
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+
+class ServiceState:
+    def __init__(self, args: argparse.Namespace):
+        self.args = args
+        self.run_root = Path(args.run_root)
+        self.run_root.mkdir(parents=True, exist_ok=True)
+        self.model = None
+        self.checkpoint_path: str | None = None
+        self.loaded_at: float | None = None
+        self.load_error: str | None = None
+        self.load_lock = threading.Lock()
+        self.scoring_batcher = ScoringBatcher(self)
+
+    def load_model(self) -> dict[str, Any]:
+        with self.load_lock:
+            if self.model is not None:
+                return self.status()
+            try:
+                from comet import load_from_checkpoint
+
+                ckpt = resolve_checkpoint(self.args.comet_model, self.args.checkpoint_path)
+                model = load_from_checkpoint(ckpt)
+                self.model = model
+                self.checkpoint_path = ckpt
+                self.loaded_at = time.time()
+                self.load_error = None
+            except Exception as exc:  # noqa: BLE001 - report service-load failures
+                self.load_error = f"{type(exc).__name__}: {exc}"
+                raise
+        return self.status()
+
+    def status(self) -> dict[str, Any]:
+        cuda = {
+            "available": torch.cuda.is_available(),
+            "device_count": torch.cuda.device_count(),
+        }
+        if torch.cuda.is_available():
+            cuda["device_name"] = torch.cuda.get_device_name(0)
+            cuda["memory_allocated"] = torch.cuda.memory_allocated(0)
+            cuda["memory_reserved"] = torch.cuda.memory_reserved(0)
+        return {
+            "ok": self.load_error is None,
+            "model_loaded": self.model is not None,
+            "comet_model": self.args.comet_model,
+            "checkpoint_path": self.checkpoint_path,
+            "loaded_at": self.loaded_at,
+            "run_root": str(self.run_root),
+            "float32_matmul_precision": self.args.float32_matmul_precision,
+            "cuda": cuda,
+            "load_error": self.load_error,
+            "queue": self.scoring_batcher.status(),
+        }
+
+
+def rows_from_request(payload: dict[str, Any]) -> tuple[list[dict[str, Any]], str]:
+    max_rows = payload.get("max_rows")
+    if payload.get("rows") is not None:
+        rows = list(payload["rows"])
+        if max_rows is not None:
+            rows = rows[: int(max_rows)]
+        return rows, payload.get("source_path", "request_rows")
+    if payload.get("hyps_jsonl"):
+        path = Path(payload["hyps_jsonl"])
+        rows = load_jsonl(path)
+        if max_rows is not None:
+            rows = rows[: int(max_rows)]
+        return rows, str(path)
+    raise ValueError("request needs either rows or hyps_jsonl")
+
+
+def score_payload(state: ServiceState, payload: dict[str, Any]) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    state.load_model()
+    rows, source_path = rows_from_request(payload)
+
+    src_field = payload.get("src_field", "en")
+    ref_field = payload.get("ref_field", "pt")
+    hyp_field = payload.get("hyp_field", "model_hyp")
+    id_field = payload.get("id_field", "id")
+    batch_size = int(payload.get("batch_size", state.args.default_batch_size))
+    chunk_size = int(payload.get("chunk_size", state.args.default_chunk_size))
+    timeout_s = float(payload.get("timeout_s", state.args.queue_timeout_s))
+    threshold = float(payload.get("threshold", state.args.threshold))
+    system_name = payload.get("system_name") or Path(source_path).stem
+
+    data = []
+    valid_rows = []
+    for row in rows:
+        src = row.get(src_field)
+        hyp = row.get(hyp_field)
+        ref = row.get(ref_field)
+        if src is None or hyp is None:
+            continue
+        item = {"src": src, "mt": hyp}
+        if ref is not None:
+            item["ref"] = ref
+        data.append(item)
+        valid_rows.append(row)
+    if not data:
+        raise ValueError("no scoreable rows found")
+
+    t0 = time.time()
+    scored_rows: list[dict[str, Any]] = []
+    seg_scores: list[float] = []
+    results = state.scoring_batcher.score(data, batch_size=batch_size, timeout_s=timeout_s)
+    for i, result in enumerate(results):
+        src_row = valid_rows[i]
+        scored = {
+            "row_id": src_row.get(id_field, i),
+            "source_path": source_path,
+            "system": system_name,
+            "metric": state.args.comet_model,
+            "score": result.score,
+            "src": src_row[src_field],
+            "ref": src_row.get(ref_field),
+            "mt": src_row[hyp_field],
+            "category": src_row.get("category"),
+            "tag": src_row.get("tag"),
+            "metadata": {
+                k: v for k, v in src_row.items()
+                if k not in {src_field, ref_field, hyp_field}
+            },
+        }
+        if result.extra:
+            scored["metric_metadata"] = result.extra
+        scored_rows.append(scored)
+        seg_scores.append(result.score)
+
+    summary = {
+        "source_path": source_path,
+        "comet_model": state.args.comet_model,
+        "checkpoint_path": state.checkpoint_path,
+        "n": len(scored_rows),
+        "threshold": threshold,
+        "system_score": statistics.fmean(seg_scores),
+        "passed": sum(1 for s in seg_scores if s >= threshold),
+        "elapsed_seconds": time.time() - t0,
+        "batch_size": batch_size,
+        "chunk_size": chunk_size,
+        "max_worker_batch_size": state.scoring_batcher.max_worker_batch_size,
+        "max_batch_rows": state.scoring_batcher.max_rows,
+        "max_batch_wait_ms": int(state.scoring_batcher.max_wait_seconds * 1000),
+        "throughput_seg_per_s": len(scored_rows) / max(time.time() - t0, 1e-9),
+    }
+    return scored_rows, summary
+
+
+def write_score_outputs(payload: dict[str, Any], rows: list[dict[str, Any]], summary: dict[str, Any]) -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    out_jsonl = payload.get("out_jsonl")
+    if out_jsonl:
+        path = Path(out_jsonl)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        write_jsonl(path, rows)
+        out["out_jsonl"] = str(path)
+
+    summary_json = payload.get("summary_json")
+    if summary_json:
+        path = Path(summary_json)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("w") as f:
+            json.dump(summary, f, indent=2, ensure_ascii=False)
+        out["summary_json"] = str(path)
+    return out
+
+
+def build_dataset_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    if payload.get("scored_rows") is not None:
+        scored_rows = normalize_pool(list(payload["scored_rows"]))
+        source = payload.get("source", "request_scored_rows")
+    elif payload.get("scored_jsonl"):
+        source_path = Path(payload["scored_jsonl"])
+        scored_rows = normalize_pool(load_jsonl(source_path))
+        source = str(source_path)
+    else:
+        raise ValueError("request needs either scored_rows or scored_jsonl")
+    if not scored_rows:
+        raise ValueError("no valid scored rows")
+
+    out_dir = Path(payload["out_dir"])
+    out_dir.mkdir(parents=True, exist_ok=True)
+    args = SimpleNamespace(
+        target_language=payload.get("target_language", "Portuguese"),
+        sft_min_score=float(payload.get("sft_min_score", 0.85)),
+        preference_min_gap=float(payload.get("preference_min_gap", 0.05)),
+        repair_max_score=float(payload.get("repair_max_score", 0.80)),
+        max_pairs_per_source=int(payload.get("max_pairs_per_source", 3)),
+    )
+
+    rows_by_source: dict[str, list[dict[str, Any]]] = {}
+    for row in scored_rows:
+        rows_by_source.setdefault(row["src"], []).append(row)
+
+    sft_rows, sft_rejects = build_sft(rows_by_source, args)
+    pref_rows, pref_rejects = build_preferences(rows_by_source, args)
+    repair_rows, repair_rejects = build_repairs(scored_rows, args)
+
+    write_jsonl(out_dir / "scored_pool.jsonl", scored_rows)
+    write_jsonl(out_dir / "sft.jsonl", sft_rows)
+    write_jsonl(out_dir / "preferences.jsonl", pref_rows)
+    write_jsonl(out_dir / "repair_triples.jsonl", repair_rows)
+
+    from collections import Counter
+
+    manifest = {
+        "source": source,
+        "target_language": args.target_language,
+        "thresholds": {
+            "sft_min_score": args.sft_min_score,
+            "preference_min_gap": args.preference_min_gap,
+            "repair_max_score": args.repair_max_score,
+            "max_pairs_per_source": args.max_pairs_per_source,
+        },
+        "counts": {
+            "scored_pool": len(scored_rows),
+            "unique_sources": len(rows_by_source),
+            "sft": len(sft_rows),
+            "preferences": len(pref_rows),
+            "repair_triples": len(repair_rows),
+        },
+        "splits": dict(Counter(row["split"] for row in scored_rows)),
+        "systems": dict(Counter(row.get("system", "?") for row in scored_rows)),
+        "categories": dict(Counter(row.get("category", "?") for row in scored_rows)),
+        "score_distribution": score_distribution(scored_rows),
+        "rejections": {
+            "sft": dict(sft_rejects),
+            "preferences": dict(pref_rejects),
+            "repair_triples": dict(repair_rejects),
+        },
+        "artifacts": {
+            "scored_pool": str(out_dir / "scored_pool.jsonl"),
+            "sft": str(out_dir / "sft.jsonl"),
+            "preferences": str(out_dir / "preferences.jsonl"),
+            "repair_triples": str(out_dir / "repair_triples.jsonl"),
+        },
+    }
+    with (out_dir / "curriculum_manifest.json").open("w") as f:
+        json.dump(manifest, f, indent=2, ensure_ascii=False)
+    return manifest
+
+
+def make_handler(state: ServiceState):
+    class Handler(BaseHTTPRequestHandler):
+        server_version = "XCOMETService/0.1"
+
+        def log_message(self, fmt: str, *args: Any) -> None:
+            print(f"[{self.log_date_time_string()}] {self.address_string()} {fmt % args}", flush=True)
+
+        def authenticated(self) -> bool:
+            token = state.args.auth_token
+            if not token:
+                return True
+            auth = self.headers.get("Authorization", "")
+            header_token = self.headers.get("X-XCOMET-Token")
+            return auth == f"Bearer {token}" or header_token == token
+
+        def read_json(self) -> dict[str, Any]:
+            n = int(self.headers.get("Content-Length", "0"))
+            if n <= 0:
+                return {}
+            return json.loads(self.rfile.read(n))
+
+        def send_json(self, status: HTTPStatus, payload: dict[str, Any]) -> None:
+            body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def do_GET(self) -> None:
+            if self.path in {"/", "/health"}:
+                self.send_json(HTTPStatus.OK, state.status() | {
+                    "endpoints": ["/health", "/load", "/score", "/dataset", "/score-dataset"],
+                })
+                return
+            self.send_json(HTTPStatus.NOT_FOUND, {"error": "not found"})
+
+        def do_POST(self) -> None:
+            if not self.authenticated():
+                self.send_json(HTTPStatus.UNAUTHORIZED, {"error": "unauthorized"})
+                return
+            try:
+                payload = self.read_json()
+                if self.path == "/load":
+                    self.send_json(HTTPStatus.OK, state.load_model())
+                    return
+                if self.path == "/score":
+                    rows, summary = score_payload(state, payload)
+                    outputs = write_score_outputs(payload, rows, summary)
+                    response = {"summary": summary, "outputs": outputs}
+                    if payload.get("return_rows", True):
+                        response["rows"] = rows
+                    self.send_json(HTTPStatus.OK, response)
+                    return
+                if self.path == "/dataset":
+                    self.send_json(HTTPStatus.OK, {"manifest": build_dataset_payload(payload)})
+                    return
+                if self.path == "/score-dataset":
+                    request_id = payload.get("request_id") or uuid.uuid4().hex[:12]
+                    root = state.run_root / request_id
+                    payload.setdefault("out_jsonl", str(root / "scored_pool.jsonl"))
+                    payload.setdefault("summary_json", str(root / "scored_pool.summary.json"))
+                    payload.setdefault("out_dir", str(root / "dataset"))
+                    rows, summary = score_payload(state, payload)
+                    outputs = write_score_outputs(payload, rows, summary)
+                    manifest = build_dataset_payload({
+                        **payload,
+                        "scored_rows": rows,
+                        "source": outputs.get("out_jsonl", "inline_scored_rows"),
+                    })
+                    self.send_json(HTTPStatus.OK, {
+                        "summary": summary,
+                        "outputs": outputs,
+                        "manifest": manifest,
+                    })
+                    return
+                self.send_json(HTTPStatus.NOT_FOUND, {"error": "not found"})
+            except Exception as exc:  # noqa: BLE001 - return JSON errors to callers
+                self.send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {
+                    "error": type(exc).__name__,
+                    "message": str(exc),
+                })
+
+    return Handler
+
+
+def main() -> None:
+    args = parse_args()
+    if torch.cuda.is_available():
+        torch.set_float32_matmul_precision(args.float32_matmul_precision)
+    state = ServiceState(args)
+    if args.load_on_start:
+        state.load_model()
+    server = ThreadingHTTPServer((args.host, args.port), make_handler(state))
+    print(json.dumps({
+        "event": "xcomet_service_start",
+        "host": args.host,
+        "port": args.port,
+        "comet_model": args.comet_model,
+        "run_root": args.run_root,
+        "auth_enabled": bool(args.auth_token),
+        "load_on_start": args.load_on_start,
+    }), flush=True)
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

circuit-shotting/artifacts/xcomet_destructive_mlp_95/issue43_xcomet_destructive_mlp_95_20260518T145643Z/selection/percentile/masks/percentile_top_1.full.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c8d140828eefea1d2dd4565eb0a64a78b7c33381b1cdb37d83c6a00e17f723b
+size 7205