"""
Longshot
========
A writing game played inside a language model's predictions. You build a sentence one
word at a time. At each step you see the model's real top candidate next-words with
their actual probabilities, and you pick one. Your score is the total SURPRISE you
create, measured in bits (-log2 of the probability you chose). Pick what the model
expects and you score nothing; pick its longshots and the sentence turns strange.
Track 2 toy for the "Small Models Big Adventures" hackathon.
Model: openbmb/MiniCPM5-1B (1B, on-device, well under the 32B ceiling).
Why a SMALL model is the point: the game IS the next-token distribution, so it needs
the model's real logits, and a 1B model is fast enough to predict after every single
word AND quirky enough to make fighting its expectations genuinely fun. One forward
pass per word, no GPU required.
Modes: model (real logits) / keeper (a mock distribution, so it always demos).
"""
import os
import math
import html
import inspect
import random
import gradio as gr
_BLOCKS_HAS_CSS = "css" in inspect.signature(gr.Blocks.__init__).parameters
_LAUNCH_HAS_SSR = "ssr_mode" in inspect.signature(gr.Blocks.launch).parameters
_TB_HAS_COPY = "show_copy_button" in inspect.signature(gr.Textbox.__init__).parameters
_COPY = {"show_copy_button": True} if _TB_HAS_COPY else {}
MODEL_ID = os.environ.get("LONGSHOT_MODEL", "openbmb/MiniCPM5-1B")
DEBUG = os.environ.get("LONGSHOT_DEBUG", "").strip().lower() in {"1", "true", "yes"}
MAX_STEPS = int(os.environ.get("LONGSHOT_MAX_STEPS", "24"))
K = 6 # candidate words shown per step
SEEDS = ["The old lighthouse keeper", "On the third day of the voyage",
"Nobody expected the cheese to", "She opened the box and found"]
_PUNCT = set(".,;:!?\u2014\u2026\"')(-")
def _bits(p):
return -math.log2(max(p, 1e-9))
def label(bits):
if bits < 18:
return "Predictable"
if bits < 42:
return "Curious"
if bits < 80:
return "Eccentric"
if bits < 140:
return "Unhinged"
return "Beyond comprehension"
# ----------------------------------------------------------------- model -------
def _noop_gpu(*a, **k):
def wrap(fn):
return fn
return wrap(a[0]) if a and callable(a[0]) else wrap
if os.environ.get("SPACES_ZERO_GPU", "").lower() in {"true", "1"}:
try:
import spaces
GPU = spaces.GPU
except Exception: # noqa: BLE001
GPU = _noop_gpu
else:
GPU = _noop_gpu
_tokenizer = None
_model = None
MODE = "keeper"
def load_model():
global _tokenizer, _model, MODE
try:
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
_tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
_model = AutoModelForCausalLM.from_pretrained(
MODEL_ID, torch_dtype=torch.float32, trust_remote_code=True)
_model.eval()
MODE = "model"
print(f"[Longshot] Loaded {MODEL_ID} -- model mode (real logits).")
except Exception as exc: # noqa: BLE001
MODE = "keeper"
print(f"[Longshot] Could not load {MODEL_ID} ({exc}). Keeper mode active.")
load_model()
@GPU(duration=30)
def _predict_model(text, k=K):
import torch
if torch.cuda.is_available() and next(_model.parameters()).device.type != "cuda":
_model.to("cuda", dtype=torch.bfloat16)
enc = _tokenizer(text if text else _tokenizer.bos_token or " ",
return_tensors="pt").to(_model.device)
with torch.no_grad():
logits = _model(**enc).logits[0, -1].float()
probs = torch.softmax(logits, dim=-1)
topv, topi = probs.topk(60)
cands, fallback = [], []
for p, tid in zip(topv.tolist(), topi.tolist()):
piece = _tokenizer.decode([int(tid)])
if not piece or "\ufffd" in piece:
continue
st = piece.strip()
if not st:
continue
fallback.append((piece, st, p))
if piece[:1] == " " or st[0] in _PUNCT or not text:
cands.append({"piece": piece, "word": st, "p": p})
if len(cands) >= k:
break
if len(cands) < 3: # tokenizer gave mostly sub-words
cands = [{"piece": pc if pc[:1] == " " else " " + s, "word": s, "p": p}
for pc, s, p in fallback[:k]]
return cands
_BANK = ["the", "a", "and", "then", "slowly", "suddenly", "quietly", "because",
"moon", "door", "whispered", "forgot", "umbrella", "sea", "clockwork",
"nobody", "almost", "perhaps", "velvet", "thunder", "sang", "river",
"glass", "remembered", "blue", "forever", "maybe", "stone", "feather", "drifted"]
_KP = [0.30, 0.20, 0.14, 0.10, 0.07, 0.05]
def _keeper_candidates(text, k=K):
rng = random.Random((text[-40:] or "seed"))
words = rng.sample(_BANK, min(k, len(_BANK)))
return [{"piece": " " + w, "word": w, "p": _KP[i % len(_KP)]} for i, w in enumerate(words)]
def next_candidates(text):
if MODE == "model":
try:
cands = _predict_model(text)
if cands:
return cands
except Exception as exc: # noqa: BLE001
print(f"[Longshot] predict error: {exc}")
return _keeper_candidates(text)
# --------------------------------------------------------------- rendering -----
def esc(s):
return html.escape(str(s))
def base_state():
return {"text": "", "score": 0.0, "steps": 0, "history": [],
"started": False, "finished": False, "candidates": []}
def share_text(state):
return (f'{state["score"]:.0f} bits of surprise ({label(state["score"])}) - '
f'"{state["text"].strip()}" · played in Longshot')
def render_stage(state):
if not state.get("started"):
return ('Pick an opening below to begin, then build a '
'sentence the model never saw coming.
')
text = state.get("text", "")
cursor = "" if state.get("finished") else '\u258c'
story = f'{esc(text)}{cursor}
'
lab = label(state["score"])
score = (f'Surprise {state["score"]:.1f} bits'
f'{lab}
')
if state.get("finished"):
body = (f'The oracle is {lab.lower()}. '
f'{state["steps"]} words, {state["score"]:.1f} bits of surprise.
')
return f'{story}{score}{body}
'
rows = ""
for idx, c in enumerate(state.get("candidates") or []):
p = c["p"]
pct = p * 100
w = max(3, min(100, round((p ** 0.5) * 100)))
exp = ' expected' if idx == 0 else ''
rows += (f'{esc(c["word"])}'
f''
f'{pct:.1f}%{exp}
')
ask = ('Choose the next word below. The longer the bar, the more '
'the model expects it. The bolder your longshot, the more surprise you score.
')
return f'{story}{score}{ask}
{rows}
Longshot
Build a sentence from a model's own predictions. The stranger your path, the higher your score.
{mode_label}