Upload code/gmap.py with huggingface_hub

code/gmap.py

@@ -8,9 +8,16 @@ each factor accepted only if it does not increase the scale-free block-normalise
 reference -- the identity is in every one of these groups, so min_g must range over it.
 """
 from __future__ import annotations
-import sys, time
+import os, sys, time
 import numpy as np
+# VENDORED SNAPSHOT of mergeschool.core. /root/mergeability is another agent's live working tree
+# and it is being edited concurrently -- two runs of this study died mid-flight with
+# "ImportError: cannot import name 'merge' from 'mergeschool.core' (unknown location)" while its
+# package __init__ was mid-rewrite. We take a frozen copy at /root/merge-accuracy/vendor and fall
+# back to the original only if the copy is missing. /root/mergeability is never written to.
 sys.path.insert(0, "/root/mergeability/src")
+if os.path.isdir("/root/merge-accuracy/vendor/mergeschool"):
+    sys.path.insert(0, "/root/merge-accuracy/vendor")
 from mergeschool.core import alignment as AL
 
 
@@ -23,6 +30,32 @@ def _fast_assignment(gain):
     am = np.argmax(gain, axis=1)
     if len(np.unique(am)) == gain.shape[0]:
         return am, "argmax_exact"
+    if os.environ.get("MA_FAST_ASSIGN") == "1":
+        # CONFLICT REPAIR. The row-wise argmax attains the row-wise upper bound, so every row whose
+        # choice is unique is already at its optimum and can be frozen. Only the rows that collided
+        # need a real assignment, and they are solved exactly on the (tiny) submatrix of contested
+        # rows x still-free columns. n = 14336 makes a full Hungarian minutes-to-hours; the contested
+        # set here is a handful of rows. Not provably globally optimal, but it dominates the greedy
+        # fallback and matches the full solve on every case we checked.
+        n = gain.shape[0]
+        first, dup_rows = {}, []
+        for i, j in enumerate(am):
+            if j in first:
+                dup_rows.append(i)
+            else:
+                first[j] = i
+        free_cols = np.array(sorted(set(range(n)) - set(first.keys())), dtype=int)
+        rows = np.array(dup_rows, dtype=int)
+        perm = np.empty(n, dtype=int)
+        for j, i in first.items():
+            perm[i] = j
+        if len(rows):
+            from scipy.optimize import linear_sum_assignment
+            sub = gain[np.ix_(rows, free_cols)]
+            r, c = linear_sum_assignment(-sub)
+            for ri, ci in zip(r, c):
+                perm[rows[ri]] = free_cols[ci]
+        return perm, f"argmax_repair({len(rows)})"
     from scipy.optimize import linear_sum_assignment
     r, c = linear_sum_assignment(-gain)
     return c[np.argsort(r)], "hungarian"