Phase 62: synthetic scaling study (1x/2x/4x, official-mechanism EOLs); count rule scales cleanly; fixed-ref vmin7 dial (default off); alpha-1.0 edge holds at every scale

EXPERIMENTS.md

@@ -3305,3 +3305,17 @@ zero catches) was on the OLD ordering; whether ft2's ordering converts
 extra appetite publicly is the one open question a public trigger can
 answer. PREPARED: commit 296f8f2 = alpha 1.0 on ft2 (single variable,
 selectable for public scoring); head 7d7632c keeps the safe 0.8.
+
+## Phase 62 - synthetic scaling study (user directive): CV tested on fleet-size scaling; fixed-reference vmin7 dial shipped
+
+Synthetic fleets at 1x/2x/4x (461/922/1844 devices) from time-shifted
+building clones with OFFICIAL-mechanism-derived EOLs (0 mismatches on the
+checkable set at every scale); deployment-faithful static-path runs;
+anchor k=1 champ = 1762.5 ~= bgkf 1760.2 (same recall .471). Verdicts:
+count rule scales cleanly (swaps/death 0.98-1.07); live-rank vmin7_rank
+decays and inverts at 4x while a train-ECDF fixed-reference form is
+scale-neutral (shipped as BATTERYSWAP_FT2_FIXEDREF, default 0 - the Docker
+rehearsal measured 922-device splits = the safe 2x regime); alpha 1.0 best
+at EVERY scale with recall +7pts held (third independent support for the
+296f8f2 public A/B); runtime 3.4s/scenario at 4x - no budget risk. Full
+tables: agent_reports_bgkf/c3_findings.md.

agent_reports_bgkf/artifacts/scale_run.py

@@ -0,0 +1,147 @@
+"""Scaling evaluation: run an arm on a synthetic fleet at scale K.
+
+Deployment-faithful: ONE static fit on the real packaged train table
+(submit.py's held-out branch), then the 48 real scenario times planned on
+the synthetic fleet and costed by the real evaluator with derived EOLs.
+
+Arms: champ (plain logbag, alpha .8) | ft2 (frontier, alpha .8)
+      | ft2a10 (frontier, alpha 1.0)
+Usage: scale_run.py K ARM
+"""
+import sys, time, pickle
+from pathlib import Path
+import numpy as np
+import pandas as pd
+
+OURS = Path('/Users/THIF/repos/BatterySwapAI2026-Example')
+sys.path.insert(0, str(OURS))
+from batteryswap_public.utils import load_dataset, iterate_scenarios
+from batteryswap_public.evaluate import evaluate_plan
+from batteryswap_example.features import (
+    daily_voltage, daily_all, weekly_betas, master_curve, physics_features,
+    features_at_origin, WINDOW_DAYS, BETA_DEFAULT)
+from batteryswap_example.fht_features import daily_corrected, wiener_at_origin
+import batteryswap_example.models_cv as mc
+import batteryswap_example.submit as sub
+
+K = int(sys.argv[1])
+ARM = sys.argv[2]
+ALPHA = 1.0 if ARM.endswith('a10') else 0.8
+if ARM == 'ft2fix':
+    ALPHA = 0.8
+
+with open(f'/tmp/c5/fleet_k{K}.pkl', 'rb') as f:
+    FL = pickle.load(f)
+locations = FL['locations']
+for _c in ('start_time', 'end_time'):
+    if getattr(locations[_c].dt, 'tz', None) is not None:
+        locations[_c] = locations[_c].dt.tz_localize(None)
+eol = FL['eol']
+if getattr(eol.dt, 'tz', None) is not None:
+    eol = eol.dt.tz_localize(None)
+travel = FL['travel']
+ts = FL['ts'].set_index(['device_id', 'end_time']).sort_index()
+
+_, _, eol_real, scenarios = load_dataset(OURS / 'dataset/train')
+# fleet-wide EOL series shaped like load_dataset's (NaT for survivors);
+# clone-0 devices take the OFFICIAL values (exact), shifted clones the
+# telemetry-derived ones (0 mismatches on the checkable set). The 6 real
+# deaths the derivation misses become permanent low-voltage "ghosts" in
+# shifted clones - noted, and shared by every arm equally.
+eol_syn = eol.reindex(locations['battery'])
+eol_syn.index = locations['battery']
+er = eol_real.copy()
+if getattr(er.dt, 'tz', None) is not None:
+    er = er.dt.tz_localize(None)
+c0 = eol_syn.index.intersection(er.index)
+eol_syn.loc[c0] = er.reindex(c0)
+# scenarios with the synthetic travel matrix
+scenarios = [dict(sc, travel_costs=travel) for sc in scenarios]
+GEN = list(iterate_scenarios(locations, ts, eol_syn, scenarios))
+
+# ---- one static foreign fit (the deployment path) ----
+base = pd.read_parquet(OURS / 'batteryswap_example/data/train_features.parquet')
+base = base[base['window_closed']]
+model = (mc.SklearnRUL('logbag') if ARM == 'champ' else sub.Ft2RUL()).fit(base)
+if ARM == 'ft2fix':
+    # scale hardening: vmin7_rank as a FIXED-reference percentile (train
+    # ECDF of v_min_7) instead of a live-fleet rank - fleet-size invariant
+    _q = np.sort(base['v_min_7'].dropna().to_numpy())
+    _inner = model
+    class _Fix:
+        def predict(self, rows):
+            r = rows.copy()
+            v = r['v_min_7'].to_numpy(dtype=float)
+            pct = np.searchsorted(_q, v, side='right') / len(_q)
+            r['vmin7_rank'] = np.where(np.isfinite(v), pct, np.nan)
+            return _inner.predict(r)
+    model = _Fix()
+
+# ---- per-fleet caches ----
+t0 = time.time()
+daily = daily_voltage(ts)
+dall = daily_all(ts)
+betas = weekly_betas(dall)
+fd = daily_corrected(ts)
+print(f'fleet caches {time.time()-t0:.0f}s', file=sys.stderr, flush=True)
+
+p = mc.plan_tsroute
+p.alpha = ALPHA
+p.ec_margin, p.ec_pmax = 0.8, 25.0
+p.split_days = 7
+p.floor_scale, p.recent_deaths = 2.5, 0.0
+
+W = pd.Timedelta(days=WINDOW_DAYS)
+recs = []
+for i, (sc, fleet, cut, eol_f) in enumerate(GEN):
+    T = pd.Timestamp(sc['start_time'])
+    tt = time.time()
+    feats = features_at_origin(daily, fleet, T)
+    past = betas[betas['week_end'] <= T]['beta']
+    beta = float(past.median()) if len(past) >= 20 else BETA_DEFAULT
+    dead = eol[eol.notna() & (eol <= T)]
+    curve = master_curve(dall[dall['day'] <= T], dead, beta)
+    feats = feats.join(physics_features(dall, T, beta, curve, match=False))
+    if ARM != 'champ':
+        feats = feats.join(wiener_at_origin(
+            fd, T.tz_localize(None) if T.tz is not None else T))
+    feats = feats.reindex(fleet['battery'])
+    t_feat = time.time() - tt
+
+    pred = model.predict(feats)
+    t_pred = time.time() - tt - t_feat
+    plan = mc.plan_tsroute(pred, None, fleet, T, 0.05,
+                           travel_costs=travel, settings=sc['settings'])
+    t_plan = time.time() - tt - t_feat - t_pred
+    _, _, overall = evaluate_plan(plan, fleet, travel, sc['settings'],
+                                  eol_times=eol_f, start_time=T)
+    pday = plan['day']
+    if getattr(pday.dt, 'tz', None) is not None:
+        pday = pday.dt.tz_localize(None)
+    Tn = T.tz_localize(None) if T.tz is not None else T
+    inwin = plan[(pday <= Tn + W).values]
+    swap_day = inwin.groupby('battery')['day'].min()
+    dies = eol[(eol > Tn) & (eol <= Tn + W)
+               & eol.index.isin(set(fleet['battery']))]
+    caught = int(dies.index.isin(swap_day.index).sum())
+    recs.append(dict(overall, origin=i, n_swaps=int(inwin['battery'].nunique()),
+                     deaths=len(dies), caught=caught,
+                     t_feat=t_feat, t_pred=t_pred, t_plan=t_plan))
+    print(f's_{i}: {overall["total_cost"]:8.1f} deaths {len(dies):3d} '
+          f'caught {caught:3d} swaps {recs[-1]["n_swaps"]:3d} '
+          f'[f{t_feat:.1f} p{t_pred:.1f} pl{t_plan:.1f}s]',
+          file=sys.stderr, flush=True)
+
+df = pd.DataFrame(recs)
+df.to_csv(f'/tmp/c5/scale_k{K}_{ARM}.csv', index=False)
+n_dev = locations['battery'].nunique()
+print(f"\nK={K} ARM={ARM}  devices={n_dev}")
+print(f"  mean total/scenario {df['total_cost'].mean():9.1f}   "
+      f"per-DEVICE {df['total_cost'].mean()/n_dev:7.3f}")
+print(f"  swaps/scen {df['n_swaps'].mean():6.1f}  deaths/scen "
+      f"{df['deaths'].mean():5.1f}  recall {df['caught'].sum()/max(df['deaths'].sum(),1):.3f}  "
+      f"swaps/death {df['n_swaps'].sum()/max(df['deaths'].sum(),1):.2f}")
+print(f"  late/scen {df['late_swap'].mean():7.1f}  early/scen "
+      f"{df['early_swap'].mean():7.1f}")
+print(f"  sec/scenario: feat {df['t_feat'].mean():.1f} pred "
+      f"{df['t_pred'].mean():.1f} plan {df['t_plan'].mean():.1f}")

agent_reports_bgkf/artifacts/synth.py

@@ -0,0 +1,102 @@
+"""Synthetic fleet generator for the SCALING evaluation.
+
+Fleet at scale k = k time-shifted clones of each real building. Each clone
+building gets ONE shift (preserves within-building death correlation,
+decorrelates clone sets). Ground-truth EOL is DERIVED from the shifted
+telemetry with the official mechanism (7d-median < 2.40, validated 81/81
+by the team repo) - labels stay mechanically consistent with the data.
+Travel: distance between clones = distance between base buildings;
+same-base clone pairs get the median off-diagonal hop.
+
+Writes /tmp/c5/fleet_k{K}.pkl with: timeseries, locations, eol, travel fn.
+"""
+import sys, pickle, time
+from pathlib import Path
+import numpy as np
+import pandas as pd
+
+TEAM = Path('/tmp/teamrepo')
+OURS = Path('/Users/THIF/repos/BatterySwapAI2026-Example')
+sys.path.insert(0, str(TEAM))
+sys.path.insert(0, str(OURS))
+from batteryswap_public.utils import load_dataset
+from features import daily_panel, eol_from_panel
+
+K = int(sys.argv[1]) if len(sys.argv) > 1 else 2
+SEED = 7
+
+locations, ts, eol_times, scenarios = load_dataset(OURS / 'dataset/train')
+df = ts.reset_index()
+df['device_id'] = df['device_id'].astype(str)
+dev = pd.read_csv(OURS / 'dataset/train/devices.csv').drop_duplicates('device_id')
+span_lo = df['end_time'].min()
+span_hi = df['end_time'].max()
+
+rng = np.random.default_rng(SEED)
+frames, loc_rows = [], []
+for c in range(K):
+    for b, sub in dev.groupby('building_id'):
+        # clone 0 of each building = the untouched original (scale anchor)
+        shift = 0 if c == 0 else int(rng.integers(-120, 121))
+        sb = b if c == 0 else f'{b}_c{c}'
+        for _, r in sub.iterrows():
+            sd = r['device_id'] if c == 0 else f"{r['device_id']}_c{c}"
+            d = df[df['device_id'] == r['device_id']].copy()
+            d['device_id'] = sd
+            d['end_time'] = d['end_time'] + pd.Timedelta(days=shift)
+            d = d[(d['end_time'] >= span_lo) & (d['end_time'] <= span_hi)]
+            if len(d) < 50:
+                continue
+            frames.append(d)
+            loc_rows.append(dict(battery=sd, building=sb,
+                                 room=(r['room_id'] if c == 0
+                                       else f"{r['room_id']}_c{c}"),
+                                 base_building=b,
+                                 start_time=pd.Timestamp(r['start_time'])
+                                 + pd.Timedelta(days=shift),
+                                 end_time=pd.Timestamp(r['end_time'])
+                                 + pd.Timedelta(days=shift)))
+
+sts = pd.concat(frames, ignore_index=True)
+locs = pd.DataFrame(loc_rows)
+for col in ('start_time', 'end_time'):
+    locs[col] = pd.to_datetime(locs[col], utc=True)
+
+t0 = time.time()
+panel = daily_panel(sts.set_index(['device_id', 'end_time']))
+eol = eol_from_panel(panel)
+print(f'k={K}: {locs.battery.nunique()} devices, '
+      f'{locs.building.nunique()} buildings, {len(eol)} EOLs '
+      f'(panel {time.time()-t0:.0f}s)')
+
+# sanity: clone-0 EOLs must match the official file exactly
+official = pd.read_csv(OURS / 'dataset/train/eol_times.csv')
+col = [c for c in official.columns if c != 'device_id'][0]
+truth = pd.to_datetime(official.set_index('device_id')[col]).dt.tz_localize(None)
+c0 = eol[~eol.index.str.contains('_c')]
+both = truth.dropna().index.intersection(c0.index)
+mism = int((pd.to_datetime(c0.reindex(both)).dt.normalize()
+            != truth.reindex(both).dt.normalize()).sum())
+print(f'clone-0 EOL check: {len(both)} deaths, {mism} mismatches')
+
+# travel-cost template: base 24x24 matrix from scenario 0
+tc0 = scenarios[0]['travel_costs']
+base_h = tc0.set_index(['from', 'to'])['hours']
+med_hop = tc0.loc[tc0['from'] != tc0['to'], 'hours'].median()
+blds = sorted(locs['building'].unique())
+base_of = locs.drop_duplicates('building').set_index('building')['base_building']
+rows = []
+for i in blds:
+    for j in blds:
+        if i == j:
+            h = 0.0
+        else:
+            bi, bj = base_of[i], base_of[j]
+            h = med_hop if bi == bj else float(base_h.get((bi, bj), med_hop))
+        rows.append(dict(**{'from': i, 'to': j}, hours=h))
+travel = pd.DataFrame(rows)
+
+with open(f'/tmp/c5/fleet_k{K}.pkl', 'wb') as f:
+    pickle.dump(dict(ts=sts, locations=locs, eol=pd.to_datetime(eol),
+                     travel=travel), f)
+print(f'wrote /tmp/c5/fleet_k{K}.pkl')

agent_reports_bgkf/c3_findings.md

@@ -167,3 +167,44 @@ trigger can answer it. Prepared as a one-click experiment:
 **commit 296f8f2 = alpha 1.0 on the ft2 frontier** (single variable);
 head 7d7632c stays at the safe 0.8. Pushes are scoring-inert - 296f8f2
 only runs if the user triggers it.
+
+## SCALING EVALUATION (user directive, phase 62): synthetic fleets 1x/2x/4x
+
+Construction: fleets of 461/922/1844 devices (24/48/96 buildings) = time-
+shifted clones of real buildings (one shift per clone building; clone-0 =
+the untouched real fleet); ground-truth EOLs DERIVED from the shifted
+telemetry with the official label mechanism (clone-0 check: 0 mismatches
+at every scale). Deployment-faithful runs: one static fit on the shipped
+train table, submit.py's per-scenario feature path, real evaluator,
+synthetic travel matrix. ANCHOR: k=1 champ = 1762.5/scenario ~= the bgkf
+baseline 1760.2 with the same recall (.471) - the instrument calibrates.
+Clone bias affects levels, cancels across scales and arms.
+
+| per-device cost | k=1 | k=2 | k=4 | recall k1->k4 |
+|---|---|---|---|---|
+| champ (logbag, a.8) | 3.823 | 3.891 | 4.438 | .471 -> .453 |
+| ft2 (live-rank) | 3.713 | 3.874 | 4.506 | .489 -> .448 |
+| ft2 FIXED-REF vmin7 | 3.736 | 3.848 | 4.443 | .491 -> .457 |
+| ft2 + alpha 1.0 | 3.523 | 3.569 | 4.020 | .545 -> .522 |
+
+FINDINGS:
+1. COUNT RULE SCALES CLEANLY: swaps/death 0.98-1.07 at every scale for the
+   alpha-.8 arms - sum(p42) tracks prevalence linearly. No calibration
+   risk at large fleets.
+2. LIVE-RANK vmin7 DECAYS with fleet size and inverts at 4x. Fixed-
+   reference percentile (train ECDF of v_min_7) removes the decay; on the
+   standard bgkf it costs +2.1 +/- 14.4 (free at the mean, 8W/27L slightly
+   sign-worse on small fleets). SHIPPED AS A DIAL:
+   BATTERYSWAP_FT2_FIXEDREF (default 0). The Docker rehearsal MEASURED the
+   real splits at 922 devices (= k=2, where live-rank is still fine), so
+   the dial stays off; flip it if fleets turn out much larger. (The
+   "4000 total" figure is inconsistent with the rehearsal's observation.)
+3. ALPHA 1.0 IS THE BEST ARM AT EVERY SCALE and its edge GROWS absolutely
+   with fleet size (recall +7pts held at 4x; swaps/death stable 1.15-1.22).
+   Third independent line (bgkf mean, podium operating points, synthetic
+   scaling) behind the 296f8f2 public A/B.
+4. RUNTIME IS A NON-ISSUE: 3.4s/scenario at 1844 devices (feat 0.7 + plan
+   2.0-2.7) ~= 3 min/split even at 4x fleets, far inside the 20-min budget.
+
+Artifacts: /tmp/c5/ (generator synth.py, runner scale_run.py, fleets,
+per-arm CSVs, /tmp/cv_bgkfcand_ft2fix.csv).

batteryswap_example/submit.py

@@ -212,6 +212,16 @@ class FrontierRUL:
 # any fit error falls back to the legacy champion via _fit_model.
 FT2 = os.environ.get('BATTERYSWAP_FT2', '1') != '0'
 FT2_W = float(os.environ.get('BATTERYSWAP_FT2_W', '0.20'))
+# Scale hardening (phase 62 synthetic scaling study): vmin7_rank as a
+# FIXED-reference percentile (train ECDF of v_min_7) instead of the scored
+# fleet's live rank. Live-rank ft2's edge decays with fleet size and
+# inverts at 4x (per-device 4.506 vs champ 4.438 at 1844 devices); the
+# fixed form is scale-neutral (4.443) and best at 2x (3.848). Cost on the
+# standard bgkf instrument: +2.1 +/- 14.4 (free at the mean, slightly
+# sign-worse on small fleets). Docker rehearsal measured the real splits
+# at 922 devices (= the 2x regime, where live-rank is fine), so this ships
+# OFF - flip to 1 if the scored fleets turn out much larger than 922.
+FT2_FIXEDREF = os.environ.get('BATTERYSWAP_FT2_FIXEDREF', '0') != '0'
 
 
 class Ft2RUL:
@@ -239,9 +249,16 @@ class Ft2RUL:
             self.primary = SklearnRUL(MODEL_KIND).fit(train)
             self.wiener = (models_cv.WienerFHT().fit(train)
                            if FT2_W > 0 and 'wnr_n' in train.columns else None)
+        self._ecdf = (np.sort(train['v_min_7'].dropna().to_numpy())
+                      if FT2_FIXEDREF and 'v_min_7' in train.columns else None)
         return self
 
     def predict(self, rows):
+        if self._ecdf is not None and 'v_min_7' in rows.columns:
+            rows = rows.copy()
+            v = rows['v_min_7'].to_numpy(dtype=float)
+            pct = np.searchsorted(self._ecdf, v, side='right') / len(self._ecdf)
+            rows['vmin7_rank'] = np.where(np.isfinite(v), pct, np.nan)
         if 'vmin7_rank' not in rows.columns:
             rows = rows.copy()
             rows['vmin7_rank'] = (rows['v_min_7'].rank(pct=True)