--- license: apache-2.0 base_model: Qwen/Qwen3.5-9B library_name: transformers pipeline_tag: image-text-to-text language: - en - hi - bn - mr - gu - te - ml - pa - kn - or - ta tags: - alpie - 169pi - qwen3.5 - vision-language - multimodal - reasoning - coding - video-understanding - multilingual - indic - long-context - gguf - 9b - apache-2.0 ---

🌱 Alpie Seed 9B

A 9B open-weight vision-language model for reasoning, coding, and multimodal understanding.

GGUF GitHub

X LinkedIn YouTube Instagram

A short demo of Alpie Seed running fully offline on a mobile device, tested on [PocketPal](https://github.com/a-ghorbani/pocketpal-ai). It shows the quantized model generating responses on-device with no cloud connection. [▶️ Watch the demo video](https://huggingface.co/169Pi/Alpie_seed/resolve/main/alpie_offline_mobile_demo_fast.mp4)

📄 Technical Report

The Alpie Seed Technical Report documents the model in detail: lineage and architecture, the SFT and GRPO post-training pipeline, reward design, quantization and inference profiling, offline results on real devices (desktop GPU, Apple Silicon, mobile, and CPU-only), benchmark results across reasoning, coding, multimodal, and Indic-language tasks, safety evaluation, and limitations.

Read the Technical Report (PDF)

Get Alpie Seed

Run on Ollama Alpie Seed 9B on Kaggle
--- **Alpie Seed 9B** is a multimodal model developed by **169Pi AI**, built on the Qwen3.5-9B architecture and post-trained to strengthen reasoning, instruction following, coding, and visual understanding. It brings together text, image, and video understanding with a 262K context window and multiple quantized formats for deployment across different hardware. ## Alpie Seed Highlights - **Unified vision-language model**: text, image, and video input on the Qwen3.5-9B architecture. - **Reasoning and coding**: post-trained with supervised fine-tuning and GRPO; supports thinking and non-thinking modes. - **262K native context** for long documents and extended conversations. - **Flexible deployment**: FP16 weights plus 2-bit, 3-bit, and 4-bit GGUF builds. - **Open license**: Apache 2.0. ## Available On | Platform | Link | |---|---| | Hugging Face (GGUF) | [169Pi/Alpie_Seed_GGUF](https://huggingface.co/169Pi/Alpie_Seed_GGUF) | | Ollama | [ollama.com/169pi/alpie-seed](https://ollama.com/169pi/alpie-seed) | | Kaggle | [kaggle.com/models/alpie/alpie-seed-9b](https://www.kaggle.com/models/alpie/alpie-seed-9b) | ### Ollama Run Alpie Seed directly from the Ollama library: ```bash ollama run 169pi/alpie-seed ``` Available tags: | Name | Size | Context | Input | |---|---:|---:|---| | `alpie-seed:latest` | 5.6 GB | 256K | Text | | `alpie-seed:q2` | 3.8 GB | 256K | Text | | `alpie-seed:q3` | 4.6 GB | 256K | Text | | `alpie-seed:vision` | 6.6 GB | 256K | Text, Image | To run a specific tag: ```bash ollama run 169pi/alpie-seed:q2 ollama run 169pi/alpie-seed:vision ``` ## Model Overview - Type: Causal Language Model with Vision Encoder - Training Stage: Post-training (SFT + GRPO) on Qwen3.5-9B - Language Model - Number of Parameters: 9B - Hidden Dimension: 4096 - Token Embedding: 248320 (Padded) - Number of Layers: 32 - Hidden Layout: 8 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN)) - Gated DeltaNet: - Number of Linear Attention Heads: 32 for V and 16 for QK - Head Dimension: 128 - Gated Attention: - Number of Attention Heads: 16 for Q and 4 for KV - Head Dimension: 256 - Rotary Position Embedding Dimension: 64 - Feed Forward Network: - Intermediate Dimension: 12288 - LM Output: 248320 (Padded) - MTP: trained with multi-steps - Vision Encoder: 27-layer Vision Transformer - Context Length: 262,144 tokens The architecture is retained from Qwen3.5-9B; Alpie Seed's adaptation is carried out through post-training rather than a structural redesign. ## Training Alpie Seed uses a two-stage post-training pipeline. 1. **Supervised fine-tuning (SFT):** a DORA adapter is trained to improve instruction following, response quality, and task performance. 2. **Group Relative Policy Optimization (GRPO):** a trainable DoRA adapter is optimized while the SFT adapter is kept as a frozen reference policy. The GRPO stage uses a 4-bit NF4 base with double quantization and BF16 computation, and the trained adapter is merged into the base model at its original precision for release. ## Benchmark Results > **Evaluation Settings Note:** All benchmarks were evaluated with extended thinking enabled (`enable_thinking: true`), a maximum generation length of `max_tokens: 65536`, and `temperature: 0.0`. > > Alpie Seed scores are from the FP16 model and do not apply to the 2-bit, 3-bit, or 4-bit variants. **Bold** indicates the best score in each row. Comparison-model scores are taken from published model cards and reports (including the [Qwen3.5-9B model card](https://huggingface.co/Qwen/Qwen3.5-9B)). ### Language
Benchmark Qwen3.5
9B		 Gemma 4
12B		 Ministral 3
8B		 GPT-OSS
20B		 Sarvam
30B		 Nemotron 3.5
Lightning		 Alpie Seed
9B
Knowledge & STEM
MMLU -- -- 76.1 85.3 85.1 78.63 87.30
MMLU-Pro 82.5 77.2 75.00 77.2 80.0 81.94 82.54
GPQA Diamond 81.7 78.8 38.6 71.5 66.5 75.44 84.32
Mathematics
AIME 2026 69.4 77.5 -- -- -- -- 83.33
Coding & Software Engineering
LiveCodeBench v6 65.6 72.0 61.6 61.0 70.0 -- 72.99
SWE-Bench Verified 60.0 52.0 -- 60.7 34.0 51.56 61.20
### Vision Language
Benchmark GPT-5-Nano
2025-08-07		 Gemini-2.5
Flash-Lite		 Qwen3-VL
30B-A3B		 Qwen3.5
9B		 Gemma 4
12B		 Alpie Seed
9B
STEM and Puzzle
MMMU-Pro 57.2 59.7 63.0 70.1 69.1 68.70
MathVision 62.2 52.1 65.7 78.9 79.7 76.76
General VQA
RealWorldQA 71.8 72.2 77.4 80.3 -- 80.39
MMStar 68.6 69.1 75.5 79.7 -- 78.87
HallusionBench 58.4 64.5 66.0 69.3 -- 79.88
Text Recognition & Document Understanding
OCRBench 75.3 82.5 83.9 89.2 -- 90.30
- SWE-Bench Verified: resolved rate using Mini-SWE-agent, with retries disabled. - Comparison-model scores were not re-run by 169Pi, and harnesses, prompts, and benchmark versions differ, so cross-model comparisons are indicative rather than strictly like-for-like. Scores vary with dataset versions, prompts, evaluation harnesses, and inference settings. - Empty cells (--) indicate scores not yet available or not applicable. - Sources: [Ministral 3 8B model card](https://www.modelscope.cn/models/mistralai/Ministral-3-8B-Instruct-2512-BF16), [NVIDIA Nemotron 3.5 Lightning evaluation](https://docs.nvidia.com/nemotron/nightly/nemotron/lightning35/evaluate.html), [Qwen3.5-9B model card](https://huggingface.co/Qwen/Qwen3.5-9B), [Gemma 4 model card](https://huggingface.co/google/gemma-4-12B), [GPT-OSS evaluation](https://deploymentsafety.openai.com/gpt-oss), and [Sarvam-30B model card](https://huggingface.co/sarvamai/sarvam-30b). ## Quickstart ### Install dependencies Alpie Seed support requires a recent Transformers release (Transformers 5 or later). ```bash pip install -U "transformers>=5.2.0" torch torchvision pillow accelerate ``` ### Serve with vLLM (OpenAI-compatible API) Start the standard Alpie Seed 9B server: ```bash vllm serve 169Pi/Alpie_seed \ --port 8000 \ --max-model-len 262144 \ --reasoning-parser qwen3 ``` To enable automatic tool-call parsing, use this command instead: ```bash vllm serve 169Pi/Alpie_seed \ --port 8000 \ --max-model-len 262144 \ --reasoning-parser qwen3 \ --enable-auto-tool-choice \ --tool-call-parser qwen3_coder ``` The API is available at `http://localhost:8000/v1`. The tool-calling options enable vLLM to parse model-generated tool calls; your application is still responsible for executing the requested tools and returning their results. ### Run with Transformers The following examples load the full vision-language checkpoint using `AutoModelForImageTextToText` and `AutoProcessor`. They retain the model's multimodal architecture. The `enable_thinking` argument is passed to the chat template to select the response mode. #### 1. Thinking mode (`enable_thinking=True`) ```python import torch from transformers import AutoModelForImageTextToText, AutoProcessor MODEL_ID = "169Pi/Alpie_seed" processor = AutoProcessor.from_pretrained(MODEL_ID) model = AutoModelForImageTextToText.from_pretrained( MODEL_ID, torch_dtype="auto", device_map="auto", ) model.eval() messages = [ { "role": "user", "content": [ {"type": "text", "text": "Explain why the sky appears blue."} ], } ] inputs = processor.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, enable_thinking=True, return_dict=True, return_tensors="pt", ).to(model.device) with torch.inference_mode(): output_ids = model.generate( **inputs, max_new_tokens=4096, do_sample=True, temperature=0.7, top_p=0.8, ) new_tokens = output_ids[0, inputs["input_ids"].shape[1]:] response = processor.decode(new_tokens, skip_special_tokens=True) print(response) ``` #### 2. Non-thinking mode (`enable_thinking=False`) ```python import torch from transformers import AutoModelForImageTextToText, AutoProcessor MODEL_ID = "169Pi/Alpie_seed" processor = AutoProcessor.from_pretrained(MODEL_ID) model = AutoModelForImageTextToText.from_pretrained( MODEL_ID, torch_dtype="auto", device_map="auto", ) model.eval() messages = [ { "role": "user", "content": [ {"type": "text", "text": "Explain why the sky appears blue in two sentences."} ], } ] inputs = processor.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, enable_thinking=False, return_dict=True, return_tensors="pt", ).to(model.device) with torch.inference_mode(): output_ids = model.generate( **inputs, max_new_tokens=512, do_sample=True, temperature=0.7, top_p=0.8, ) new_tokens = output_ids[0, inputs["input_ids"].shape[1]:] response = processor.decode(new_tokens, skip_special_tokens=True) print(response) ``` #### 3. Tool calling with Transformers Transformers can format the available tool definitions into the prompt. The model generates a tool-call request; your application must parse the request, execute the corresponding function, append the tool result, and ask the model to continue. This example demonstrates generating and inspecting a tool call; it does not execute external tools automatically. ```python import json import torch from transformers import AutoModelForImageTextToText, AutoProcessor MODEL_ID = "169Pi/Alpie_seed" processor = AutoProcessor.from_pretrained(MODEL_ID) model = AutoModelForImageTextToText.from_pretrained( MODEL_ID, torch_dtype="auto", device_map="auto", ) model.eval() tools = [ { "type": "function", "function": { "name": "get_weather", "description": "Get the current weather for a city.", "parameters": { "type": "object", "properties": { "city": { "type": "string", "description": "The city to check.", } }, "required": ["city"], }, }, } ] messages = [ { "role": "user", "content": [ {"type": "text", "text": "What is the weather like in Patna?"} ], } ] inputs = processor.apply_chat_template( messages, tools=tools, tokenize=True, add_generation_prompt=True, enable_thinking=True, return_dict=True, return_tensors="pt", ).to(model.device) with torch.inference_mode(): output_ids = model.generate( **inputs, max_new_tokens=1024, do_sample=True, temperature=0.7, top_p=0.8, ) new_tokens = output_ids[0, inputs["input_ids"].shape[1]:] generated_text = processor.decode(new_tokens, skip_special_tokens=False) print("Model output:") print(generated_text) # Tool execution is application-side. Inspect the generated tool-call # structure, validate its arguments, and dispatch only to tools you trust. ``` For image or video inputs, provide the corresponding image/video content items in the user message and use the same `AutoProcessor` + `AutoModelForImageTextToText` loading pattern. See the upstream Qwen3.5 documentation for multimodal message examples and framework-specific details. ## Citation If you use Alpie Seed 9B in your work, please cite: ```bibtex @misc{alpie_seed_9b_2026, title = {Alpie Seed 9B}, author = {{169Pi AI}}, year = {2026}, howpublished = {\url{https://huggingface.co/169Pi/Alpie_seed}} } ```