@zhin.js/plugin-lottery 1.0.0

package/src/evaluate/adaptive-sim.ts

@@ -0,0 +1,210 @@
+import { DEFAULT_WEIGHTS, type DrawNumbers, type GameId, type GamePick, type NormalizedDraw, type ScoreWeights } from '../types.js';
+
+import { comparePickToDraw, tuneWeightsFromDraw } from './hit-rate.js';
+import { recommendGame } from '../recommend/game-pick.js';
+
+export interface SimulationOptions {
+  pickCount: number;
+  minHistory: number;
+  randomTrials: number;
+  initialWeights?: ScoreWeights;
+  adaptive?: boolean;
+  /** Score only the last N periods; omit to score every training step. */
+  scoreWindow?: number;
+}
+
+export interface SimulationResult {
+  gameId: GameId;
+  periods: number;
+  warmupPeriods: number;
+  adaptiveAvgHitRate: number;
+  fixedAvgHitRate: number;
+  randomAvgHitRate: number;
+  adaptiveVsRandom: number;
+  adaptiveVsFixed: number;
+  initialWeights: ScoreWeights;
+  finalWeights: ScoreWeights;
+  firstScoredIssue: string;
+  lastScoredIssue: string;
+}
+
+const EMPTY_STATS: GamePick['stats'] = {
+  gameId: 'kl8',
+  sampleSize: 0,
+  hot: [],
+  cold: [],
+  detail: '',
+};
+
+function createRng(seed: number): () => number {
+  let s = seed | 0;
+  return () => {
+    s = (s + 0x6d2b79f5) | 0;
+    let t = Math.imul(s ^ (s >>> 15), 1 | s);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function pickUnique(rng: () => number, min: number, max: number, count: number): number[] {
+  const pool = [];
+  for (let i = min; i <= max; i++) pool.push(i);
+  const out: number[] = [];
+  for (let i = 0; i < count && pool.length; i++) {
+    const idx = Math.floor(rng() * pool.length);
+    const picked = pool.splice(idx, 1)[0];
+    if (picked !== undefined) out.push(picked);
+  }
+  return out.sort((a, b) => a - b);
+}
+
+function pickDigits(rng: () => number, len: number): number[] {
+  const out: number[] = [];
+  for (let i = 0; i < len; i++) out.push(Math.floor(rng() * 10));
+  return out;
+}
+
+export function randomDrawNumbers(gameId: GameId, pickCount: number, rng: () => number): DrawNumbers {
+  switch (gameId) {
+    case 'kl8':
+      return { main: pickUnique(rng, 1, 80, Math.min(10, Math.max(1, pickCount))) };
+    case 'ssq':
+      return { red: pickUnique(rng, 1, 33, 6), blue: pickUnique(rng, 1, 16, 1) };
+    case 'dlt':
+      return { front: pickUnique(rng, 1, 35, 5), back: pickUnique(rng, 1, 12, 2) };
+    case 'fc3d':
+    case 'pl3':
+      return { digits: pickDigits(rng, 3) };
+    case 'pl5':
+      return { digits: pickDigits(rng, 5) };
+    default:
+      return {};
+  }
+}
+
+function asPick(gameId: GameId, numbers: DrawNumbers): GamePick {
+  return {
+    gameId,
+    label: gameId,
+    numbers,
+    weights: DEFAULT_WEIGHTS,
+    stats: { ...EMPTY_STATS, gameId },
+  };
+}
+
+function stableIssueSeed(issue: string): number {
+  let h = 0;
+  for (let i = 0; i < issue.length; i++) h = (h * 31 + issue.charCodeAt(i)) >>> 0;
+  return h;
+}
+
+function randomRateForPeriod(
+  gameId: GameId,
+  pickCount: number,
+  actual: NormalizedDraw,
+  randomTrials: number,
+): number {
+  let periodRandom = 0;
+  const baseSeed = stableIssueSeed(actual.issue);
+  for (let t = 0; t < randomTrials; t++) {
+    const rng = createRng(baseSeed + t);
+    const rnd = randomDrawNumbers(gameId, pickCount, rng);
+    periodRandom += comparePickToDraw(asPick(gameId, rnd), actual).rate;
+  }
+  return periodRandom / randomTrials;
+}
+
+/**
+ * Walk-forward core: for each issue after minHistory, predict → score → tune weights.
+ * Training uses scoreWindow omitted (every step counts); backtest uses scoreWindow.
+ */
+export function runAdaptiveSimulation(
+  chronological: NormalizedDraw[],
+  gameId: GameId,
+  options: SimulationOptions,
+): SimulationResult | null {
+  if (chronological.length <= options.minHistory) return null;
+
+  const trainable = chronological.length - options.minHistory;
+  const testCount = options.scoreWindow
+    ? Math.min(options.scoreWindow, trainable)
+    : trainable;
+  if (testCount <= 0) return null;
+
+  const testStartIdx = options.scoreWindow
+    ? chronological.length - testCount
+    : options.minHistory;
+
+  const useAdaptive = options.adaptive !== false;
+  const initialWeights = options.initialWeights
+    ? { ...options.initialWeights }
+    : { ...DEFAULT_WEIGHTS };
+  let adaptiveWeights = { ...initialWeights };
+
+  let adaptiveSum = 0;
+  let fixedSum = 0;
+  let randomSum = 0;
+  let scored = 0;
+  let firstScoredIssue = '';
+  let lastScoredIssue = '';
+
+  for (let idx = options.minHistory; idx < chronological.length; idx++) {
+    const actual = chronological[idx];
+    if (!actual) continue;
+    const history = chronological.slice(0, idx).reverse();
+    const tieSeed = `sim:${actual.issue}`;
+
+    const fixedPick = recommendGame(gameId, history, {
+      pickCount: options.pickCount,
+      tieSeed,
+      weights: DEFAULT_WEIGHTS,
+    });
+
+    const adaptivePick = useAdaptive
+      ? recommendGame(gameId, history, {
+          pickCount: options.pickCount,
+          tieSeed,
+          weights: adaptiveWeights,
+        })
+      : fixedPick;
+
+    if (idx >= testStartIdx) {
+      if (!firstScoredIssue) firstScoredIssue = actual.issue;
+      lastScoredIssue = actual.issue;
+      fixedSum += comparePickToDraw(fixedPick, actual).rate;
+      adaptiveSum += comparePickToDraw(adaptivePick, actual).rate;
+      randomSum += randomRateForPeriod(gameId, options.pickCount, actual, options.randomTrials);
+      scored++;
+    }
+
+    if (useAdaptive) {
+      adaptiveWeights = tuneWeightsFromDraw(
+        adaptiveWeights,
+        adaptivePick.numbers,
+        actual.numbers,
+        gameId,
+        history,
+      );
+    }
+  }
+
+  if (!scored) return null;
+  const adaptiveAvg = adaptiveSum / scored;
+  const fixedAvg = fixedSum / scored;
+  const randomAvg = randomSum / scored;
+
+  return {
+    gameId,
+    periods: scored,
+    warmupPeriods: testStartIdx - options.minHistory,
+    adaptiveAvgHitRate: adaptiveAvg,
+    fixedAvgHitRate: fixedAvg,
+    randomAvgHitRate: randomAvg,
+    adaptiveVsRandom: adaptiveAvg - randomAvg,
+    adaptiveVsFixed: adaptiveAvg - fixedAvg,
+    initialWeights,
+    finalWeights: adaptiveWeights,
+    firstScoredIssue,
+    lastScoredIssue,
+  };
+}

package/src/evaluate/backtest.ts

@@ -0,0 +1,128 @@
+import type { GameId } from '../types.js';
+import { loadDraws, type LotteryDb } from '../db.js';
+
+import { loadGameWeights } from './tracker.js';
+import { runAdaptiveSimulation, type SimulationResult } from './adaptive-sim.js';
+import { trainGameWeights } from './train-weights.js';
+import { formatWeights } from '../stats/weights.js';
+
+export interface BacktestOptions {
+  pickCount: number;
+  window: number;
+  randomTrials: number;
+  minHistory: number;
+  historyLimit?: number;
+  initialWeights?: import('../types.js').ScoreWeights;
+  adaptive?: boolean;
+}
+
+export type BacktestSummary = SimulationResult;
+
+export async function walkForwardBacktest(
+  db: LotteryDb,
+  gameId: GameId,
+  options: BacktestOptions,
+): Promise<BacktestSummary | null> {
+  const loadLimit = options.historyLimit ?? Math.max(options.window + options.minHistory + 50, 150);
+  const draws = await loadDraws(db, gameId, loadLimit);
+  if (draws.length <= options.minHistory) return null;
+
+  const chronological = [...draws].sort((a, b) => a.issue.localeCompare(b.issue));
+  return runAdaptiveSimulation(chronological, gameId, {
+    pickCount: options.pickCount,
+    minHistory: options.minHistory,
+    randomTrials: options.randomTrials,
+    initialWeights: options.initialWeights,
+    adaptive: options.adaptive,
+    scoreWindow: options.window,
+  });
+}
+
+export async function runBacktestForGames(
+  db: LotteryDb,
+  gameIds: GameId[],
+  options: BacktestOptions,
+): Promise<BacktestSummary[]> {
+  const out: BacktestSummary[] = [];
+  for (const gameId of gameIds) {
+    const initial = await loadGameWeights(db, gameId);
+    const summary = await walkForwardBacktest(db, gameId, { ...options, initialWeights: initial });
+    if (summary) out.push(summary);
+  }
+  return out;
+}
+
+/** Full-history training refresh (same as lottery-train) when pipeline has no live review. */
+export async function refreshAndPersistWeights(
+  db: LotteryDb,
+  gameId: GameId,
+  options: RefreshWeightsOptions,
+): Promise<BacktestSummary | null> {
+  const result = await trainGameWeights(db, gameId, {
+    pickCount: options.pickCount,
+    minHistory: options.minHistory,
+    historyLimit: options.historyLimit ?? 500,
+    randomTrials: options.randomTrials,
+    initialWeights: options.initialWeights ?? (await loadGameWeights(db, gameId)),
+    holdoutWindow: options.holdoutWindow ?? options.window,
+    holdoutFallback: options.holdoutFallback,
+    persist: true,
+  });
+  return result;
+}
+
+export interface RefreshWeightsOptions extends BacktestOptions {
+  persist: boolean;
+  reviewEvaluated: number;
+  holdoutWindow?: number;
+  holdoutFallback?: boolean;
+}
+
+export async function refreshWeightsForGames(
+  db: LotteryDb,
+  gameIds: GameId[],
+  options: RefreshWeightsOptions,
+): Promise<BacktestSummary[]> {
+  if (!options.persist) return [];
+  const out: BacktestSummary[] = [];
+  for (const gameId of gameIds) {
+    if (options.reviewEvaluated > 0) continue;
+    const summary = await refreshAndPersistWeights(db, gameId, options);
+    if (summary) out.push(summary);
+  }
+  return out;
+}
+
+function pct(rate: number): string {
+  return (rate * 100).toFixed(1);
+}
+
+function signedPct(delta: number): string {
+  const v = delta * 100;
+  return v >= 0 ? `+${v.toFixed(1)}` : v.toFixed(1);
+}
+
+export function formatBacktestLine(s: BacktestSummary): string {
+  const w = formatWeights(s.finalWeights);
+  return [
+    `${s.gameId}: 调优 ${pct(s.adaptiveAvgHitRate)}%`,
+    `固定 ${pct(s.fixedAvgHitRate)}%`,
+    `随机 ${pct(s.randomAvgHitRate)}%`,
+    `(Δ调优-随机 ${signedPct(s.adaptiveVsRandom)}%, n=${s.periods}, 热身${s.warmupPeriods}期)`,
+    `终权重 ${w}`,
+  ].join(' / ');
+}
+
+export function formatBacktestSection(summaries: BacktestSummary[]): string {
+  if (!summaries.length) return '';
+  const lines = [
+    '【回测可信度】近 N 期 walk-forward 抽样（全量训练请用 lottery-train）',
+    ...summaries.map(formatBacktestLine),
+    '说明：Δ 接近 0 为正常；终权重见 lottery_model_weights。',
+    '推荐时若近端调优输给随机，将自动回退默认 F40/O35/T25（见【权重保护】）。',
+  ];
+  return lines.join('\n');
+}
+
+export type { TrainWeightsOptions } from './train-weights.js';
+export { trainGameWeights, trainAllGameWeights, formatTrainReport } from './train-weights.js';

package/src/evaluate/hit-rate.ts

@@ -0,0 +1,132 @@
+import { DEFAULT_WEIGHTS, type DrawNumbers, type GameId, type GamePick, type HitSummary, type NormalizedDraw, type ScoreWeights } from '../types.js';
+
+import {
+  affinityOfNumbers,
+  buildFreqMap,
+  buildOmitMap,
+} from '../stats/pro-analysis.js';
+import { analyzePoolTrend } from '../stats/engine.js';
+import { mergeWeights } from '../stats/weights.js';
+
+function intersectCount(a: number[], b: number[]): number {
+  const set = new Set(b);
+  return a.filter((n) => set.has(n)).length;
+}
+
+function digitPositionHits(pick: number[], actual: number[]): { hits: number; total: number } {
+  const total = Math.min(pick.length, actual.length);
+  let hits = 0;
+  for (let i = 0; i < total; i++) {
+    if (pick[i] === actual[i]) hits++;
+  }
+  return { hits, total };
+}
+
+export function comparePickToDraw(pick: GamePick, draw: NormalizedDraw): HitSummary {
+  const n = pick.numbers;
+  const a = draw.numbers;
+  switch (pick.gameId) {
+    case 'kl8': {
+      const p = n.main ?? [];
+      const act = a.main ?? [];
+      const hits = intersectCount(p, act);
+      return {
+        total: p.length,
+        hits,
+        rate: p.length ? hits / p.length : 0,
+        detail: `命中 ${hits}/${p.length}`,
+      };
+    }
+    case 'ssq': {
+      const redHits = intersectCount(n.red ?? [], a.red ?? []);
+      const blueHit = (n.blue?.[0] != null && a.blue?.includes(n.blue[0])) ? 1 : 0;
+      const total = 7;
+      const hits = redHits + blueHit;
+      return {
+        total,
+        hits,
+        rate: hits / total,
+        detail: `红${redHits}/6 蓝${blueHit}/1`,
+      };
+    }
+    case 'dlt': {
+      const fHits = intersectCount(n.front ?? [], a.front ?? []);
+      const bHits = intersectCount(n.back ?? [], a.back ?? []);
+      const total = 7;
+      const hits = fHits + bHits;
+      return {
+        total,
+        hits,
+        rate: hits / total,
+        detail: `前${fHits}/5 后${bHits}/2`,
+      };
+    }
+    case 'fc3d':
+    case 'pl3':
+    case 'pl5': {
+      const { hits, total } = digitPositionHits(n.digits ?? [], a.digits ?? []);
+      return {
+        total,
+        hits,
+        rate: total ? hits / total : 0,
+        detail: `定位 ${hits}/${total}`,
+      };
+    }
+    default:
+      return { total: 0, hits: 0, rate: 0, detail: '未知玩法' };
+  }
+}
+
+/** 根据开奖结果反推更优权重方向，用于渐进调优 */
+export function tuneWeightsFromDraw(
+  current: ScoreWeights,
+  pick: DrawNumbers,
+  actual: DrawNumbers,
+  gameId: GameId,
+  draws: NormalizedDraw[],
+): ScoreWeights {
+  const rows = draws.map((d) => flatNumbers(d.numbers, gameId)).filter((r) => r.length);
+  if (!rows.length) return current;
+
+  const ranges = poolRange(gameId);
+  if (!ranges) {
+    return current;
+  }
+  const { min, max } = ranges;
+  const freqMap = buildFreqMap(rows, min, max);
+  const omitMap = buildOmitMap(rows, min, max);
+  const trendMap = analyzePoolTrend(rows, min, max);
+  const actualNums = flatNumbers(actual, gameId);
+  const actualAff = affinityOfNumbers(actualNums, freqMap, omitMap, trendMap);
+  return mergeWeights(current, actualAff, 0.04);
+}
+
+function flatNumbers(n: DrawNumbers, gameId: GameId): number[] {
+  if (gameId === 'kl8') return n.main ?? [];
+  if (gameId === 'ssq') return [...(n.red ?? []), ...(n.blue ?? [])];
+  if (gameId === 'dlt') return [...(n.front ?? []), ...(n.back ?? [])];
+  return n.digits ?? [];
+}
+
+function poolRange(gameId: GameId): { min: number; max: number } | null {
+  switch (gameId) {
+    case 'kl8':
+      return { min: 1, max: 80 };
+    case 'ssq':
+      return { min: 1, max: 33 };
+    case 'dlt':
+      return { min: 1, max: 35 };
+    case 'fc3d':
+    case 'pl3':
+    case 'pl5':
+      return { min: 0, max: 9 };
+    default:
+      return null;
+  }
+}
+
+export function formatHitSummary(gameId: GameId, hit: HitSummary, issue: string): string {
+  return `${gameId} 第${issue}期 ${hit.detail} (${(hit.rate * 100).toFixed(0)}%)`;
+}
+
+export { DEFAULT_WEIGHTS };

package/src/evaluate/review-pending.ts

@@ -0,0 +1,120 @@
+import type { GameId, NormalizedDraw } from '../types.js';
+import { loadDraws, type LotteryDb } from '../db.js';
+
+import { formatHitSummary } from './hit-rate.js';
+import {
+  listPendingPredictions,
+  PREDICTIONS_TABLE,
+  submitAgentReview,
+} from './tracker.js';
+
+export interface EvaluatePendingResult {
+  evaluated: number;
+  skipped: boolean;
+  lines: string[];
+}
+
+async function isIssueAlreadyReviewed(db: LotteryDb, gameId: GameId, issue: string): Promise<boolean> {
+  const predModel = db.models.get(PREDICTIONS_TABLE);
+  if (!predModel) return false;
+  const rows = (await predModel.select().where({
+    game_id: gameId,
+    status: 'evaluated',
+    actual_issue: issue,
+  })) as unknown[];
+  return rows.length > 0;
+}
+
+function drawsForReview(
+  gameId: GameId,
+  insertedDraws: NormalizedDraw[],
+  latestInDb: NormalizedDraw | undefined,
+  stalePending: boolean,
+): NormalizedDraw[] {
+  const inserted = insertedDraws
+    .filter((d) => d.gameId === gameId)
+    .sort((a, b) => a.issue.localeCompare(b.issue));
+  if (inserted.length) return inserted;
+  if (stalePending && latestInDb) return [latestInDb];
+  return [];
+}
+
+/** Match pending picks to new or latest draws; skip when nothing pending. */
+export async function evaluatePendingPredictions(
+  db: LotteryDb,
+  gameIds: GameId[],
+  historyLimit: number,
+  insertedDraws: NormalizedDraw[] = [],
+): Promise<EvaluatePendingResult> {
+  const lines: string[] = [];
+  let evaluated = 0;
+  let hadPending = false;
+  const today = new Date().toISOString().slice(0, 10);
+
+  for (const gameId of gameIds) {
+    const pending = (await listPendingPredictions(db, gameId)) as Array<{
+      predict_at: string;
+      predict_date: string;
+    }>;
+    if (!pending.length) continue;
+    hadPending = true;
+
+    const stale = pending.filter((p) => p.predict_date < today);
+    const todayOnly = pending.filter((p) => p.predict_date === today);
+    const latest = (await loadDraws(db, gameId, 1))[0];
+    const useStale = stale.length > 0 && latest && !(await isIssueAlreadyReviewed(db, gameId, latest.issue));
+    const drawsToMatch = drawsForReview(gameId, insertedDraws, latest, useStale);
+
+    if (!drawsToMatch.length) {
+      if (todayOnly.length) {
+        lines.push(`${gameId}: waiting for next draw`);
+      } else {
+        lines.push(`${gameId}: pending, no matching draw yet`);
+      }
+      continue;
+    }
+
+    const pool = useStale ? [...stale] : [...pending];
+    const orderedPending = pool.sort((a, b) => a.predict_at.localeCompare(b.predict_at));
+    for (const draw of drawsToMatch) {
+      const row = orderedPending.shift();
+      if (!row) break;
+      const hit = await submitAgentReview(
+        db,
+        {
+          gameId,
+          predictAt: row.predict_at,
+          actualIssue: draw.issue,
+          actualNumbers: draw.numbers,
+          analysis: '',
+        },
+        historyLimit,
+      );
+      if (hit) {
+        evaluated++;
+        lines.push(formatHitSummary(gameId, hit, draw.issue));
+      }
+    }
+  }
+
+  if (!hadPending) {
+    return { evaluated: 0, skipped: true, lines: ['no pending predictions'] };
+  }
+  return { evaluated, skipped: false, lines };
+}
+
+/** Games that still need a next-period pick (no pending row for today). */
+export async function gamesNeedingPrediction(db: LotteryDb, gameIds: GameId[], date = new Date()): Promise<GameId[]> {
+  const today = date.toISOString().slice(0, 10);
+  const out: GameId[] = [];
+  for (const gid of gameIds) {
+    const pending = (await listPendingPredictions(db, gid)) as Array<{ predict_date: string }>;
+    if (!pending.some((p) => p.predict_date === today)) out.push(gid);
+  }
+  return out;
+}
+
+export async function latestDrawIssue(db: LotteryDb, gameId: GameId): Promise<string | null> {
+  const draws = await loadDraws(db, gameId, 1);
+  return draws[0]?.issue ?? null;
+}