feat: fixed response

ml/markov.py

@@ -0,0 +1,55 @@
+"""Markov-chain baseline over winning numbers (orders 1, 2, 3).
+
+Each order-K model counts transitions from every K-gram of past numbers to the
+next number, then predicts the most frequent successor (with global frequency
+as fallback).
+"""
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from typing import Final
+
+import numpy as np
+
+NUMBER_CLASSES: Final[int] = 37
+
+
+@dataclass
+class MarkovModel:
+    order: int
+    transitions: dict[tuple[int, ...], np.ndarray] = field(default_factory=dict)
+    global_counts: np.ndarray = field(default_factory=lambda: np.zeros(NUMBER_CLASSES, dtype=np.int64))
+
+    def fit(self, sequences: list[np.ndarray]) -> "MarkovModel":
+        counter: dict[tuple[int, ...], Counter[int]] = defaultdict(Counter)
+        global_counter: Counter[int] = Counter()
+        for seq in sequences:
+            for n in seq:
+                global_counter[int(n)] += 1
+            for i in range(len(seq) - self.order):
+                key = tuple(int(x) for x in seq[i : i + self.order])
+                target = int(seq[i + self.order])
+                counter[key][target] += 1
+        for key, c in counter.items():
+            arr = np.zeros(NUMBER_CLASSES, dtype=np.int64)
+            for n, count in c.items():
+                arr[n] = count
+            self.transitions[key] = arr
+        for n, count in global_counter.items():
+            self.global_counts[n] = count
+        return self
+
+    def predict_proba(self, context: tuple[int, ...]) -> np.ndarray:
+        key = context[-self.order :] if self.order > 0 else ()
+        arr = self.transitions.get(key)
+        if arr is None or arr.sum() == 0:
+            arr = self.global_counts
+        total = arr.sum()
+        if total == 0:
+            return np.full(NUMBER_CLASSES, 1.0 / NUMBER_CLASSES, dtype=np.float64)
+        return arr.astype(np.float64) / total
+
+    def predict(self, context: tuple[int, ...]) -> int:
+        proba = self.predict_proba(context)
+        return int(np.argmax(proba))