Upload fork.js with huggingface_hub

fork.js

@@ -52,16 +52,16 @@ function rig() {
 function query(append) {
   const r = rig();
   const pair = $("#kv").value;
-  // upstream kv_type only accepts f16/q8_0/q4_0 with K=V, so always ask
-  // f16 and rescale client-side (rescaleKvFits). the server's f16-based
-  // fit filtering would wrongly exclude models that fit under a smaller
-  // KV, so it is forced off whenever rescaling; the client ranker already
-  // drops non-fits itself (best-sort path included).
-  const rescaled = kvScale(pair) < 1;
+  // upstream kv_type only accepts f16/q8_0/q4_0 with K=V. ask q8_0 and
+  // rescale client-side (rescaleKvFits): q8_0-based scores and fits are
+  // close to every smaller pair, so the page stays nearly consistent
+  // (an f16 base would leave every score stale). f16/bf16 ask f16.
+  const q8base = pair !== "f16/f16" && pair !== "bf16/bf16";
+  const rescaled = q8base ? kvScale(pair) * 16 / 8.5 < 1 : false;
   return {
     hardware: { kind: r.kind, gpus: r.gpus, ram_gb: r.ram_gb,
       ...(r.unified_system ? { unified_system: r.unified_system } : {}) },
-    context: +$("#ctx").value, kv_type: "f16", kv_pair: pair,
+    context: +$("#ctx").value, kv_type: q8base ? "q8_0" : "f16", kv_pair: pair,
     min_bits: +$("#min-bits").value,
     sort: $("#sort").value, family: $("#family").value || null, size: $("#size").value || null,
     search: $("#search").value.trim() || null,
@@ -319,7 +319,10 @@ function kvScale(pair) {
 // pass through untouched. Only full tiers and failing tiers are adjusted;
 // partial offloads keep the estimator's f16 numbers (conservative).
 function rescaleKvFits(d, pair, ctx, hw) {
-  const ratio = kvScale(pair);
+  // ratio is against the queried base: q8_0 for everything below it,
+  // f16 for f16/bf16 (ratio 1, no-op). see query().
+  const base = pair === "f16/f16" || pair === "bf16/bf16" ? 16 : 8.5;
+  const ratio = kvScale(pair) * 16 / base;
   if (!(ratio < 1)) return;
   const kvf = d.kv_cache_gb && d.kv_cache_gb[String(ctx)];
   if (!(kvf > 0)) return;
@@ -328,14 +331,20 @@ function rescaleKvFits(d, pair, ctx, hw) {
   d.kv_cache_gb = scaled;
   const delta = kvf * (1 - ratio);
   const vram = hw.kind === "gpu" ? hw.gpus.reduce((a, x) => a + x, 0) : 0;
-  // per-model overhead + RAM constant, calibrated off a passing full-tier
-  // option so the rescale never invents numbers, only shrinks the KV part.
-  let oh = 1.3, ramConst = 1.2;
-  const ref = (d.options || []).find((o) => o.fit &&
-    (o.fit.tier === "gpu" || o.fit.tier === "cpu" || o.fit.tier === "ram"));
-  if (ref) {
-    oh = Math.max(0, (ref.fit.gpu_gb || ref.fit.ram_gb || 0) - ref.size / 1e9 - kvf);
-    if (ref.fit.tier === "gpu") ramConst = ref.fit.ram_gb || ramConst;
+  // per-model overhead + RAM constant: median over the estimator's own
+  // full-gpu options (single-option calibration flips picks on 0.2GB
+  // noise; the backend's implied overhead spans ~1.7-2.8 per model).
+  let oh = 1.75, ramConst = 1.2;
+  const gpuRefs = (d.options || []).filter((o) => o.fit && o.fit.tier === "gpu");
+  if (gpuRefs.length) {
+    const med = (xs) => { const s = xs.filter((x) => x > 0).sort((a, b) => a - b);
+      return s.length ? s[Math.floor(s.length / 2)] : null; };
+    oh = med(gpuRefs.map((o) => (o.fit.gpu_gb || 0) - o.size / 1e9 - kvf)) ?? oh;
+    ramConst = med(gpuRefs.map((o) => o.fit.ram_gb || 0)) ?? ramConst;
+  } else {
+    const ref = (d.options || []).find((o) => o.fit &&
+      (o.fit.tier === "cpu" || o.fit.tier === "ram"));
+    if (ref) oh = Math.max(0, (ref.fit.gpu_gb || ref.fit.ram_gb || 0) - ref.size / 1e9 - kvf);
   }
   const full = (o, tier, gpuGb, ramGb, label) => {
     o.fit.tier = tier; o.fit.gpu_gb = gpuGb; o.fit.ram_gb = ramGb;