Next-Ask / ask_core.py
Lamapi's picture
Publish Next-Ask model
d14d984 verified
Raw History Blame Contribute Delete
3.79 kB
"""Next Ask: pool-based active learning with a label budget.
Classifier: multinomial logistic regression trained by full-batch gradient descent
from zero weights (deterministic, mirrored exactly in web/core.js).
Strategies:
random - uniform sample from the unlabeled pool (Mulberry32 PRNG)
uncertainty - smallest top-2 probability margin
hybrid - uncertainty + diversity: shortlist the 4*B most uncertain points, then
greedily pick the point maximising (1 - margin) * distance to everything
already labeled or picked (farthest-first on the shortlist)
"""
import numpy as np
from nlrt import Mulberry32
STRATEGIES = ("random", "uncertainty", "hybrid")
def features(pixels):
x = np.asarray(pixels, dtype=np.float64) / 16.0
return np.hstack([x, np.ones((x.shape[0], 1))])
def train(X, y, n_classes=10, steps=150, lr=0.5, l2=1e-3):
n, d = X.shape
W = np.zeros((d, n_classes))
Y = np.zeros((n, n_classes))
Y[np.arange(n), y] = 1.0
reg = np.ones((d, 1))
reg[-1] = 0.0
for _ in range(steps):
Z = X @ W
Z -= Z.max(axis=1, keepdims=True)
P = np.exp(Z)
P /= P.sum(axis=1, keepdims=True)
G = X.T @ (P - Y) / n + l2 * reg * W
W -= lr * G
return W
def proba(W, X):
Z = X @ W
Z -= Z.max(axis=1, keepdims=True)
P = np.exp(Z)
return P / P.sum(axis=1, keepdims=True)
def margins(P):
s = np.sort(P, axis=1)
return s[:, -1] - s[:, -2]
def select(strategy, W, X, labeled, B, seed):
"""Return B pool indices (ordered) to request labels for next."""
labeled_set = set(int(i) for i in labeled)
unl = [i for i in range(X.shape[0]) if i not in labeled_set]
if strategy == "random":
rng = Mulberry32(seed)
arr = list(unl)
picks = []
for k in range(min(B, len(arr))):
j = k + rng.randint(len(arr) - k)
arr[k], arr[j] = arr[j], arr[k]
picks.append(arr[k])
return picks
m = margins(proba(W, X[unl]))
order = sorted(range(len(unl)), key=lambda k: (m[k], unl[k]))
if strategy == "uncertainty":
return [unl[k] for k in order[:B]]
if strategy != "hybrid":
raise ValueError(strategy)
short = order[:4 * B]
feats = X[:, :-1]
anchors = feats[sorted(labeled_set)] if labeled_set else np.zeros((0, feats.shape[1]))
cand = feats[[unl[k] for k in short]]
if len(anchors):
dmin = ((cand[:, None, :] - anchors[None, :, :]) ** 2).sum(-1).min(axis=1)
else:
dmin = np.full(len(short), np.inf)
dmin = np.sqrt(dmin)
picks, used = [], np.zeros(len(short), dtype=bool)
for _ in range(min(B, len(short))):
score = np.where(used, -np.inf, (1.0 - m[short]) * dmin)
k = int(np.argmax(score))
used[k] = True
picks.append(unl[short[k]])
dnew = np.sqrt(((cand - cand[k]) ** 2).sum(-1))
dmin = np.minimum(dmin, dnew)
return picks
def initial_set(n_pool, n_init, seed):
rng = Mulberry32(seed * 7919 + 1)
arr = list(range(n_pool))
for k in range(n_init):
j = k + rng.randint(n_pool - k)
arr[k], arr[j] = arr[j], arr[k]
return arr[:n_init]
def simulate(strategy, Xp, yp, Xt, yt, seed, hyper, n_init=10, B=10, budget=200):
labeled = initial_set(len(Xp), n_init, seed)
curve = []
W = None
rnd = 0
while True:
W = train(Xp[labeled], yp[labeled], **hyper)
acc = float((proba(W, Xt).argmax(1) == yt).mean())
curve.append((len(labeled), acc))
if len(labeled) >= budget:
break
picks = select(strategy, W, Xp, labeled, min(B, budget - len(labeled)), seed * 100003 + rnd)
labeled = labeled + picks
rnd += 1
return curve, labeled, W