Add Tiny Aya Global vs Earth ZeroGPU comparison app

README.md

@@ -1,13 +1,130 @@
 ---
 title: Tiny Aya Compare
-emoji: 🚀
-colorFrom: gray
-colorTo: pink
+emoji: 🌍
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 6.18.0
-python_version: '3.12'
 app_file: app.py
-pinned: false
+python_version: "3.12"
+startup_duration_timeout: 30m
+short_description: Compare Tiny Aya Global vs Earth side by side
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Tiny Aya Compare
+
+Side-by-side comparison of [CohereLabs/tiny-aya-global](https://huggingface.co/CohereLabs/tiny-aya-global) and
+[CohereLabs/tiny-aya-earth](https://huggingface.co/CohereLabs/tiny-aya-earth) on the same prompt.
+
+**Live Space:** https://huggingface.co/spaces/build-small-hackathon/tiny-aya-compare
+
+This Space runs on **ZeroGPU** using the PyTorch/safetensors checkpoints (not the GGUF builds).
+
+## Deploy to ZeroGPU (build-small-hackathon)
+
+### Prerequisites
+
+- Hugging Face account with access to the `build-small-hackathon` org
+- **PRO, Team, or Enterprise** plan (required to attach ZeroGPU to a Space you create)
+- `hf` CLI installed and authenticated: `hf auth login`
+- Access to the gated CohereLabs Tiny Aya models
+
+### 1. Create the Space
+
+```bash
+hf repos create build-small-hackathon/tiny-aya-compare \
+  --type space \
+  --space-sdk gradio \
+  --flavor zero-a10g \
+  --public \
+  --exist-ok
+```
+
+`--flavor zero-a10g` selects ZeroGPU. Hardware is **not** set via README frontmatter.
+
+If the Space already exists on `cpu-basic`, switch hardware:
+
+```bash
+hf spaces settings build-small-hackathon/tiny-aya-compare --hardware zero-a10g
+```
+
+### 2. Add the gated-model token
+
+Both Tiny Aya checkpoints are gated. Add a Space secret so the runtime can download them:
+
+```bash
+hf spaces secrets add build-small-hackathon/tiny-aya-compare \
+  --key HF_TOKEN \
+  --value "$(hf auth token)"
+```
+
+Use a token with access to `CohereLabs/tiny-aya-global` and `CohereLabs/tiny-aya-earth`.
+
+### 3. Push the app
+
+From this repo:
+
+```bash
+git init
+git add app.py README.md requirements.txt
+git commit -m "Add Tiny Aya Global vs Earth ZeroGPU comparison app"
+git remote add space https://huggingface.co/spaces/build-small-hackathon/tiny-aya-compare
+git push space HEAD:main
+```
+
+Or upload without git:
+
+```bash
+hf upload build-small-hackathon/tiny-aya-compare . \
+  --include "app.py" \
+  --include "README.md" \
+  --include "requirements.txt"
+```
+
+### 4. Verify the deployment
+
+```bash
+# Runtime stage and hardware
+hf spaces info build-small-hackathon/tiny-aya-compare --expand runtime
+
+# Build + startup logs
+hf spaces logs build-small-hackathon/tiny-aya-compare --tail 200
+
+# Smoke test (after RUNNING)
+gradio predict build-small-hackathon/tiny-aya-compare /compare \
+  '{"prompt": "Explain photosynthesis simply.", "max_new_tokens": 128, "temperature": 0.7, "top_p": 0.9}'
+```
+
+Expect `requested_hardware: zero-a10g` and both models loading at startup (~6 GB each in bf16).
+
+### 5. Update after changes
+
+| Change | Action |
+|--------|--------|
+| `app.py`, `README.md` | `git push space main` (hot-reload) |
+| `requirements.txt` | push → full Space rebuild |
+| Hardware / secrets | `hf spaces settings` / `hf spaces secrets add` |
+
+## Local development (uv)
+
+ZeroGPU Spaces require **Python 3.12** (not 3.14):
+
+```bash
+uv python pin 3.12
+uv sync --group dev
+uv run python app.py
+```
+
+Refresh `requirements.txt` after dependency changes (keep it minimal — Spaces preinstall `torch`, `gradio`, `spaces`, `huggingface_hub`):
+
+```bash
+# Edit requirements.txt manually, e.g.:
+# accelerate>=1.4.0
+# transformers>=4.50.0
+```
+
+## Why not GGUF here?
+
+ZeroGPU is built around PyTorch and `@spaces.GPU`. GGUF targets llama.cpp (Ollama, `llama-server`, local inference) and does not integrate with ZeroGPU's scheduler.
+
+Use the Transformers checkpoints in this Space. The [GGUF repos](https://huggingface.co/CohereLabs/tiny-aya-global-GGUF) remain useful for local llama.cpp deployment.

app.py

@@ -0,0 +1,166 @@
+import os
+import time
+
+import spaces
+import torch
+import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+MODELS = {
+    "global": {
+        "repo_id": "CohereLabs/tiny-aya-global",
+        "title": "Tiny Aya Global",
+        "subtitle": "Broad multilingual coverage (67+ languages).",
+    },
+    "earth": {
+        "repo_id": "CohereLabs/tiny-aya-earth",
+        "title": "Tiny Aya Earth",
+        "subtitle": "Grounded variant tuned for real-world context.",
+    },
+}
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+tokenizers: dict[str, AutoTokenizer] = {}
+models: dict[str, AutoModelForCausalLM] = {}
+
+for key, meta in MODELS.items():
+    repo_id = meta["repo_id"]
+    tokenizers[key] = AutoTokenizer.from_pretrained(repo_id, token=HF_TOKEN)
+    models[key] = AutoModelForCausalLM.from_pretrained(
+        repo_id,
+        torch_dtype=torch.bfloat16,
+        token=HF_TOKEN,
+    ).to("cuda")
+
+EXAMPLES = [
+    ["Explain photosynthesis in simple terms."],
+    ["¿Cuál es la capital de Perú y qué la hace especial?"],
+    ["Write a short haiku about rain."],
+    ["Quelles sont les différences entre le français québécois et le français de France?"],
+]
+
+
+def _generate_one(
+    key: str,
+    prompt: str,
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+) -> tuple[str, float]:
+    tokenizer = tokenizers[key]
+    model = models[key]
+    inputs = tokenizer.apply_chat_template(
+        [{"role": "user", "content": prompt}],
+        add_generation_prompt=True,
+        return_tensors="pt",
+    ).to(model.device)
+
+    gen_kwargs: dict = {
+        "max_new_tokens": max_new_tokens,
+        "top_p": top_p,
+        "pad_token_id": tokenizer.eos_token_id,
+    }
+    if temperature > 0:
+        gen_kwargs["do_sample"] = True
+        gen_kwargs["temperature"] = temperature
+    else:
+        gen_kwargs["do_sample"] = False
+
+    started = time.perf_counter()
+    with torch.inference_mode():
+        output = model.generate(inputs, **gen_kwargs)
+    elapsed = time.perf_counter() - started
+
+    response = tokenizer.decode(
+        output[0, inputs.shape[-1] :],
+        skip_special_tokens=True,
+    ).strip()
+    return response, elapsed
+
+
+def estimate_duration(
+    prompt: str,
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+) -> int:
+    _ = (prompt, temperature, top_p)
+    return int(10 + max_new_tokens * 0.2)
+
+
+@spaces.GPU(duration=estimate_duration)
+def compare(
+    prompt: str,
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+) -> tuple[str, str, str, str]:
+    if not prompt.strip():
+        message = "Enter a prompt to compare both models."
+        return message, message, "", ""
+
+    global_text, global_time = _generate_one(
+        "global", prompt, max_new_tokens, temperature, top_p
+    )
+    earth_text, earth_time = _generate_one(
+        "earth", prompt, max_new_tokens, temperature, top_p
+    )
+
+    global_stats = f"{global_time:.2f}s"
+    earth_stats = f"{earth_time:.2f}s"
+    return global_text, earth_text, global_stats, earth_stats
+
+
+with gr.Blocks(title="Tiny Aya Compare") as demo:
+    gr.Markdown(
+        """
+        # Tiny Aya: Global vs Earth
+        Side-by-side comparison of [tiny-aya-global](https://huggingface.co/CohereLabs/tiny-aya-global)
+        and [tiny-aya-earth](https://huggingface.co/CohereLabs/tiny-aya-earth) on ZeroGPU.
+
+        Both models are gated. Set an `HF_TOKEN` Space secret with access to CohereLabs models.
+        """
+    )
+
+    prompt = gr.Textbox(
+        label="Prompt",
+        placeholder="Ask the same question in any supported language…",
+        lines=3,
+    )
+
+    with gr.Row():
+        max_new_tokens = gr.Slider(
+            16, 512, value=256, step=16, label="Max new tokens"
+        )
+        temperature = gr.Slider(0, 1.5, value=0.7, step=0.05, label="Temperature")
+        top_p = gr.Slider(0.1, 1.0, value=0.9, step=0.05, label="Top-p")
+
+    compare_btn = gr.Button("Compare", variant="primary")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(f"### {MODELS['global']['title']}")
+            gr.Markdown(MODELS["global"]["subtitle"])
+            global_out = gr.Textbox(label="Response", lines=12)
+            global_stats = gr.Textbox(label="Latency", interactive=False)
+        with gr.Column():
+            gr.Markdown(f"### {MODELS['earth']['title']}")
+            gr.Markdown(MODELS["earth"]["subtitle"])
+            earth_out = gr.Textbox(label="Response", lines=12)
+            earth_stats = gr.Textbox(label="Latency", interactive=False)
+
+    gr.Examples(
+        examples=EXAMPLES,
+        inputs=[prompt],
+        cache_examples=False,
+    )
+
+    compare_btn.click(
+        fn=compare,
+        inputs=[prompt, max_new_tokens, temperature, top_p],
+        outputs=[global_out, earth_out, global_stats, earth_stats],
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,2 @@
+accelerate>=1.4.0
+transformers>=4.50.0