Phase 62 postscript: scaling verdict is geography-insensitive (cluster-local and map-faithful travel variants <2% shift, arm ranking unchanged)

agent_reports_bgkf/artifacts/travel_cluster.py

@@ -0,0 +1,49 @@
+"""Cluster-realistic travel for the synthetic fleets: a clone building is a
+NEW building in its base's cluster - one nearest-neighbour-scale hop from
+its base and its sibling clones (jittered, capped at local scale for the
+remote site), and its base's real distance (small jitter) to everyone else.
+Rewrites the travel frame inside fleet_k{K}.pkl -> fleetc_k{K}.pkl."""
+import sys, pickle
+from pathlib import Path
+import numpy as np, pandas as pd
+
+sys.path.insert(0, '/Users/THIF/repos/BatterySwapAI2026-Example')
+from batteryswap_public.utils import load_dataset
+
+K = int(sys.argv[1])
+rng = np.random.default_rng(42 + K)
+*_, sc = load_dataset(Path('/Users/THIF/repos/BatterySwapAI2026-Example/dataset/train'))
+tc = sc[0]['travel_costs']
+base_h = tc.set_index(['from', 'to'])['hours']
+off = tc[tc['from'] != tc['to']]
+nn = off.pivot(index='from', columns='to', values='hours').min(axis=1)
+local = nn.clip(upper=2 * nn.median())          # remote-site guard
+
+with open(f'/tmp/c5/fleet_k{K}.pkl', 'rb') as f:
+    FL = pickle.load(f)
+locs = FL['locations']
+base_of = locs.drop_duplicates('building').set_index('building')['base_building']
+blds = sorted(locs['building'].unique())
+
+rows, seen = [], {}
+for i in blds:
+    for j in blds:
+        if i == j:
+            h = 0.0
+        else:
+            key = tuple(sorted((i, j)))
+            if key not in seen:
+                bi, bj = base_of[i], base_of[j]
+                if bi == bj:
+                    h = float(local[bi]) * rng.uniform(0.6, 1.4)
+                else:
+                    h = float(base_h.get((bi, bj), off['hours'].median()))
+                    if i != bi or j != bj:      # at least one clone: jitter
+                        h *= rng.uniform(0.9, 1.1)
+                seen[key] = max(h, 0.02)
+            h = seen[key]
+        rows.append({'from': i, 'to': j, 'hours': h})
+FL['travel'] = pd.DataFrame(rows)
+with open(f'/tmp/c5/fleetc_k{K}.pkl', 'wb') as f:
+    pickle.dump(FL, f)
+print(f'k={K}: cluster travel written ({len(blds)} buildings)')

agent_reports_bgkf/artifacts/travel_map.py

@@ -0,0 +1,93 @@
+"""Map-faithful travel for synthetic fleets (per the competition map:
+one dominant metro cluster + small satellite clumps, hours apart).
+
+Clusters inferred from the real travel matrix (average-linkage, 1h cut:
+sizes [18,2,1,1,1,1]). Each CLONE building is assigned to a cluster with
+probability proportional to real cluster size; its distances are sampled
+from the empirical intra-cluster hop distribution (satellite clumps: the
+map shows tight multi-dot sites -> local hops ~0.05-0.15h) and the real
+between-cluster block distances. Fleet/telemetry unchanged.
+fleet_k{K}.pkl -> fleetm_k{K}.pkl
+"""
+import sys, pickle
+from pathlib import Path
+import numpy as np, pandas as pd
+from scipy.cluster.hierarchy import linkage, fcluster
+from scipy.spatial.distance import squareform
+
+sys.path.insert(0, '/Users/THIF/repos/BatterySwapAI2026-Example')
+from batteryswap_public.utils import load_dataset
+
+K = int(sys.argv[1])
+rng = np.random.default_rng(1000 + K)
+*_, sc = load_dataset(Path('/Users/THIF/repos/BatterySwapAI2026-Example/dataset/train'))
+tc = sc[0]['travel_costs']
+piv = tc.pivot(index='from', columns='to', values='hours')
+order = sorted(piv.index)
+piv = piv.reindex(index=order, columns=order)
+D = (piv.values + piv.values.T) / 2
+np.fill_diagonal(D, 0)
+lab = fcluster(linkage(squareform(D, checks=False), method='average'),
+               t=1.0, criterion='distance')
+clus = pd.Series(lab, index=order)
+sizes = clus.value_counts()
+
+def intra_pool(c):
+    m = clus[clus == c].index
+    if len(m) < 2:
+        return np.array([0.08])           # tight clump scale (map dots)
+    ix = [order.index(b) for b in m]
+    v = D[np.ix_(ix, ix)][np.triu_indices(len(ix), 1)]
+    return v[v > 0] if (v > 0).any() else np.array([0.08])
+
+def between_pool(c1, c2):
+    m1 = [order.index(b) for b in clus[clus == c1].index]
+    m2 = [order.index(b) for b in clus[clus == c2].index]
+    return D[np.ix_(m1, m2)].ravel()
+
+INTRA = {c: intra_pool(c) for c in sizes.index}
+BETW = {(a, b): between_pool(a, b) for a in sizes.index for b in sizes.index
+        if a != b}
+
+with open(f'/tmp/c5/fleet_k{K}.pkl', 'rb') as f:
+    FL = pickle.load(f)
+locs = FL['locations']
+base_of = locs.drop_duplicates('building').set_index('building')['base_building']
+blds = sorted(locs['building'].unique())
+
+# cluster of every synthetic building: originals keep theirs; clones drawn
+# proportional to real cluster sizes (metro gets ~75% of new buildings)
+p = (sizes / sizes.sum()).sort_index()
+assign = {}
+for b in blds:
+    if b in clus.index:
+        assign[b] = int(clus[b])
+    else:
+        assign[b] = int(rng.choice(p.index.to_numpy(), p=p.to_numpy()))
+
+rows, seen = [], {}
+for i in blds:
+    for j in blds:
+        if i == j:
+            h = 0.0
+        else:
+            key = tuple(sorted((i, j)))
+            if key not in seen:
+                ci, cj = assign[i], assign[j]
+                both_real = i in clus.index and j in clus.index
+                if both_real:
+                    h = float(D[order.index(i), order.index(j)])
+                elif ci == cj:
+                    h = float(rng.choice(INTRA[ci])) * rng.uniform(0.7, 1.3)
+                else:
+                    h = float(rng.choice(BETW[(ci, cj)])) * rng.uniform(0.9, 1.1)
+                seen[key] = max(h, 0.02)
+            h = seen[key]
+        rows.append({'from': i, 'to': j, 'hours': h})
+FL['travel'] = pd.DataFrame(rows)
+with open(f'/tmp/c5/fleetm_k{K}.pkl', 'wb') as f:
+    pickle.dump(FL, f)
+n_new = sum(1 for b in blds if b not in clus.index)
+metro = sizes.idxmax()
+share = sum(1 for b in blds if assign[b] == metro) / len(blds)
+print(f'k={K}: {len(blds)} buildings ({n_new} new), metro share {share:.2f}')

agent_reports_bgkf/c3_findings.md

@@ -208,3 +208,20 @@ FINDINGS:
 
 Artifacts: /tmp/c5/ (generator synth.py, runner scale_run.py, fleets,
 per-arm CSVs, /tmp/cv_bgkfcand_ft2fix.csv).
+
+## Phase 62 postscript: geography robustness (user's map)
+
+The real travel matrix clusters exactly like the competition map (average
+linkage, 1h cut): one 18-building metro + one pair + four satellite
+singletons; intra-metro hops median 0.25h, nearest-neighbour hops ~0.08h,
+cross-cluster up to 10h. Two additional synthetic geographies were run at
+k=2/4 (fleets unchanged, travel rebuilt): CLUSTER-LOCAL (clones one
+nearest-neighbour-scale hop from their base) and MAP-FAITHFUL (clones
+assigned to clusters proportional to real cluster sizes - metro share
+.75/.78 - with intra/inter distances sampled from the empirical
+distributions). Per-device costs moved by <2% in every cell and the arm
+ranking never changed (champ ~= ft2 at 2x, mild ft2 inversion at 4x,
+alpha 1.0 best everywhere). Cost is dominated by late/early, not travel:
+the scaling verdict is geography-insensitive. Stopped early per user (two
+k=4 alpha arms unfinished - pattern already unambiguous). Artifacts:
+/tmp/c5/travel_map.py, travel_cluster.py, scalem_*/scalec_* CSVs.