feat(bot): weaker bots sometimes pick another plausible option (spread by level)

app.py

@@ -244,8 +244,11 @@ async def do_guess(images: list[UploadFile] = File(None),
                 k = min(nloc, max(5, int(round(f * nloc))))
                 sel = np.where(rr < k)[0]
                 re_, rl_, rn_ = re_[sel], rl_[sel], rn_[sel]
+            # "human mistake" spread by level: easy often takes another option,
+            # medium rarely, hard never (best geo-medoid).
+            spread = 0.6 if skill <= 1.5 else 0.2 if skill <= 2.5 else 0.0
             result = regionlib.predict(list(emb), re_, rl_, rn_,
-                                       M["country_slug"], M["country_name"])
+                                       M["country_slug"], M["country_name"], spread=spread)
         elif M.get("type") == "head":
             result = atlaslib.predict(list(emb), M["W"], M["b"], M["classes"],
                                       STATE["centroids"], STATE["cfg"], STATE["priors"],

region.py

@@ -16,30 +16,46 @@ def load_region(path):
     return emb, z["lat"].astype(np.float64), z["lng"].astype(np.float64)
 
 
-def predict(embs, ref_emb, ref_lat, ref_lng, country_slug, country_name, k=5):
-    """embs: list of (D,) query-frame embeddings. Returns a scoreable guess dict
-    (same shape the bot/guess.py emits): predicted lat/lon from the nearest
-    reference image, confidence from cosine similarity."""
+def predict(embs, ref_emb, ref_lat, ref_lng, country_slug, country_name, k=5, spread=0.0):
+    """embs: list of (D,) query-frame embeddings. Returns a scoreable guess dict.
+
+    `spread` (0..1) is the "make a human-like mistake" knob for weaker bots: the
+    candidate pool is widened and, with probability `spread`, the bot takes one of
+    the other (still visually-similar) options instead of the best geo-medoid. So
+    an easy bot sometimes confidently picks a wrong-but-plausible spot. spread=0
+    (hard) always returns the best geo-medoid.
+    """
     Q = np.stack([e / (np.linalg.norm(e) + 1e-8) for e in embs])  # (F, D)
     sims = Q @ ref_emb.T                                          # (F, N)
     fi, ni = np.unravel_index(int(np.argmax(sims)), sims.shape)
     best = float(sims[fi, ni])
 
-    # Top-k across all frames → geo-medoid (robust to a single odd neighbour).
+    # Candidate pool: top-k for the best guess, widened by spread for mistakes.
     flat = sims.reshape(-1)
-    kk = min(k, flat.shape[0])
-    top = np.argpartition(-flat, kk - 1)[:kk]
+    poolK = min(flat.shape[0], max(k, int(round(k + spread * 35))))
+    top = np.argpartition(-flat, poolK - 1)[:poolK]
+    top = top[np.argsort(-flat[top])]              # best-first
     cols = (top % ref_emb.shape[0])
     cla, cln = ref_lat[cols], ref_lng[cols]
+
+    # geo-medoid over the best k (robust to a single odd neighbour).
+    kk = min(k, len(cols))
     R = 6371.0088; p = np.pi / 180.0
-    dsum = np.empty(len(cols))
-    for i in range(len(cols)):
-        a = (np.sin((cla - cla[i]) * p / 2) ** 2
-             + np.cos(cla[i] * p) * np.cos(cla * p) * np.sin((cln - cln[i]) * p / 2) ** 2)
+    dsum = np.empty(kk)
+    for i in range(kk):
+        a = (np.sin((cla[:kk] - cla[i]) * p / 2) ** 2
+             + np.cos(cla[i] * p) * np.cos(cla[:kk] * p) * np.sin((cln[:kk] - cln[i]) * p / 2) ** 2)
         dsum[i] = (2 * R * np.arcsin(np.sqrt(np.clip(a, 0, 1)))).sum()
     m = int(dsum.argmin())
     lat, lon = float(cla[m]), float(cln[m])
 
+    # Weaker bots: sometimes grab a different, still-plausible option (ranks k..pool).
+    if spread > 0 and len(cols) > kk:
+        rng = np.random.default_rng()
+        if rng.random() < spread:
+            j = int(rng.integers(kk, len(cols)))
+            lat, lon = float(cla[j]), float(cln[j])
+
     conf = round(max(0.0, min(1.0, best)), 3)
     return {
         "country": country_slug,