fix: add .gitattributes for binary files, Dockerfile --chown for weights

Dockerfile

@@ -5,9 +5,14 @@ WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
+# Copy text files first
 COPY app.py .
 COPY tiny_fighter.py .
-COPY tiny_fighter.pt .
+
+# Copy binary weights file - use --chown to avoid permission issues
+COPY --chown=root:root tiny_fighter.pt .
+
+# Copy static assets
 COPY static/ static/
 
 ENV PORT=7860

app.py

@@ -32,7 +32,11 @@ def get_model() -> TinyFighter:
     if _tiny_model is None:
         _tiny_model = TinyFighter()
         if WEIGHTS_PATH.exists():
-            _tiny_model.load_state_dict(torch.load(WEIGHTS_PATH, map_location="cpu"))
+            # Debug: verify file integrity
+            with open(WEIGHTS_PATH, "rb") as f:
+                head = f.read(8)
+            print(f"Loading weights from {WEIGHTS_PATH}, size={WEIGHTS_PATH.stat().st_size}, head={head[:4].hex()}")
+            _tiny_model.load_state_dict(torch.load(WEIGHTS_PATH, map_location="cpu", weights_only=False))
         _tiny_model.eval()
     return _tiny_model
 

docs/DEMO_VIDEO_SCRIPT.md

@@ -0,0 +1,48 @@
+# Duel of Nemotron — Demo Video Script
+
+*Target length: 60–90 seconds. Vertical or landscape.*
+
+## Beat 1 (0:00–0:05) — Cold open
+*[Screen: black with text fade-in]*
+**"What if a 4-billion parameter model and a 142-thousand parameter model fought together?"**
+
+## Beat 2 (0:05–0:20) — The game
+*[Screen: Space loads, character select, then the arena]*
+- Pick a fighter (ronin vs brute)
+- First few seconds of combat — show the NPC reacting to your moves
+- HUD shows the Nemotron "reasoning" text in real time
+- Text overlay: *"Tiny model on CPU picks each move. Nemotron on Modal sets the strategy."*
+
+## Beat 3 (0:20–0:40) — The strategy switch
+*[Screen: gameplay continues, then the Nemotron output changes]*
+- Player lands a few hits, NPC's HP drops
+- Nemotron reasoning updates: *"NPC adapts: high aggression, parry-focused"*
+- NPC starts parrying and countering
+- Text overlay: *"Every ~10 moves, Nemotron on Modal A10 picks a new mode"*
+- Show the `/strategize` response JSON in a small overlay (fades in for 2s)
+
+## Beat 4 (0:40–0:55) — The tiny model in action
+*[Screen: cut to the Gradio panel at /gradio]*
+- Show the Tiny Fighter Gradio demo
+- Move the sliders: aggression 0.9, defense 0.1, kick_affinity 0.8
+- Click "Pick Move" → model outputs "kick" with 0.25 confidence
+- Text overlay: *"142k params. 0.093ms inference. Runs on CPU in the Space."*
+
+## Beat 5 (0:55–1:05) — Outro
+*[Screen: split view — the 3D game on the left, the Gradio demo on the right]*
+**"Nemotron 3 Nano 4B, fine-tuned via AlphaGo-style self-play. The tiny model learned to execute the strategy in 20 minutes on a laptop."**
+- HF Space link
+- Hackathon credits
+
+## Recording tips
+- Record at 1080p, 30fps
+- Use OBS for screen capture
+- Pre-warm Nemotron before recording (60–90s cold start)
+- Add subtle lo-fi music (royalty-free)
+- The Tiny Fighter inference is sub-millisecond, so it's instant
+
+## Post-production
+- Add captions for accessibility
+- Export as MP4, H.264
+- Upload to YouTube (unlisted) or Twitter
+- Submit link with the Space URL

docs/FIELD_NOTES.md

@@ -0,0 +1,42 @@
+# Duel of Nemotron — Field Notes
+
+*Built for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon) by [@sankalphs](https://huggingface.co/sankalphs)*
+
+## What I built
+
+A 3D fighting game where the NPC opponent is powered by **two models** working together:
+
+- **Nemotron 3 Nano 4B** (fine-tuned, runs on Modal A10) — the *strategist*. Every several moves it looks at the fight state and outputs a mode: aggressive, defensive, grappling, etc.
+- **Tiny Fighter** (~142k parameters, runs on CPU in the HF Space) — the *executor*. Conditioned on Nemotron's strategic weights, it picks the actual next move in **less than 1 millisecond**.
+
+This is the same pattern AlphaGo used: a big model that thinks about the big picture, and a fast policy network that picks the concrete move. The twist is that for a real-time fighting game, the fast network has to be *really* fast — sub-millisecond per move, on CPU, inside an HF Space.
+
+## How the training worked
+
+I trained Nemotron on Modal A100-40GB in three stages:
+
+1. **SFT bootstrap** — 12,000 procedurally generated examples teaching Nemotron to output a JSON of strategic weights given the fight state. Loss went from 2.5 → 2.17 over 3 epochs.
+
+2. **Self-play rollouts** — the SFT model played 100 fights against itself. Each trajectory got a reward: positive for winning trajectories, negative for losing ones. This gave me 106 trajectory points.
+
+3. **Reward-weighted fine-tuning** — I fine-tuned on the self-play data for 3 more epochs, reinforcing high-reward completions and suppressing low-reward ones. This is a simplified version of GRPO that doesn't need the `trl` library.
+
+The LoRA adapter is published at [sankalphs/duel-nemotron-strategist](https://huggingface.co/sankalphs/duel-nemotron-strategist).
+
+## How the tiny model works
+
+142,000 parameters. Three-layer MLP with BatchNorm. Input is 168 features: one-hot encodings of the last 5 NPC and 5 player moves, HP and stamina deltas, distance bucket, and the 5 Nemotron strategic weights. Output is 15 move logits (jab, cross, hook, kick, uppercut, block, parry, dodge, advance, retreat, grapple, throw, sweep, feint, wait).
+
+Training data: 20,000 procedurally generated (state, strategy) → move examples. Inference: **0.093ms per call on CPU**. The model runs in the HF Space itself — no cloud round-trip for each move.
+
+## What I learned
+
+- **Hybrid architectures are underused for real-time games.** A 4B model is great for thinking but terrible for real-time frame-by-frame decisions. A 142k model is the opposite. Pairing them gives you both.
+- **Nemotron is a hybrid Mamba2/Transformer model.** It needs `mamba-ssm` and `causal-conv1d` to run. The Unsloth re-upload is the easiest way to get a working tokenizer config.
+- **HF Spaces have a hard limit of 3 CPU spaces on the free tier.** For production, use the `cpu-upgrade` hardware tier with HF credits.
+- **Binary files don't push via git to HF Spaces.** Use the HF API (`upload_folder`) which uses Xet storage.
+- **Modal cold start is 60–90 seconds for a 4B model.** The Space proxy needs a 120s timeout.
+
+## Try it
+
+[Live Space](https://huggingface.co/spaces/sankalphs/duel) · [Fine-tuned adapter](https://huggingface.co/sankalphs/duel-nemotron-strategist) · [Source code](https://github.com/sankalphs/duel)

nemotron-duel/modal/inference_only.py

@@ -0,0 +1,239 @@
+"""Minimal Modal app: inference only.
+Removes all training/data functions to keep the Modal deployment lean.
+Only the inference web function remains.
+"""
+from __future__ import annotations
+import json
+import os
+from pathlib import Path
+
+import modal
+
+MODEL_VOLUME = modal.Volume.from_name("nemotron-duel-models", create_if_missing=False)
+MODEL_PATH = "/vol/models"
+
+BASE_MODEL = "unsloth/NVIDIA-Nemotron-3-Nano-4B"
+GPU_INFER = "A10"
+
+# Minimal image: just what inference needs (Nemotron + mamba-ssm + causal-conv1d)
+image = (
+    modal.Image.from_registry(
+        "nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11"
+    )
+    .apt_install("git", "gcc", "g++")
+    .pip_install("ninja", "packaging", "wheel", "setuptools>=70.1")
+    .pip_install(
+        "torch==2.5.1",
+        "transformers==4.50.0",
+        "tokenizers==0.21.4",
+        "huggingface_hub>=0.26.0",
+        "peft>=0.14.0",
+        "accelerate>=0.34.0",
+        "starlette>=0.40.0",
+        "fastapi>=0.110.0",
+        extra_index_url="https://download.pytorch.org/whl/cu124",
+    )
+    .pip_install(
+        "causal-conv1d",
+        "mamba-ssm",
+        "torch==2.5.1",
+        extra_index_url="https://download.pytorch.org/whl/cu124",
+        extra_options="--no-build-isolation",
+        env={"CC": "gcc", "CXX": "g++", "TORCH_CUDA_ARCH_LIST": "8.6"},
+    )
+    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})
+)
+
+app = modal.App("nemotron-duel-inference", image=image)
+
+
+@app.function(
+    volumes={MODEL_PATH: MODEL_VOLUME},
+    gpu=GPU_INFER,
+    scaledown_window=300,
+    secrets=[modal.Secret.from_name("huggingface-secret")],
+)
+@modal.concurrent(max_inputs=10)
+@modal.asgi_app()
+def inference():
+    """Serve Nemotron strategist via ASGI on A10 GPU. Inference only."""
+    import torch
+    from starlette.applications import Starlette
+    from starlette.routing import Route
+    from starlette.requests import Request
+    from starlette.responses import JSONResponse
+    from starlette.middleware.cors import CORSMiddleware
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    from peft import PeftModel
+    from huggingface_hub import login
+
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        login(token)
+
+    _model = None
+    _tokenizer = None
+
+    SYSTEM_PROMPT = (
+        "You are an expert fighting game NPC strategist for Duel of Albion. "
+        "Based on the fight state (HP, stamina, distance, characters, last 10 moves), "
+        "output a JSON object with strategic weight parameters:\n"
+        "  aggression (0-1), defense (0-1), parry_affinity (0-1), "
+        "kick_affinity (0-1), grapple_affinity (0-1), reasoning.\n"
+        "Return ONLY the JSON object."
+    )
+
+    def get_model():
+        nonlocal _model, _tokenizer
+        if _model is None:
+            print("Loading Nemotron model (cold start)...")
+            adapter_path = Path(MODEL_PATH) / "adapters" / "grpo"
+            if not adapter_path.exists():
+                adapter_path = Path(MODEL_PATH) / "adapters" / "sft"
+
+            _tokenizer = AutoTokenizer.from_pretrained(
+                BASE_MODEL, cache_dir=MODEL_PATH, token=token, trust_remote_code=True,
+            )
+            _model = AutoModelForCausalLM.from_pretrained(
+                BASE_MODEL, cache_dir=MODEL_PATH, token=token, trust_remote_code=True,
+                torch_dtype=torch.bfloat16, device_map="auto",
+            )
+            if adapter_path.exists():
+                _model = PeftModel.from_pretrained(_model, str(adapter_path), token=token)
+            _model.eval()
+            print("Model loaded!")
+        return _model, _tokenizer
+
+    async def health(request):
+        return JSONResponse({"status": "ok", "cold_start": _model is None})
+
+    async def strategize(request: Request):
+        try:
+            body = await request.json()
+        except Exception:
+            body = {}
+
+        # Accept either {playerChar, npcChar, ...} or {sequence, state} format
+        if "sequence" in body or "state" in body:
+            state = body.get("state", {})
+            sequence = body.get("sequence", "")
+            player_char = state.get("playerChar", "ronin")
+            npc_char = state.get("npcChar", "brute")
+            player_hp = state.get("playerHp", 100)
+            npc_hp = state.get("npcHp", 100)
+            player_stamina = state.get("playerStamina", 100)
+            npc_stamina = state.get("npcStamina", 100)
+            round_num = state.get("round", 1)
+            distance = state.get("distance", "mid")
+            moves = sequence.split() if sequence else state.get("lastMoves", [])
+        else:
+            player_char = body.get("playerChar", "ronin")
+            npc_char = body.get("npcChar", "brute")
+            player_hp = body.get("playerHp", 100)
+            npc_hp = body.get("npcHp", 100)
+            player_stamina = body.get("playerStamina", 100)
+            npc_stamina = body.get("npcStamina", 100)
+            round_num = body.get("round", 1)
+            distance = body.get("distance", "mid")
+            moves = body.get("lastMoves", [])
+
+        moves_str = ", ".join(moves[-10:]) if moves else "none"
+
+        prompt = (
+            f"Round {round_num} | Distance: {distance}\n"
+            f"Player ({player_char}): stamina={player_stamina}, hp={player_hp}\n"
+            f"NPC ({npc_char}): stamina={npc_stamina}, hp={npc_hp}\n"
+            f"Last 10 player moves: {moves_str}\n"
+            "Output strategic weights JSON."
+        )
+
+        full = (
+            f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+            f"<|im_start|>user\n{prompt}<|im_end|>\n"
+            f"<|im_start|>assistant\n"
+        )
+
+        model, tokenizer = get_model()
+        inputs = tokenizer(full, return_tensors="pt").to(model.device)
+
+        im_end_id = tokenizer.convert_tokens_to_ids("<|im_end|>")
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=200,
+                temperature=0.6,
+                top_p=0.95,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=[tokenizer.eos_token_id, im_end_id],
+            )
+
+        raw = tokenizer.decode(
+            outputs[0][inputs["input_ids"].shape[-1]:],
+            skip_special_tokens=False,
+        ).strip()
+
+        weights = {
+            "aggression": 0.5, "defense": 0.5, "parry_affinity": 0.4,
+            "kick_affinity": 0.3, "grapple_affinity": 0.3,
+        }
+        reasoning = ""
+
+        def find_first_json(text):
+            start = text.find("{")
+            if start == -1:
+                return None
+            depth = 0
+            in_str = False
+            esc = False
+            for i in range(start, len(text)):
+                c = text[i]
+                if esc:
+                    esc = False
+                    continue
+                if c == "\\":
+                    esc = True
+                    continue
+                if c == '"':
+                    in_str = not in_str
+                    continue
+                if in_str:
+                    continue
+                if c == "{":
+                    depth += 1
+                elif c == "}":
+                    depth -= 1
+                    if depth == 0:
+                        return text[start:i+1]
+            return None
+
+        candidate = find_first_json(raw)
+        if candidate:
+            try:
+                parsed = json.loads(candidate)
+                for k in weights:
+                    weights[k] = float(parsed.get(k, weights[k]))
+                reasoning = parsed.get("reasoning", "")
+            except (json.JSONDecodeError, ValueError):
+                pass
+        if not reasoning:
+            reasoning = "Using default balanced strategy"
+
+        return JSONResponse({
+            "weights": weights,
+            "reasoning": reasoning,
+            "raw": raw,
+        })
+
+    api = Starlette(routes=[
+        Route("/health", health, methods=["GET"]),
+        Route("/strategize", strategize, methods=["POST"]),
+    ])
+    api.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    return api