Initial commit with Xet-managed safetensors

.gitattributes

@@ -0,0 +1 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,108 @@
+# =========================
+# Python
+# =========================
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+*.egg-info/
+.eggs/
+.env
+.venv
+venv/
+ENV/
+env/
+sudoku.csv
+
+# =========================
+# PyTorch / ML
+# =========================
+*.pt
+*.pth
+*.ckpt
+*.bin
+*.onnx
+*.trt
+*.engine
+
+# Allow safetensors (HF preferred)
+!*.safetensors
+
+# =========================
+# Training / Runtime
+# =========================
+runs/
+logs/
+lightning_logs/
+wandb/
+mlruns/
+tensorboard/
+tb_logs/
+.prof
+*.log
+
+# =========================
+# Datasets (do NOT upload raw datasets)
+# =========================
+data/
+datasets/
+*.csv
+*.tsv
+*.parquet
+*.arrow
+*.jsonl
+*.hdf5
+*.npz
+
+# =========================
+# Caches
+# =========================
+.cache/
+huggingface/
+hf_cache/
+torch_cache/
+transformers_cache/
+
+# =========================
+# Jupyter / Colab
+# =========================
+.ipynb_checkpoints/
+*.ipynb
+*.colab
+
+# =========================
+# OS / Editor
+# =========================
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+.idea/
+.vscode/
+.history/
+
+# =========================
+# Build / Packaging
+# =========================
+dist/
+build/
+*.tar.gz
+*.zip
+
+# =========================
+# Secrets
+# =========================
+*.key
+*.pem
+*.crt
+*.token
+.env.*
+
+# =========================
+# Temporary / Scratch
+# =========================
+tmp/
+temp/
+scratch/
+

README.md

@@ -0,0 +1,130 @@
+---
+license: cc-by-nc-4.0
+tags:
+- sudoku
+- reasoning
+- pytorch
+- rhan
+---
+
+# PotatoAGI (RHAN-Sudoku)
+
+This is the official weight repository for the **Recurrent Hybrid Attention Network (RHAN)** trained on Sudoku.
+
+It uses a **Universal Linear Attention** mechanism combined with **Recursive Memory** and was trained using **Adversarial Erasure**.
+
+## Stats
+- **Parameters:** ~150k
+- **Architecture:** 12-Loop Recurrent CNN + Linear Attention
+- **Accuracy:** 99% Cell Accuracy / 90%+ Perfect Solve Rate
+- **License:** CC BY-NC 4.0 (Non-Commercial Research Use Only)
+
+## Files in this Repository
+
+model.py # Model architecture (UniversalPotato)
+model.safetensors # Trained weights
+local_test_sudoku.py # Dataset-based local evaluation
+README.md
+
+## Usage
+### 1️⃣ Install dependencies
+
+```bash
+pip install torch safetensors
+```
+
+Python ≥ 3.10 recommended.
+
+2️⃣ Load the model and weights
+
+import torch
+from safetensors.torch import load_file
+from model import UniversalPotato, HIDDEN_DIM
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+model = UniversalPotato().to(device)
+model.load_state_dict(load_file("model.safetensors"), strict=True)
+model.eval()
+
+3️⃣ Run inference on a single Sudoku puzzle
+
+Sudoku grids are represented as a flat tensor of length 81,
+with 0 indicating empty cells.
+
+# Example puzzle (0 = empty)
+puzzle = [
+    5,3,0,0,7,0,0,0,0,
+    6,0,0,1,9,5,0,0,0,
+    0,9,8,0,0,0,0,6,0,
+    8,0,0,0,6,0,0,0,3,
+    4,0,0,8,0,3,0,0,1,
+    7,0,0,0,2,0,0,0,6,
+    0,6,0,0,0,0,2,8,0,
+    0,0,0,4,1,9,0,0,5,
+    0,0,0,0,8,0,0,7,9,
+]
+
+clues = torch.tensor(puzzle, dtype=torch.long).unsqueeze(0).to(device)
+board = clues.clone()
+memory = torch.zeros(1, HIDDEN_DIM, 9, 9, device=device)
+
+with torch.no_grad():
+    for _ in range(24):  # reasoning steps
+        logits, memory = model(
+            clues=clues,
+            current_board=board,
+            memory=memory,
+            blindfold=False,
+        )
+        board = logits.argmax(dim=-1)
+
+solution = board.view(9, 9).cpu()
+print(solution)
+
+4️⃣ Dataset-based evaluation
+
+To evaluate the model on a real Sudoku dataset:
+
+    Download sudoku.csv from Kaggle
+    👉 https://www.kaggle.com/datasets/rohanrao/sudoku
+
+    Place it in the repository root
+
+    Run:
+
+python local_test_sudoku.py
+
+This script:
+
+    runs multi-step inference
+
+    compares predictions against ground truth
+
+    reports solve success rate
+
+Notes
+
+    This model does not use Hugging Face Transformers
+
+    model.py is the authoritative architecture definition
+
+    Inference requires multiple recurrent steps for best results
+
+    Designed for reasoning research, not commercial deployment
+
+License
+
+This project is released under CC BY-NC 4.0.
+
+You may:
+
+    use
+
+    modify
+
+    redistribute
+    for non-commercial research purposes only, with attribution.
+
+Commercial use is not permitted.
+

local_test_sudoku.py

@@ -0,0 +1,124 @@
+import os
+import csv
+import torch
+from safetensors.torch import load_file
+
+from model import UniversalPotato, HIDDEN_DIM
+
+CSV_PATH = "sudoku.csv"
+WEIGHTS_PATH = "model.safetensors"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+STEPS = 24
+MAX_PUZZLES = 50
+
+
+def require_sudoku_csv(path: str):
+    if not os.path.exists(path):
+        raise FileNotFoundError(
+            """
+sudoku.csv not found.
+
+Please download it manually from:
+https://www.kaggle.com/datasets/rohanrao/sudoku
+
+Then place sudoku.csv in the project root.
+"""
+        )
+
+
+def load_sudoku_csv(path: str, limit: int):
+    puzzles = []
+    solutions = []
+
+    with open(path, newline="") as f:
+        reader = csv.DictReader(f)
+
+        if not reader.fieldnames:
+            raise RuntimeError("sudoku.csv has no header row")
+
+        # Normalize headers
+        fieldnames_lower = [h.lower() for h in reader.fieldnames]
+
+        def pick(*candidates):
+            for name in candidates:
+                if name in fieldnames_lower:
+                    return reader.fieldnames[fieldnames_lower.index(name)]
+            return None
+
+        puzzle_key = pick("puzzle", "quiz", "quizzes")
+        solution_key = pick("solution", "solutions")
+
+        if puzzle_key is None or solution_key is None:
+            raise RuntimeError(
+                f"Unsupported sudoku.csv format. Headers found: {reader.fieldnames}"
+            )
+
+        for i, row in enumerate(reader):
+            if i >= limit:
+                break
+            puzzles.append(row[puzzle_key])
+            solutions.append(row[solution_key])
+
+    return puzzles, solutions
+
+
+def str_to_tensor(grid_str: str) -> torch.Tensor:
+    return torch.tensor([int(c) for c in grid_str], dtype=torch.long)
+
+
+def tensor_to_str(t: torch.Tensor) -> str:
+    return "".join(str(int(x)) for x in t)
+
+
+def run_inference(model, clues: torch.Tensor, steps: int):
+    clues = clues.unsqueeze(0).to(DEVICE)
+    board = clues.clone()
+    memory = torch.zeros(1, HIDDEN_DIM, 9, 9, device=DEVICE)
+
+    with torch.no_grad():
+        for _ in range(steps):
+            logits, memory = model(
+                clues=clues,
+                current_board=board,
+                memory=memory,
+                blindfold=False,
+            )
+            board = logits.argmax(dim=-1)
+
+    return board.squeeze(0).cpu()
+
+
+def main():
+    require_sudoku_csv(CSV_PATH)
+
+    puzzles, solutions = load_sudoku_csv(CSV_PATH, MAX_PUZZLES)
+
+    model = UniversalPotato().to(DEVICE)
+    model.load_state_dict(load_file(WEIGHTS_PATH), strict=True)
+    model.eval()
+
+    solved = 0
+
+    for i, (quiz, solution) in enumerate(zip(puzzles, solutions), 1):
+        clues = str_to_tensor(quiz)
+        target = solution
+
+        pred = run_inference(model, clues, STEPS)
+        pred_str = tensor_to_str(pred)
+
+        success = pred_str == target
+        solved += int(success)
+
+        print(f"\nPuzzle {i}")
+        print("Solved:", success)
+        print(pred.view(9, 9))
+
+    print("\n==============================")
+    print(f"Solved {solved}/{len(puzzles)} puzzles")
+    print("==============================")
+
+
+if __name__ == "__main__":
+    main()
+

model.py

@@ -0,0 +1,125 @@
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+
+# --- CONFIGURATION ---
+INPUT_CELLS = 81
+NUM_CLASSES = 10
+HIDDEN_DIM = 128
+ATTN_HEADS = 4   # MUST match training script
+
+class StandardAttention2D(nn.Module):
+    """
+    Standard O(N^2) Multi-Head Attention for 2D grids.
+    Zero-initialized output projection to start as identity.
+    """
+    def __init__(self, dim, heads=ATTN_HEADS):
+        super().__init__()
+        self.scale = dim ** -0.5
+        self.heads = heads
+        self.head_dim = dim // heads
+
+        self.to_qkv = nn.Conv2d(dim, dim * 3, kernel_size=1, bias=False)
+        self.to_out = nn.Sequential(
+            nn.Conv2d(dim, dim, kernel_size=1),
+            nn.GroupNorm(8, dim)
+        )
+
+        # Zero-init so attention starts as a no-op
+        init.zeros_(self.to_out[0].weight)
+        init.zeros_(self.to_out[0].bias)
+
+    def forward(self, x):
+        b, c, h, w = x.shape
+        n = h * w
+
+        qkv = self.to_qkv(x).view(b, 3 * c, n)
+        q, k, v = qkv.chunk(3, dim=1)
+
+        q = q.view(b, self.heads, self.head_dim, n).permute(0, 1, 3, 2)
+        k = k.view(b, self.heads, self.head_dim, n).permute(0, 1, 3, 2)
+        v = v.view(b, self.heads, self.head_dim, n).permute(0, 1, 3, 2)
+
+        dots = (q @ k.transpose(-2, -1)) * self.scale
+        attn = dots.softmax(dim=-1)
+
+        out = (attn @ v).transpose(1, 2).reshape(b, c, h, w)
+        return self.to_out(out) + x
+
+
+class UniversalPotato(nn.Module):
+    """
+    EXACT match to the Colab-trained HybridPotato architecture.
+    No positional embeddings. Blindfold-compatible.
+    """
+    def __init__(self):
+        super().__init__()
+
+        self.embed_clues = nn.Embedding(NUM_CLASSES, HIDDEN_DIM)
+        self.embed_board = nn.Embedding(NUM_CLASSES, HIDDEN_DIM)
+
+        self.input_proj = nn.Sequential(
+            nn.Conv2d(HIDDEN_DIM * 3, HIDDEN_DIM, kernel_size=1),
+            nn.GroupNorm(8, HIDDEN_DIM),
+            nn.SiLU()
+        )
+
+        self.core = nn.Sequential(
+            # Local
+            nn.Conv2d(HIDDEN_DIM, HIDDEN_DIM, 3, padding=1),
+            nn.GroupNorm(8, HIDDEN_DIM),
+            nn.SiLU(),
+
+            # Global
+            StandardAttention2D(HIDDEN_DIM),
+            nn.SiLU(),
+
+            # Mid-range
+            nn.Conv2d(HIDDEN_DIM, HIDDEN_DIM, 3, padding=2, dilation=2),
+            nn.GroupNorm(8, HIDDEN_DIM),
+            nn.SiLU(),
+
+            # Processing
+            nn.Conv2d(HIDDEN_DIM, HIDDEN_DIM, 3, padding=4, dilation=4),
+            nn.GroupNorm(8, HIDDEN_DIM),
+            nn.SiLU()
+        )
+
+        self.head = nn.Conv2d(HIDDEN_DIM, NUM_CLASSES, kernel_size=1)
+        self.memory_norm = nn.GroupNorm(8, HIDDEN_DIM)
+
+    def run_core(self, x):
+        return self.core(x)
+
+    def forward(self, clues, current_board, memory, blindfold=False):
+        b, n = clues.shape
+
+        clues_emb = (
+            self.embed_clues(clues)
+            .transpose(1, 2)
+            .view(b, HIDDEN_DIM, 9, 9)
+        )
+
+        board_emb = (
+            self.embed_board(current_board)
+            .transpose(1, 2)
+            .view(b, HIDDEN_DIM, 9, 9)
+        )
+
+        if blindfold:
+            board_emb = torch.zeros_like(board_emb)
+
+        raw = torch.cat([clues_emb, board_emb, memory], dim=1)
+        z = self.input_proj(raw)
+        z = self.core(z)
+
+        new_memory = self.memory_norm(memory + z)
+
+        logits = (
+            self.head(z)
+            .view(b, NUM_CLASSES, 81)
+            .transpose(1, 2)
+        )
+
+        return logits, new_memory
+

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b0fe7f3855cf4e18b9a13d0cb83a3c741f81be5e504825d731f5c1cfd44eca7
+size 2254560

model_100k.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:052d53a28bc9141494e6e1f3a467be4a659ce61c203e1001dfee56179a9aa93a
+size 2254560

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "potato-agi"
+version = "1.0.0"
+description = "Official weights for PotatoAGI (RHAN)"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "torch",
+    "numpy",
+    "safetensors",
+    "requests",
+    "pandas",
+    "packaging"
+]