beeeeg update

src/lib/derby/generic.ts

@@ -0,0 +1,132 @@
+// Algemeen kansmodel voor de overige koersen: zelfde opzet als het Derby-model
+// (z-scores × gewichten → softmax), maar zonder proef- en marktsignaal.
+// Signalen: uitslagen, snelheid (beste recente km-tijd), niveau (prijzengeld
+// van de laatste starts), startpositie en uitvalrisico.
+
+import type { Result } from './data';
+import type { Race, Runner } from './races';
+
+export type GWeights = {
+	form: number;
+	speed: number;
+	level: number;
+	draw: number;
+	risk: number;
+	halfLife: number;
+	temperature: number;
+	lambda: number;
+};
+
+export const gFeatureKeys = ['form', 'speed', 'level', 'draw'] as const;
+export type GFeatureKey = (typeof gFeatureKeys)[number];
+
+export const gDefaults: GWeights = {
+	form: 1,
+	speed: 1,
+	level: 0.6,
+	draw: 0.4,
+	risk: 1,
+	halfLife: 2,
+	temperature: 1,
+	lambda: 0.8
+};
+
+/** rensport: geen tijden, startbox minder belangrijk over 1900 m */
+export const defaultsFor = (race: Race): GWeights =>
+	race.discipline === 'ren' ? { ...gDefaults, speed: 0, draw: 0.2, level: 0.8 } : { ...gDefaults };
+
+export const gPresets: Record<string, Partial<GWeights>> = {
+	Standaard: {},
+	Vorm: { form: 1.6, speed: 0.5, level: 0.4 },
+	Snelheid: { form: 0.5, speed: 1.6, level: 0.4 },
+	Niveau: { form: 0.6, speed: 0.6, level: 1.5 }
+};
+
+const SCALE = 0.55;
+const POSITION_POINTS: Record<number, number> = { 1: 1, 2: 0.75, 3: 0.6, 4: 0.45, 5: 0.35, 6: 0.25 };
+const positionPoints = (r: Result) => (r === 'D' ? 0 : (POSITION_POINTS[r] ?? 0.1));
+const DRAW_SCORE = [0, 0.6, 0.7, 0.6, 0.45, 0.4, 0.25, 0.1, 0, -0.2, -0.3];
+
+export type GFeatures = {
+	form: number;
+	speed: number;
+	level: number;
+	draw: number;
+	pFail: number;
+	/** welke signalen ontbraken en het veldgemiddelde kregen */
+	estimated: GFeatureKey[];
+};
+
+const mean = (xs: number[]) => xs.reduce((a, b) => a + b, 0) / xs.length;
+
+function rawForm(h: Runner, w: GWeights): number | null {
+	if (h.form.length === 0) return null;
+	const decay = h.form.map((_, i) => Math.pow(0.5, i / w.halfLife));
+	return h.form.reduce((s: number, r, i) => s + decay[i] * positionPoints(r), 0) / decay.reduce((a, b) => a + b, 0);
+}
+
+export function gFeatures(runners: Runner[], w: GWeights): GFeatures[] {
+	const raw = runners.map((h) => ({
+		form: rawForm(h, w),
+		speed: h.times.length ? -Math.min(...h.times) : null,
+		level: h.purses.length ? mean(h.purses.map((p) => Math.log(p))) : null
+	}));
+	const fill = (k: 'form' | 'speed' | 'level') => {
+		const known = raw.map((r) => r[k]).filter((v): v is number => v !== null);
+		return known.length ? mean(known) : 0;
+	};
+	const avg = { form: fill('form'), speed: fill('speed'), level: fill('level') };
+
+	return runners.map((h, i) => {
+		const estimated: GFeatureKey[] = [];
+		const pick = (k: 'form' | 'speed' | 'level') => {
+			const v = raw[i][k];
+			if (v === null) estimated.push(k);
+			return v ?? avg[k];
+		};
+		const disq = h.form.filter((r) => r === 'D').length;
+		const poor = h.form.filter((r) => r !== 'D' && r >= 7).length;
+		// debutanten: geen bewijs dat ze in de draf blijven
+		const base = h.form.length === 0 ? 0.12 : 0.03;
+		const pFail = Math.min(0.5, base + 0.1 * disq + 0.03 * poor);
+		return { form: pick('form'), speed: pick('speed'), level: pick('level'), draw: DRAW_SCORE[h.n] ?? 0, pFail, estimated };
+	});
+}
+
+/**
+ * ondergrens voor de spreiding per signaal, anders wordt 0,2 s verschil in een
+ * veld met drie bijna gelijke tijden een enorme z-score
+ */
+const SD_FLOOR: Record<GFeatureKey, number> = { form: 0.08, speed: 1, level: 0.3, draw: 0.15 };
+
+function zscores(values: number[], floor: number): number[] {
+	const m = mean(values);
+	const sd = Math.max(floor, Math.sqrt(mean(values.map((v) => (v - m) ** 2))));
+	return values.map((v) => (v - m) / sd);
+}
+
+export type GPrediction = {
+	horse: Runner;
+	features: GFeatures;
+	contributions: Record<GFeatureKey, number>;
+	riskPenalty: number;
+	logit: number;
+	p: number;
+};
+
+export function gPredict(runners: Runner[], w: GWeights): GPrediction[] {
+	if (runners.length === 0) return [];
+	const feats = gFeatures(runners, w);
+	const z = Object.fromEntries(gFeatureKeys.map((k) => [k, zscores(feats.map((f) => f[k]), SD_FLOOR[k])])) as Record<GFeatureKey, number[]>;
+	const rows = runners.map((horse, i) => {
+		const contributions = Object.fromEntries(gFeatureKeys.map((k) => [k, w[k] * z[k][i] * SCALE])) as Record<GFeatureKey, number>;
+		const riskPenalty = w.risk * Math.log(1 - feats[i].pFail);
+		const logit = Object.values(contributions).reduce((a, b) => a + b, 0) + riskPenalty;
+		return { horse, features: feats[i], contributions, riskPenalty, logit, p: 0 };
+	});
+	const max = Math.max(...rows.map((r) => r.logit));
+	const exp = rows.map((r) => Math.exp((r.logit - max) / w.temperature));
+	const total = exp.reduce((a, b) => a + b, 0);
+	rows.forEach((r, i) => (r.p = exp[i] / total));
+	return rows.sort((a, b) => b.p - a.p);
+}