Update index.html

index.html

@@ -628,8 +628,8 @@
           <div class="eyebrow">Regression explorer</div>
           <h1><span class="title-silver">SLM Regression Line Benchmark</span></h1>
           <p class="sub">
-            Choose a benchmark, fit a linear regression on <strong>log10(parameters)</strong>, and compare models to the size trend.
-            Search and org filters only change what is visible. The regression line stays anchored to the full eligible dataset for the selected benchmark.
+            Choose a benchmark, fit a robust linear line on <strong>log10(parameters)</strong>, and compare models to the size trend.
+            Search and org filters only change what is visible. The line stays anchored to the full eligible dataset for the selected benchmark.
             Models below <strong>500k parameters</strong> are clipped from the plot and excluded from the fit so they do not crush the scale.
           </p>
         </div>
@@ -708,13 +708,13 @@
         <div class="section desktop-only">
           <span class="section-label">Regression stats</span>
           <div class="stat-grid">
-            <div class="stat"><div class="k">Slope</div><div class="v" id="statSlope">—</div></div>
-            <div class="stat"><div class="k">Intercept</div><div class="v" id="statIntercept">—</div></div>
-            <div class="stat"><div class="k">MSE</div><div class="v" id="statMSE">—</div></div>
+            <div class="stat"><div class="k">Curvature</div><div class="v" id="statSlope">—</div></div>
+            <div class="stat"><div class="k">Mid-slope</div><div class="v" id="statIntercept">—</div></div>
+            <div class="stat"><div class="k">Center score</div><div class="v" id="statMSE">—</div></div>
             <div class="stat"><div class="k">RMSE</div><div class="v" id="statRMSE">—</div></div>
             <div class="stat"><div class="k">R²</div><div class="v" id="statR2">—</div></div>
           </div>
-          <div class="small-note" id="fitNote">The fit is locked to the full eligible dataset for the selected benchmark.</div>
+          <div class="small-note" id="fitNote">The line is locked to the full eligible dataset for the selected benchmark.</div>
         </div>
       </aside>
 
@@ -723,13 +723,13 @@
           <div class="chart-top">
             <div>
               <h2 class="chart-title" id="chartTitle">Average score vs log parameters</h2>
-              <p class="chart-sub" id="chartSub">Silver regression line fit globally for the selected benchmark. Search and org filtering only hide points.</p>
+              <p class="chart-sub" id="chartSub">Binned linear regression on log10(parameters) for the selected benchmark. Each size bin contributes one equally weighted sample, so the line tracks the average score by parameter region instead of point density.</p>
               <div class="callout">
                 <span class="dot"></span>
-                <span>Hover for details. Click a point to open the model page. The line is fit globally for the selected benchmark.</span>
+                <span>Hover for details. Click a point to open the model page. The line is fit globally with a robust quadratic estimator for the selected benchmark.</span>
               </div>
             </div>
-            <div class="badge" id="countBadge">0 visible / 0 fit</div>
+            <div class="badge" id="countBadge">0 visible / 0 bins</div>
           </div>
           <div class="canvas-wrap">
             <canvas id="scatterChart"></canvas>
@@ -739,7 +739,7 @@
         <section class="info-grid desktop-only">
           <div class="info-card"><div class="label">Selected benchmark</div><div class="big" id="infoBenchmark">Avg</div></div>
           <div class="info-card"><div class="label">Visible models</div><div class="big" id="infoCount">0</div></div>
-          <div class="info-card"><div class="label">Fit models</div><div class="big" id="infoFitCount">0</div></div>
+          <div class="info-card"><div class="label">Fit bins</div><div class="big" id="infoFitCount">0</div></div>
           <div class="info-card"><div class="label">Mean absolute residual</div><div class="big" id="infoMAE">—</div></div>
           <div class="info-card"><div class="label">Residual spread</div><div class="big" id="infoResidualSpread">—</div></div>
           <div class="info-card"><div class="label">Visible match rate</div><div class="big" id="infoMatchRate">—</div></div>
@@ -748,8 +748,8 @@
         </section>
 
         <section class="disclaimer desktop-only">
-          <strong>Disclaimer:</strong> the regression line is fit only to the full eligible dataset for the selected benchmark, using <strong>log10(parameters)</strong> as x and the selected benchmark score as y.
-          Search and org filtering only hide points from the chart. Residuals are measured in score points after converting scores to percentages.
+          <strong>Disclaimer:</strong> the regression line is fit using <strong>log10(parameters)</strong> as x and the selected benchmark score as y, but the samples are first collapsed into equal-weight size bins so the line reflects the average score by parameter region rather than point density.
+          The displayed line uses a robust binned fit that downweights outliers while keeping each parameter-size region equally represented. Search and org filtering only hide points from the chart. Residuals are measured in score points after converting scores to percentages.
           <strong>RMSE</strong> is the square root of mean squared error, and <strong>R²</strong> describes how much of the variation is explained by the line.
           Models with fewer than <strong>500k parameters</strong> are clipped from the view and excluded from the fit so they do not compress the plot.
 
@@ -959,6 +959,66 @@
       return 'gt500m';
     }
 
+
+    function trimmedMean(values, trimFraction = 0.1) {
+      const arr = values.filter(Number.isFinite).sort((a, b) => a - b);
+      if (!arr.length) return 0;
+      const trim = Math.floor(arr.length * trimFraction);
+      const sliced = arr.slice(trim, Math.max(trim + 1, arr.length - trim));
+      const used = sliced.length ? sliced : arr;
+      return used.reduce((a, b) => a + b, 0) / used.length;
+    }
+
+    function buildBinnedFitSamples(points) {
+      if (!Array.isArray(points) || points.length < 2) return [];
+
+      const xs = points.map(p => p.x).filter(Number.isFinite);
+      if (!xs.length) return [];
+
+      const minX = Math.min(...xs);
+      const maxX = Math.max(...xs);
+      const range = Math.max(1e-6, maxX - minX);
+
+      const targetBins = Math.max(5, Math.min(14, Math.round(Math.sqrt(points.length))));
+      const binWidth = Math.max(0.08, range / targetBins);
+      const firstEdge = Math.floor(minX / binWidth) * binWidth;
+
+      const bins = new Map();
+      for (const p of points) {
+        const idx = Math.floor((p.x - firstEdge) / binWidth);
+        if (!bins.has(idx)) bins.set(idx, []);
+        bins.get(idx).push(p);
+      }
+
+      const samples = [];
+      for (const [idx, group] of [...bins.entries()].sort((a, b) => a[0] - b[0])) {
+        const xsInBin = group.map(p => p.x).filter(Number.isFinite);
+        const ysInBin = group.map(p => p.y).filter(Number.isFinite);
+        if (!xsInBin.length || !ysInBin.length) continue;
+
+        const binX = xsInBin.reduce((a, b) => a + b, 0) / xsInBin.length;
+        const binY = ysInBin.length >= 4
+          ? trimmedMean(ysInBin, 0.15)
+          : (ysInBin.reduce((a, b) => a + b, 0) / ysInBin.length);
+
+        samples.push({
+          x: binX,
+          y: binY,
+          count: 1,
+          modelCount: group.length,
+          binIndex: idx,
+          params: group[0]?.params,
+          name: `${group.length} models in size bin`,
+          org: 'bin',
+          url: group[0]?.url
+        });
+      }
+
+      samples.sort((a, b) => a.x - b.x);
+      return samples;
+    }
+
+
     function benchmarkFit(key) {
       const fitModels = MODELS.filter(m => {
         const score = getMetricValue(m, key);
@@ -984,16 +1044,19 @@
         };
       });
 
-      const fitSamples = buildFitSamples(fitData);
-      return { fitData, fit: linearRegression(fitSamples), rawFit: linearRegression(fitData) };
+      const fitSamples = buildBinnedFitSamples(fitData);
+      const fit = robustLinearRegression(fitSamples);
+      const rawFit = weightedLinearRegression(fitData);
+      return { fitData, fit, rawFit, fitSamples };
     }
 
+
     function buildPredictionRows(paramCount) {
       return BENCHMARKS.map(({ key, label }) => {
         const bundle = benchmarkFit(key);
         if (!bundle || bundle.fit.n < 2) return { key, label, predicted: null };
         const x = Math.log10(paramCount);
-        return { key, label, predicted: bundle.fit.slope * x + bundle.fit.intercept };
+        return { key, label, predicted: evaluateFit(bundle.fit, x) };
       });
     }
 
@@ -1008,44 +1071,331 @@
       return model[key];
     }
 
-    function linearRegression(points) {
+
+    function median(values) {
+      if (!values.length) return 0;
+      const sorted = [...values].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+    }
+
+    function weightedMedian(values, weights) {
+      const pairs = values
+        .map((v, i) => [v, Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1)])
+        .filter(([v, w]) => Number.isFinite(v) && Number.isFinite(w) && w > 0)
+        .sort((a, b) => a[0] - b[0]);
+
+      if (!pairs.length) return 0;
+
+      const total = pairs.reduce((acc, [, w]) => acc + w, 0);
+      let acc = 0;
+      for (const [value, weight] of pairs) {
+        acc += weight;
+        if (acc >= total / 2) return value;
+      }
+      return pairs[pairs.length - 1][0];
+    }
+
+    function evaluatePolynomial(coefficients, x) {
+      if (!coefficients?.length) return 0;
+      let y = 0;
+      for (let i = 0; i < coefficients.length; i += 1) {
+        y = (y * x) + coefficients[i];
+      }
+      return y;
+    }
+
+    function polynomialDerivative(coefficients, x) {
+      if (!coefficients?.length || coefficients.length < 2) return 0;
+      const degree = coefficients.length - 1;
+      let y = 0;
+      for (let i = 0; i < degree; i += 1) {
+        const power = degree - i;
+        y = (y * x) + (coefficients[i] * power);
+      }
+      return y;
+    }
+
+    function solveLinearSystem(matrix, vector) {
+      const n = vector.length;
+      const a = matrix.map((row, i) => [...row, vector[i]]);
+
+      for (let col = 0; col < n; col += 1) {
+        let pivotRow = col;
+        let pivotAbs = Math.abs(a[col][col]);
+        for (let row = col + 1; row < n; row += 1) {
+          const cand = Math.abs(a[row][col]);
+          if (cand > pivotAbs) {
+            pivotAbs = cand;
+            pivotRow = row;
+          }
+        }
+
+        if (pivotAbs < 1e-12) {
+          return null;
+        }
+
+        if (pivotRow !== col) {
+          const tmp = a[col];
+          a[col] = a[pivotRow];
+          a[pivotRow] = tmp;
+        }
+
+        const pivot = a[col][col];
+        for (let j = col; j <= n; j += 1) {
+          a[col][j] /= pivot;
+        }
+
+        for (let row = 0; row < n; row += 1) {
+          if (row === col) continue;
+          const factor = a[row][col];
+          if (Math.abs(factor) < 1e-12) continue;
+          for (let j = col; j <= n; j += 1) {
+            a[row][j] -= factor * a[col][j];
+          }
+        }
+      }
+
+      return a.map(row => row[n]);
+    }
+
+    function weightedPolynomialRegression(points, degree = 1, weights = null) {
       const n = points.length;
-      let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
-      for (const p of points) {
-        sumX += p.x;
-        sumY += p.y;
-        sumXY += p.x * p.y;
-        sumXX += p.x * p.x;
+      if (!n) return { degree, coefficients: [0], mse: 0, rmse: 0, r2: 0, n: 0, weightSum: 0 };
+
+      const actualDegree = Math.max(0, Math.min(degree, n - 1));
+      const size = actualDegree + 1;
+      const matrix = Array.from({ length: size }, () => Array(size).fill(0));
+      const vector = Array(size).fill(0);
+
+      for (let i = 0; i < n; i += 1) {
+        const p = points[i];
+        const w = Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1);
+        if (!w) continue;
+
+        const basis = [];
+        for (let d = actualDegree; d >= 0; d -= 1) {
+          basis.push(p.x ** d);
+        }
+
+        for (let r = 0; r < size; r += 1) {
+          vector[r] += w * basis[r] * p.y;
+          for (let c = 0; c < size; c += 1) {
+            matrix[r][c] += w * basis[r] * basis[c];
+          }
+        }
+      }
+
+      let coefficients = solveLinearSystem(matrix, vector);
+
+      if (!coefficients) {
+        if (actualDegree === 0) {
+          const avg = points.reduce((acc, p, i) => {
+            const w = Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1);
+            return acc + w * p.y;
+          }, 0);
+          const sw = points.reduce((acc, p, i) => acc + Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1), 0);
+          coefficients = [sw ? avg / sw : 0];
+        } else {
+          return weightedPolynomialRegression(points, actualDegree - 1, weights);
+        }
       }
-      const denom = n * sumXX - sumX * sumX;
-      const slope = Math.abs(denom) < 1e-12 ? 0 : (n * sumXY - sumX * sumY) / denom;
-      const intercept = n ? (sumY - slope * sumX) / n : 0;
-      const yMean = n ? sumY / n : 0;
-      const sst = points.reduce((acc, p) => acc + (p.y - yMean) ** 2, 0);
-      const sse = points.reduce((acc, p) => {
-        const resid = p.y - (slope * p.x + intercept);
-        return acc + resid * resid;
+
+      const predictions = points.map(p => evaluatePolynomial(coefficients, p.x));
+      const sw = points.reduce((acc, p, i) => acc + Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1), 0);
+      const yMean = sw ? points.reduce((acc, p, i) => acc + Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1) * p.y, 0) / sw : 0;
+      const sse = points.reduce((acc, p, i) => {
+        const w = Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1);
+        const resid = p.y - predictions[i];
+        return acc + w * resid * resid;
+      }, 0);
+      const sst = points.reduce((acc, p, i) => {
+        const w = Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1);
+        return acc + w * (p.y - yMean) ** 2;
       }, 0);
-      const mse = n ? sse / n : 0;
+      const mse = sw ? sse / sw : 0;
       const rmse = Math.sqrt(mse);
       const r2 = sst > 0 ? 1 - (sse / sst) : 0;
-      return { slope, intercept, mse, rmse, r2, n };
+      return { degree: actualDegree, coefficients, mse, rmse, r2, n, weightSum: sw };
+    }
+
+    function weightedLinearRegression(points, weights = null) {
+      return weightedPolynomialRegression(points, 1, weights);
+    }
+
+    function linearRegression(points) {
+      return weightedPolynomialRegression(points, 1);
+    }
+
+
+    function robustPolynomialRegression(points, degree = 2) {
+      const n = points.length;
+      if (n < 2) return weightedPolynomialRegression(points, degree);
+
+      const baseWeights = points.map(p => Math.max(1, Number.isFinite(p.count) ? p.count : 1));
+      let weights = [...baseWeights];
+      let fit = weightedPolynomialRegression(points, degree, weights);
+
+      for (let iter = 0; iter < 10; iter += 1) {
+        const residuals = points.map((p, i) => p.y - evaluateFit(fit, p.x));
+        const residMedian = median(residuals);
+        const absDeviations = residuals.map(r => Math.abs(r - residMedian));
+        const scale = Math.max(1e-6, 1.4826 * median(absDeviations));
+        const huberK = 1.345 * scale;
+        const xMedian = median(points.map(p => p.x));
+        const xScale = Math.max(1e-6, 1.4826 * median(points.map(p => Math.abs(p.x - xMedian))));
+
+        const nextWeights = points.map((p, i) => {
+          const resid = Math.abs(residuals[i] - residMedian);
+          let w = baseWeights[i];
+          if (resid > huberK) w *= huberK / resid;
+          const leverage = Math.abs(p.x - xMedian) / xScale;
+          w *= 1 / (1 + 0.18 * leverage + 0.02 * leverage * leverage);
+          return Math.max(w, 1e-6);
+        });
+
+        const next = weightedPolynomialRegression(points, degree, nextWeights);
+        const delta = next.coefficients.reduce((acc, coef, i) => acc + Math.abs((fit.coefficients[i] ?? 0) - coef), 0);
+        fit = next;
+        weights = nextWeights;
+        if (delta < 1e-10) break;
+      }
+
+      const xMean = points.reduce((acc, p, i) => {
+        const w = Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1);
+        return acc + w * p.x;
+      }, 0) / Math.max(1e-12, weights.reduce((a, b) => a + b, 0));
+      fit.xMean = xMean;
+      fit.centerValue = evaluateFit(fit, xMean);
+      fit.centerSlope = polynomialDerivative(fit.coefficients, xMean);
+      fit.curvature = fit.coefficients.length >= 3 ? fit.coefficients[0] : 0;
+      fit.method = `robust-degree-${fit.degree}`;
+      fit.effectiveN = weights.reduce((a, b) => a + b, 0);
+      return fit;
     }
 
-    function buildFitSamples(data) {
-      const groups = new Map();
-      for (const d of data) {
-        const key = String(d.params);
-        if (!groups.has(key)) groups.set(key, []);
-        groups.get(key).push(d);
+    function robustLinearRegression(points) {
+      const n = points.length;
+      if (n < 2) return weightedPolynomialRegression(points, 1);
+
+      const baseWeights = points.map(p => Math.max(1, Number.isFinite(p.count) ? p.count : 1));
+
+      const slopes = [];
+      const slopeWeights = [];
+      for (let i = 0; i < n; i += 1) {
+        for (let j = i + 1; j < n; j += 1) {
+          const dx = points[j].x - points[i].x;
+          if (Math.abs(dx) < 1e-12) continue;
+          slopes.push((points[j].y - points[i].y) / dx);
+          slopeWeights.push(baseWeights[i] * baseWeights[j]);
+        }
+      }
+
+      let slope = slopes.length ? weightedMedian(slopes, slopeWeights) : 0;
+      if (!Number.isFinite(slope)) {
+        slope = weightedLinearRegression(points, baseWeights).coefficients[0] ?? 0;
       }
-      return [...groups.values()]
-        .map(group => {
-          const meanX = group.reduce((a, b) => a + b.x, 0) / group.length;
-          const meanY = group.reduce((a, b) => a + b.y, 0) / group.length;
-          return { x: meanX, y: meanY, count: group.length };
-        })
-        .sort((a, b) => a.x - b.x);
+
+      let intercept = weightedMedian(
+        points.map(p => p.y - slope * p.x),
+        baseWeights
+      );
+      if (!Number.isFinite(intercept)) intercept = 0;
+
+      let fit = {
+        degree: 1,
+        coefficients: [slope, intercept],
+        mse: 0,
+        rmse: 0,
+        r2: 0,
+        n,
+        weightSum: baseWeights.reduce((a, b) => a + b, 0),
+        method: 'theil-sen-seeded-linear'
+      };
+
+      let weights = [...baseWeights];
+      for (let iter = 0; iter < 6; iter += 1) {
+        const residuals = points.map(p => p.y - evaluateFit(fit, p.x));
+        const residMedian = median(residuals);
+        const absDeviations = residuals.map(r => Math.abs(r - residMedian));
+        const scale = Math.max(1e-6, 1.4826 * median(absDeviations));
+        const huberK = 1.345 * scale;
+        const xMedian = median(points.map(p => p.x));
+        const xScale = Math.max(1e-6, 1.4826 * median(points.map(p => Math.abs(p.x - xMedian))));
+
+        const nextWeights = points.map((p, i) => {
+          const resid = Math.abs(residuals[i] - residMedian);
+          let w = baseWeights[i];
+          if (resid > huberK) w *= huberK / resid;
+          const leverage = Math.abs(p.x - xMedian) / xScale;
+          w *= 1 / (1 + 0.14 * leverage + 0.015 * leverage * leverage);
+          return Math.max(w, 1e-6);
+        });
+
+        const nextFit = weightedPolynomialRegression(points, 1, nextWeights);
+        fit = nextFit;
+        weights = nextWeights;
+        if (iter > 0) {
+          const delta = Math.abs((fit.coefficients[0] ?? 0) - slope) + Math.abs((fit.coefficients[1] ?? 0) - intercept);
+          if (delta < 1e-10) break;
+        }
+        slope = fit.coefficients[0] ?? slope;
+        intercept = fit.coefficients[1] ?? intercept;
+      }
+
+      const xMean = points.reduce((acc, p, i) => {
+        const w = Math.max(0, Number.isFinite(weights?.[i]) ? weights[i] : 1);
+        return acc + w * p.x;
+      }, 0) / Math.max(1e-12, weights.reduce((a, b) => a + b, 0));
+
+      fit.xMean = xMean;
+      fit.centerValue = evaluateFit(fit, xMean);
+      fit.centerSlope = fit.coefficients[0] ?? 0;
+      fit.slope = fit.coefficients[0] ?? 0;
+      fit.intercept = fit.coefficients[1] ?? 0;
+      fit.curvature = 0;
+      fit.effectiveN = weights.reduce((a, b) => a + b, 0);
+      fit.method = 'robust-linear';
+      return fit;
+    }
+
+    function evaluateFit(fit, x) {
+      return evaluatePolynomial(fit?.coefficients || [0], x);
+    }
+
+    function fitSlopeAt(fit, x) {
+      return polynomialDerivative(fit?.coefficients || [0], x);
+    }
+
+    function fitCenter(fit) {
+      return fit?.xMean ?? 0;
+    }
+
+    function fitSummaryValue(fit) {
+      return fit?.centerValue ?? 0;
+    }
+
+    function formatFitEquation(fit) {
+      if (!fit?.coefficients?.length) return '—';
+      const coeffs = fit.coefficients;
+      if (fit.degree === 1 && coeffs.length >= 2) {
+        return `${coeffs[0].toFixed(4)}x + ${coeffs[1].toFixed(2)}`;
+      }
+      if (fit.degree >= 2 && coeffs.length >= 3) {
+        return `${coeffs[0].toFixed(4)}x² + ${coeffs[1].toFixed(4)}x + ${coeffs[2].toFixed(2)}`;
+      }
+      return coeffs.map(v => v.toFixed(4)).join(', ');
+    }
+
+    function getEligibleModels() {
+      return MODELS.filter(m => {
+        const score = getMetricValue(m, activeBenchmark);
+        return Number.isFinite(m.params) &&
+          m.params >= MIN_PLOT_PARAMS &&
+          score !== null &&
+          score !== undefined &&
+          Number.isFinite(score);
+      });
     }
 
     function getEligibleModels() {
@@ -1175,17 +1525,17 @@
       }).join('');
     }
 
-    function updateStats(fit, visibleCount, residuals, fitCount, rawFit) {
-      document.getElementById('statSlope').textContent = fit.n >= 2 ? fit.slope.toFixed(4) : '—';
-      document.getElementById('statIntercept').textContent = fit.n >= 2 ? fit.intercept.toFixed(2) : '—';
-      document.getElementById('statMSE').textContent = fit.n >= 2 ? fit.mse.toFixed(3) : '—';
+    function updateStats(fit, visibleCount, residuals, rawCount, binCount, rawFit) {
+      document.getElementById('statSlope').textContent = fit.n >= 2 ? (fit.slope ?? fit.coefficients?.[0] ?? 0).toFixed(6) : '—';
+      document.getElementById('statIntercept').textContent = fit.n >= 2 ? (fit.intercept ?? fit.coefficients?.[1] ?? 0).toFixed(4) : '—';
+      document.getElementById('statMSE').textContent = fit.n >= 2 ? fit.mse.toFixed(2) : '—';
       document.getElementById('statRMSE').textContent = fit.n >= 2 ? fit.rmse.toFixed(2) : '—';
       document.getElementById('statR2').textContent = fit.n >= 2 ? fit.r2.toFixed(3) : '—';
 
-      document.getElementById('countBadge').textContent = `${visibleCount} visible / ${fitCount} fit`;
+      document.getElementById('countBadge').textContent = `${visibleCount} visible / ${binCount} bins`;
       document.getElementById('infoBenchmark').textContent = BENCHMARK_NAMES[activeBenchmark] || activeBenchmark;
       document.getElementById('infoCount').textContent = String(visibleCount);
-      document.getElementById('infoFitCount').textContent = String(fitCount);
+      document.getElementById('infoFitCount').textContent = String(binCount);
 
       const absMean = residuals.length ? residuals.reduce((a, b) => a + Math.abs(b), 0) / residuals.length : 0;
       const mean = residuals.length ? residuals.reduce((a, b) => a + b, 0) / residuals.length : 0;
@@ -1196,11 +1546,11 @@
 
       const orgCount = new Set(getVisibleModels().map(m => m.org)).size;
       document.getElementById('infoOrgs').textContent = `${orgCount} orgs`;
-      document.getElementById('infoMatchRate').textContent = `${visibleCount}/${fitCount}`;
+      document.getElementById('infoMatchRate').textContent = `${visibleCount}/${rawCount}`;
       document.getElementById('infoMode').textContent = activeMode === 'mobile' ? 'Mobile' : 'Computer';
 
       document.getElementById('fitNote').textContent =
-        `Fit uses ${fitCount} eligible models for ${BENCHMARK_NAMES[activeBenchmark] || activeBenchmark}. Raw-point RMSE is ${rawFit.n >= 2 ? rawFit.rmse.toFixed(2) : '—'}; grouped RMSE is ${fit.n >= 2 ? fit.rmse.toFixed(2) : '—'}. Search and org filters only affect visibility.`;
+        `Fit uses ${rawCount} eligible models collapsed into ${binCount} size bins for ${BENCHMARK_NAMES[activeBenchmark] || activeBenchmark}. Raw-point RMSE is ${rawFit.n >= 2 ? rawFit.rmse.toFixed(2) : '—'}; binned fit RMSE is ${fit.n >= 2 ? fit.rmse.toFixed(2) : '—'}. Search and org filters only affect visibility.`;
     }
 
     function render() {
@@ -1243,11 +1593,11 @@
 
       document.getElementById('chartTitle').textContent = chartTitleMap[activeBenchmark] || 'Regression vs log parameters';
       document.getElementById('chartSub').textContent =
-        'Silver regression line fit globally for the selected benchmark. Search and org filtering only hide points, so the line stays stable.';
+        'Binned linear regression on log10(parameters) for the selected benchmark. Each size bin contributes one equally weighted sample, so the line tracks the average score by parameter region instead of point density.';
 
       if (fitData.length < 2) {
         document.getElementById('chartSub').textContent = 'Need at least 2 eligible models to fit a line.';
-        document.getElementById('countBadge').textContent = `${visibleModels.length} visible / ${fitData.length} fit`;
+        document.getElementById('countBadge').textContent = `${visibleModels.length} visible / ${fitData.length} bins`;
         document.getElementById('infoBenchmark').textContent = BENCHMARK_NAMES[activeBenchmark] || activeBenchmark;
         document.getElementById('infoCount').textContent = String(visibleModels.length);
         document.getElementById('infoFitCount').textContent = String(fitData.length);
@@ -1261,17 +1611,17 @@
         return;
       }
 
-      const fitSamples = buildFitSamples(fitData);
-      const fit = linearRegression(fitSamples);
-      const rawFit = linearRegression(fitData);
+      const fitSamples = buildBinnedFitSamples(fitData);
+      const fit = robustLinearRegression(fitSamples);
+      const rawFit = weightedLinearRegression(fitData);
 
-      const visibleResiduals = data.map(d => d.y - (fit.slope * d.x + fit.intercept));
+      const visibleResiduals = data.map(d => d.y - evaluateFit(fit, d.x));
       data.forEach((d, i) => {
         d.residual = visibleResiduals[i];
-        d.prediction = fit.slope * d.x + fit.intercept;
+        d.prediction = evaluateFit(fit, d.x);
       });
 
-      updateStats(fit, data.length, visibleResiduals, fitData.length, rawFit);
+      updateStats(fit, data.length, visibleResiduals, fitData.length, fitSamples.length, rawFit);
       updatePredictionPanel();
 
       const xMin = Math.min(...fitData.map(d => d.x));
@@ -1283,7 +1633,7 @@
       for (let i = 0; i <= lineSteps; i += 1) {
         const t = i / lineSteps;
         const rawX = (xMin - xPad) + ((xMax + xPad) - (xMin - xPad)) * t;
-        regressionLine.push({ x: rawX, y: fit.slope * rawX + fit.intercept });
+        regressionLine.push({ x: rawX, y: evaluateFit(fit, rawX) });
       }
 
       const yMin = Math.min(...fitData.map(d => d.y), ...regressionLine.map(p => p.y)) - 1.6;
@@ -1378,14 +1728,14 @@
                 title: (items) => items[0]?.raw?.name || '',
                 label: (item) => {
                   const d = item.raw;
-                  const predicted = fit.slope * d.x + fit.intercept;
+                  const predicted = evaluateFit(fit, d.x);
                   const resid = d.y - predicted;
                   return [
                     `Org: ${d.org}`,
                     `Params: ${fmtParams(d.params)} (${d.params.toLocaleString()})`,
                     `Score: ${d.score.toFixed(2)}%`,
                     `Residual: ${resid >= 0 ? '+' : ''}${resid.toFixed(2)} pts`,
-                    `Predicted: ${predicted.toFixed(2)}%`
+                    `Predicted (robust line): ${predicted.toFixed(2)}%`
                   ];
                 },
                 afterLabel: (item) => {