force reindex

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,192 +1,5 @@
 ---
-language: en
-tags:
-  - wordle
-  - pytorch
-  - reinforcement-learning
-  - supervised-learning
-  - game-ai
-  - nlp
-license: mit
+title: wordle
+sdk: docker
+pinned: false
 ---
-
-# 🟩 Wordle AI Solver
-
-Neural network models for solving Wordle puzzles. This repo contains two models — a supervised baseline and a reinforcement learning variant — both deployable via the [live app](https://wordle-solver-tan.vercel.app).
-
----
-
-## Files
-
-| File | Description |
-|------|-------------|
-| `model_weights.pt` | Supervised model (WordleNet) |
-| `config.json` | Supervised model config |
-| `rl_model_weights.pt` | RL model (REINFORCE-filtered) |
-| `rl_config.json` | RL model config |
-| `answers.json` | 2,315 valid Wordle answers |
-| `allowed.json` | 12,972 valid guess words |
-
----
-
-## Model Comparison
-
-| | 🧠 Supervised | 🤖 Reinforcement |
-|---|---|---|
-| **Training method** | CrossEntropy on entropy-optimal games | REINFORCE with elite game filtering |
-| **Win rate** | 100% | 98.2% |
-| **Avg guesses** | 3.46 | 3.75 |
-| **Opener** | CRANE | CRANE |
-| **Parameters** | ~13M | ~13M |
-
----
-
-## Architecture
-
-Both models share the same encoder:
-
-```
-Input:  390-dim binary vector
-        (26 letters × 5 positions × 3 states: grey/yellow/green)
-
-Hidden: Linear(390 → 512) → BatchNorm1d → ReLU → Dropout(0.3)
-        Linear(512 → 512) → BatchNorm1d → ReLU → Dropout(0.3)
-        Linear(512 → 256) → BatchNorm1d → ReLU
-
-Output: Linear(256 → 12972)
-        logits over all 12,972 allowed guess words
-```
-
-Board encoding:
-```python
-vec[letter_index * 15 + position * 3 + state] = 1.0
-# letter_index: 0-25 (a-z)
-# position:     0-4
-# state:        0=grey, 1=yellow, 2=green
-```
-
----
-
-## Training
-
-### Supervised Model
-Trained on ~10,000 (board_state, best_guess) pairs generated by an entropy-optimal solver that plays all 2,315 Wordle games. The solver picks the guess maximising expected information gain at each step:
-
-$$E[\text{Info}] = \sum_{p} P(p) \cdot \log_2\left(\frac{1}{P(p)}\right)$$
-
-### RL Model
-1. **Warm start** from supervised weights
-2. **Elite game collection** — greedy rollouts with constraint-filtered action masking, keeping only games solved in ≤3 guesses (~11% hit rate)
-3. **REINFORCE training** — supervised loss on elite (state, action) pairs
-4. **Benchmark** against all 2,315 answers using constraint-filtered suggestion logic
-
-The RL model learns purely from reward signal (win/lose, guesses used) without access to the entropy oracle used to train the supervised model.
-
----
-
-## Inference
-
-The models are not used as raw classifiers — the backend combines model logits with constraint filtering:
-
-```python
-# 1. Get top-20 model words
-logits = model(encode_board(history))
-model_words = [ALLOWED[i] for i in logits.topk(20).indices]
-
-# 2. Filter to words consistent with all previous guesses
-possible = filter_words(ANSWERS, history)
-
-# 3. Score by entropy against remaining possible set
-candidates = model_words + possible
-best = max(candidates, key=lambda w: entropy_score(w, possible))
-```
-
-This hybrid approach is why the supervised model achieves 100% — the neural net narrows the search, entropy scoring picks the optimal move.
-
----
-
-## Usage
-
-```python
-import torch
-import torch.nn as nn
-from huggingface_hub import hf_hub_download
-import json
-
-REPO_ID = "sato2ru/wordle-solver"
-
-config  = json.load(open(hf_hub_download(REPO_ID, "config.json")))
-ALLOWED = json.load(open(hf_hub_download(REPO_ID, "allowed.json")))
-
-class WordleNet(nn.Module):
-    def __init__(self):
-        super().__init__()
-        h = config["hidden"]
-        self.net = nn.Sequential(
-            nn.Linear(390, h), nn.BatchNorm1d(h), nn.ReLU(), nn.Dropout(0.3),
-            nn.Linear(h, h),   nn.BatchNorm1d(h), nn.ReLU(), nn.Dropout(0.3),
-            nn.Linear(h, 256), nn.BatchNorm1d(256), nn.ReLU(),
-            nn.Linear(256, 12972)
-        )
-    def forward(self, x): return self.net(x)
-
-# Load supervised model
-model = WordleNet()
-model.load_state_dict(
-    torch.load(hf_hub_download(REPO_ID, "model_weights.pt"), map_location="cpu")
-)
-model.eval()
-```
-
-Or use the live API directly:
-```bash
-curl -X POST "https://web-production-ea1d.up.railway.app/suggest?model=supervised" \
-  -H "Content-Type: application/json" \
-  -d '{"history": []}'
-
-curl -X POST "https://web-production-ea1d.up.railway.app/suggest?model=rl" \
-  -H "Content-Type: application/json" \
-  -d '{"history": []}'
-```
-
----
-
-## Results
-
-### Supervised — all 2,315 answers (greedy + entropy filter)
-```
-1 guess :    1
-2 guesses:   59  ████████████
-3 guesses: 1188  ██████████████████████████████████████████████
-4 guesses: 1010  ████████████████████████████████████████
-5 guesses:   56  ███████████
-6 guesses:    1
-FAILED   :    0  ✅ 100% win rate
-```
-
-### RL — all 2,315 answers (greedy + entropy filter)
-```
-1 guess :    1
-2 guesses:  141  ████████████
-3 guesses:  810  ██████████████████████████████████████████████
-4 guesses:  893  ████████████████████████████████████████
-5 guesses:  343  ███████████
-6 guesses:   86  ████
-FAILED   :   41  ✅ 98.2% win rate
-```
-
----
-
-## Links
-
-- **Live App:** [wordle-solver-tan.vercel.app](https://wordle-solver-tan.vercel.app)
-- **GitHub:** [github.com/Jeanwrld/wordle-solver](https://github.com/Jeanwrld/wordle-solver)
-- **Backend:** [github.com/Jeanwrld/wordle-api](https://github.com/Jeanwrld/wordle-api)
-- **Gradio Demo:** [huggingface.co/spaces/sato2ru/wordle](https://huggingface.co/spaces/sato2ru/wordle)
-
----
-
-## License
-
-MIT
-

app.py

@@ -1,25 +1,34 @@
-
-import json, math, torch, gradio as gr
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import json, math, torch, numpy as np
 from collections import Counter
-import numpy as np
-from huggingface_hub import hf_hub_download
 import torch.nn as nn
+from huggingface_hub import hf_hub_download
 
-REPO_ID = "sato2ru/wordle-solver"  # ← update this
-
-# ── Load assets from HF Hub ──────────────────────────────────────
-config  = json.load(open(hf_hub_download(REPO_ID, "config.json")))
-ANSWERS = json.load(open(hf_hub_download(REPO_ID, "answers.json")))
-ALLOWED = json.load(open(hf_hub_download(REPO_ID, "allowed.json")))
-WORD2IDX = {w: i for i, w in enumerate(ALLOWED)}
+HF_REPO_ID = "sato2ru/wordle-solver"
+
+app = FastAPI(title="Wordle Solver API")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── Load assets ───────────────────────────────────────────────────────────────
+print("Loading model...")
+config   = json.load(open(hf_hub_download(HF_REPO_ID, "config.json")))
+ANSWERS  = json.load(open(hf_hub_download(HF_REPO_ID, "answers.json")))
+ALLOWED  = json.load(open(hf_hub_download(HF_REPO_ID, "allowed.json")))
 LETTERS  = "abcdefghijklmnopqrstuvwxyz"
-L2I = {c: i for i, c in enumerate(LETTERS)}
-INPUT_DIM  = config["input_dim"]
-OUTPUT_DIM = config["output_dim"]
-OPENING    = config["opening_guess"]
-WIN_PATTERN = (2,2,2,2,2)
+L2I      = {c: i for i, c in enumerate(LETTERS)}
+INPUT_DIM   = config["input_dim"]
+OUTPUT_DIM  = config["output_dim"]
+OPENING     = config["opening_guess"]
+WIN_PATTERN = (2, 2, 2, 2, 2)
 
-# ── Model ────────────────────────────────────────────────────────
+# ── Model ─────────────────────────────────────────────────────────────────────
 class WordleNet(nn.Module):
     def __init__(self):
         super().__init__()
@@ -33,107 +42,189 @@ class WordleNet(nn.Module):
     def forward(self, x): return self.net(x)
 
 model = WordleNet()
-model.load_state_dict(torch.load(hf_hub_download(REPO_ID, "model_weights.pt"), map_location="cpu"))
+model.load_state_dict(
+    torch.load(hf_hub_download(HF_REPO_ID, "model_weights.pt"), map_location="cpu")
+)
 model.eval()
+print("Model loaded ✅")
 
-# ── Helpers ──────────────────────────────────────────────────────
+# ── Helpers ───────────────────────────────────────────────────────────────────
 def get_pattern(guess, answer):
-    pattern = [0]*5
-    counts = Counter(answer)
+    pattern = [0] * 5
+    counts  = Counter(answer)
     for i in range(5):
-        if guess[i] == answer[i]: pattern[i] = 2; counts[guess[i]] -= 1
+        if guess[i] == answer[i]:
+            pattern[i] = 2
+            counts[guess[i]] -= 1
     for i in range(5):
-        if pattern[i] == 0 and counts.get(guess[i],0) > 0:
-            pattern[i] = 1; counts[guess[i]] -= 1
+        if pattern[i] == 0 and counts.get(guess[i], 0) > 0:
+            pattern[i] = 1
+            counts[guess[i]] -= 1
     return tuple(pattern)
 
 def filter_words(words, guess, pattern):
-    return [w for w in words if get_pattern(guess, w) == pattern]
+    return [w for w in words if get_pattern(guess, w) == tuple(pattern)]
 
 def entropy_score(guess, possible):
     buckets = Counter(get_pattern(guess, w) for w in possible)
     n = len(possible)
-    return sum(-(c/n)*math.log2(c/n) for c in buckets.values())
+    return sum(-(c / n) * math.log2(c / n) for c in buckets.values())
 
 def encode_board(history):
     vec = np.zeros(INPUT_DIM, dtype=np.float32)
     for word, pattern in history:
         for pos, (letter, state) in enumerate(zip(word, pattern)):
-            vec[L2I[letter]*15 + pos*3 + state] = 1.0
+            vec[L2I[letter] * 15 + pos * 3 + state] = 1.0
     return vec
 
+def is_consistent(word, history):
+    for guess, pattern in history:
+        green_letters = {letter for letter, state in zip(guess, pattern) if state == 2}
+        for pos, (letter, state) in enumerate(zip(guess, pattern)):
+            if state == 2:
+                if word[pos] != letter:
+                    return False
+            elif state == 1:
+                if letter not in word or word[pos] == letter:
+                    return False
+            else:
+                if letter not in green_letters and letter in word:
+                    return False
+    return True
+
 def model_suggest(history, possible):
+    if not possible:       return None
     if len(possible) == 1: return possible[0]
-    if not history:         return OPENING
+    if not history:        return OPENING
+
+    already_guessed = {w for w, _ in history}
+    possible_not_guessed = [w for w in possible if w not in already_guessed]
+
+    if len(possible) <= 6:
+        ambiguous = set()
+        for pos in range(5):
+            letters_at_pos = {w[pos] for w in possible}
+            if len(letters_at_pos) > 1:
+                ambiguous.update(letters_at_pos)
+
+        best_word, best_score = None, -1
+        for g in ALLOWED:
+            if g in already_guessed:
+                continue
+            if not is_consistent(g, history):
+                continue
+            if g in possible and len(possible) > 2:
+                continue
+            score = len(set(g) & ambiguous) * 2 + entropy_score(g, possible)
+            if score > best_score:
+                best_score, best_word = score, g
+
+        if not best_word:
+            best_word = possible_not_guessed[0] if possible_not_guessed else possible[0]
+        return best_word
+
     state = torch.tensor(encode_board(history)).unsqueeze(0)
     with torch.no_grad():
         logits = model(state)[0]
-    top5 = [ALLOWED[i] for i in logits.topk(5).indices.tolist()]
-    return max(top5, key=lambda w: entropy_score(w, possible))
 
-# ── State ─────────────────────────────────────────────────────────
-def init_state():
-    return {"possible": list(ANSWERS), "history": [], "done": False}
-
-def render_board(history):
-    colours = {0: "⬜", 1: "🟨", 2: "🟩"}
-    rows = []
-    for word, pattern in history:
-        tiles = " ".join(f"{colours[s]}{c.upper()}" for c, s in zip(word, pattern))
-        rows.append(tiles)
-    return "
-".join(rows) if rows else "(no guesses yet)"
-
-def process_guess(guess_input, pattern_input, state):
-    if state["done"]:
-        return render_board(state["history"]), "Game over — press Reset", state
-
-    guess = guess_input.strip().lower()
-    if len(guess) != 5:
-        return render_board(state["history"]), "⚠️ Guess must be 5 letters", state
-    if len(pattern_input) != 5 or not all(c in "012" for c in pattern_input):
-        return render_board(state["history"]), "⚠️ Pattern must be 5 digits (0/1/2)", state
-
-    pattern = tuple(int(c) for c in pattern_input)
-    state["history"].append((guess, pattern))
-
-    if pattern == WIN_PATTERN:
-        state["done"] = True
-        msg = f"🎉 Solved in {len(state["history"])} turns!"
-        return render_board(state["history"]), msg, state
-
-    state["possible"] = filter_words(state["possible"], guess, pattern)
-    if not state["possible"]:
-        state["done"] = True
-        return render_board(state["history"]), "❌ No words left. Check your input.", state
-
-    suggestion = model_suggest(state["history"], state["possible"])
-    msg = f"Try: **{suggestion.upper()}**  |  {len(state["possible"])} words left"
-    return render_board(state["history"]), msg, state
-
-def reset(_state):
-    s = init_state()
-    return render_board([]), f"Try: **{OPENING.upper()}** to start", s
-
-# ── Gradio UI ─────────────────────────────────────────────────────
-with gr.Blocks(title="Wordle Solver", theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown("# 🟩 Wordle Solver
-Entropy-trained neural network. Enter each guess + the colour pattern.")
-    gr.Markdown("**Pattern key:** `0` = ⬜ grey · `1` = 🟨 yellow · `2` = 🟩 green")
-
-    state = gr.State(init_state())
-    board_out = gr.Textbox(label="Board", lines=7, interactive=False)
-    msg_out   = gr.Markdown(f"Try: **{OPENING.upper()}** to start")
-
-    with gr.Row():
-        guess_in   = gr.Textbox(label="Your guess",   placeholder="crane", max_lines=1)
-        pattern_in = gr.Textbox(label="Pattern (5 digits)", placeholder="02100", max_lines=1)
-
-    with gr.Row():
-        submit_btn = gr.Button("Submit",  variant="primary")
-        reset_btn  = gr.Button("Reset")
-
-    submit_btn.click(process_guess, [guess_in, pattern_in, state], [board_out, msg_out, state])
-    reset_btn.click(reset, [state], [board_out, msg_out, state])
-
-demo.launch()
+    top50 = [ALLOWED[i] for i in logits.topk(50).indices.tolist()]
+    valid = [w for w in top50
+             if w not in already_guessed and is_consistent(w, history)]
+
+    if not valid:
+        return max(possible_not_guessed or possible,
+                   key=lambda w: entropy_score(w, possible))
+
+    return max(valid[:10], key=lambda w: entropy_score(w, possible))
+
+
+def top_suggestions(history, possible, n=5):
+    if not possible: return []
+
+    already_guessed = {w for w, _ in history}
+
+    if not history:
+        candidates = [OPENING] + [w for w in ALLOWED if w != OPENING][:30]
+    else:
+        state = torch.tensor(encode_board(history)).unsqueeze(0)
+        with torch.no_grad():
+            logits = model(state)[0]
+        candidates = [ALLOWED[i] for i in logits.topk(50).indices.tolist()]
+
+    candidates = [w for w in candidates
+                  if w not in already_guessed and is_consistent(w, history)]
+
+    possible_set = set(possible)
+    scored = [
+        {
+            "word":        w,
+            "entropy":     round(entropy_score(w, possible), 3),
+            "is_possible": w in possible_set,
+        }
+        for w in candidates
+    ]
+    scored.sort(key=lambda x: (-x["entropy"], not x["is_possible"]))
+    return scored[:n]
+
+# ── Models ────────────────────────────────────────────────────────────────────
+class GuessEntry(BaseModel):
+    word: str
+    pattern: list[int]
+
+class SuggestRequest(BaseModel):
+    history: list[GuessEntry] = []
+
+class SuggestResponse(BaseModel):
+    suggestion: str
+    top_suggestions: list[dict]
+    possible_count: int
+    bits_remaining: float
+    solved: bool
+    message: str
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+@app.get("/")
+def root():
+    return {"status": "ok", "opener": OPENING}
+
+@app.post("/suggest", response_model=SuggestResponse)
+def suggest(req: SuggestRequest):
+    possible = list(ANSWERS)
+
+    for entry in req.history:
+        word    = entry.word.lower().strip()
+        pattern = tuple(entry.pattern)
+        if len(word) != 5:
+            raise HTTPException(400, f"Word must be 5 letters: {word}")
+        if len(pattern) != 5 or not all(p in (0, 1, 2) for p in pattern):
+            raise HTTPException(400, "Pattern must be 5 values of 0, 1, or 2")
+        if pattern == WIN_PATTERN:
+            return SuggestResponse(
+                suggestion=word, top_suggestions=[], possible_count=1,
+                bits_remaining=0.0, solved=True,
+                message=f"Solved in {len(req.history)} guesses!"
+            )
+        possible = filter_words(possible, word, pattern)
+
+    if not possible:
+        raise HTTPException(422, "No possible words remaining. Check your pattern input.")
+
+    history_tuples = [(e.word.lower(), tuple(e.pattern)) for e in req.history]
+    suggestion     = model_suggest(history_tuples, possible)
+    if not suggestion:
+        suggestion = possible[0]
+    top_suggs      = top_suggestions(history_tuples, possible)
+    bits           = math.log2(len(possible)) if len(possible) > 1 else 0.0
+
+    return SuggestResponse(
+        suggestion=suggestion,
+        top_suggestions=top_suggs,
+        possible_count=len(possible),
+        bits_remaining=round(bits, 2),
+        solved=False,
+        message=f"{len(possible)} words remaining — try {suggestion.upper()}"
+    )
+
+@app.get("/opener")
+def get_opener():
+    return {"word": OPENING}

requirements.txt

@@ -1,4 +1,6 @@
-torch
-gradio
+fastapi
+uvicorn
 huggingface_hub
 numpy
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.10.0+cpu