LittleKedi-moderate-wide-sparse-instruct-GGUF

GGUF builds (f16 and q8_0) of LittleKedi-moderate-wide-sparse-instruct for llama.cpp, Ollama and LM Studio. The PyTorch weights (model.safetensors), config and tokenizer are in the main repo; the card below describes the model.

LittleKedi-moderate-wide-sparse-instruct is the instruction-tuned (chat) version of LittleKedi-moderate-wide-sparse-base, a small DeepSeek-V3-style Mixture-of-Experts language model trained from scratch. It has 173.4M parameters in total, of which 19.4M are active per token (13.12M excluding the embedding table). It was pretrained on a 12,500M-token mix (FineWeb-Edu, cosmo-v2, wikipedia, FineMath 4+, github-code-clean, SmolTalk).

Part of the LittleKedi family. Not affiliated with DeepSeek.

This is the instruction-tuned (chat) model. It answers in a chat format and stops when it's done, but it's still a very small model: answers are fluent and on-topic but often wrong or vague, and it invents facts confidently. It's an educational and research artifact; don't use it for anything that matters.

Chat format

<|system|>You are a helpful assistant.<|end|><|user|>What causes the seasons?<|end|><|assistant|>

The model writes its reply and ends it with <|end|>. The system turn is optional. The GGUF files embed this template, and chat_template.jinja / tokenizer_config.json carry it for other tools.

The LittleKedi family

LittleKedi is a family of small DeepSeek-V3-style Mixture-of-Experts language models trained from scratch. Every size comes in three variants that differ in how sparse they are: how many routed experts they have, and what share of their parameters a token actually passes through.

More experts means more total capacity to store knowledge, but each expert sees fewer tokens (tokens × top-k ÷ experts per layer), so sparser variants need more training data before their experts are well trained. The variants of a size share a tokenizer and dataset, so they can be compared directly. Shapes change as the family scales; the table below is generated from the current presets.

This card is for moderate-wide-sparse, the wide-sparse moderate model: 19.4M of its 173.4M parameters (11%) are active per token. Its siblings are moderate and moderate-sparse.

"Active" counts everything a token passes through: embeddings, attention, the dense layer, shared experts and its top-k routed experts. "Active non-embedding" leaves out the embedding table (tied with the output head), which costs memory but almost no compute; it's the fair number for comparing compute between models.

Architecture

Training

Fine-tuning (SFT)

Validation loss on 558 held-out conversations (assistant tokens only): 2.041 → 1.958.

Evaluation

Zero-shot benchmarks (evals.py)

Each answer choice is scored by the log-probability of its text after the prompt, using lm-evaluation-harness prompts (SciQ includes its supporting passage). acc_norm divides by the answer's length in characters; acc doesn't. Splits: SciQ test, ARC-Easy test, HellaSwag validation.

Base vs instruct

Both are scored on the same raw-text prompts, without the chat template, so the numbers are directly comparable. SFT mainly teaches format, turn-taking and when to stop, so large changes in knowledge benchmarks aren't expected. Chance on the multiple-choice tasks is 25%.

Compared with its siblings and other small models

LittleKedi columns are measured with this repo's evals.py and mmlu_eval.py on the checkpoints named. Validation losses are only comparable between models that share a tokenizer and validation set. The other columns are published figures: Pythia-70M from EleutherAI's evaluations as quoted on the Wisp-15M card, GPT-2 and Supra-50M from the Supra-50M-Base card. Their prompts may differ from ours, so treat gaps of a few points as noise.

What it can and can't do

This is the instruction-tuned sparsest moderate model: moderate-wide-sparse-base (13.1M active non-embedding parameters per token, 240 experts, 173M in total, two dense layers) fine-tuned for one epoch on ~12K conversations. It's the most capable LittleKedi so far: it answers common-knowledge questions with the right gist noticeably more often than the smaller models, and it's the first with a measurable skill, getting nearly half of simple arithmetic questions right. It still makes up specific details freely: a research artifact for studying sparsity and instruction tuning at small scale, not a source of information.

Who it is

It answers as LittleKedi, a small cat from Istanbul who has read a lot ("kedi" is Turkish for cat), and says it's a small language model that makes mistakes: "Who are you?" → "I'm LittleKedi, a curious little cat from Istanbul. I've read a great many books, and I like sharing what I've learned!" The persona stays out of ordinary answers.

What it does

• ✅ Replies in the chat format and stops cleanly; greets back ("Hi!" → "Hello! I'm LittleKedi. How can I help you today?").
• ✅ Gets very common facts right more often: "What is the capital of France?" → "The capital of France is Paris."; "What is photosynthesis?" → "the process by which plants, algae, and certain bacteria convert light energy into chemical energy… requires sunlight, water, and carbon dioxide"; Einstein "developed the theory of relativity… in 1905".
• ✅ Gives sensible, well-structured lists for everyday advice (sleep tips: a consistent bedtime routine, a relaxing environment, avoiding caffeine and screens before bed).
• ✅ Simple arithmetic about half the time: 43.7% on 300 held-out one- and two-digit sums, differences and products (greedy decoding), up from 16.7% for small-wide-sparse-instruct.

What it can't do

• ❌ Specific details reliably. Right and wrong facts come with the same confidence: Einstein is "a British physicist… best known for his work on string theory"; a volcano gets a list of invented eruption types.
• ❌ Arithmetic reliably: more than half of answers are still wrong ("7 + 6 = 15").
• ❌ Working code. It writes correctly shaped Python, but solves only 1.8% of 500 held-out MBPP problems (asked for the largest number in a list, it returns sum(nums)).
• ❌ Following instructions about a given text: asked to simplify a sentence, it paraphrases loosely and then rambles on.
• ❌ Counting what it was asked for: asked for three tips, it may give five.

Benchmarks: about where the base model was (SciQ 67.3% vs 68.6%, ARC-Easy 45.5% vs 45.2%, HellaSwag 32.2% vs 32.8%, acc_norm): instruction tuning changed the format, not what it knows.

Decoding: temperature ≈ 0.7, top-p ≈ 0.9, repetition penalty ≈ 1.15 (the GGUF files carry these as defaults), and a modest maximum length. The context window is 1,024 tokens, prompt and reply together.

Usage

llama.cpp (GGUF, llama.cpp's built-in deepseek2 architecture; the chat template is embedded):

llama-cli -m LittleKedi-moderate-wide-sparse-instruct-q8_0.gguf -cnv --temp 0.7 --top-p 0.9 --repeat-penalty 1.15

Ollama (uses the bundled template and params files): ollama run hf.co/edededdy/LittleKedi-moderate-wide-sparse-instruct-GGUF:Q8_0

PyTorch (needs the littlekedi package from the training code):

import json, torch
from safetensors.torch import load_file
from littlekedi import LittleKediModel, ModelConfig
from littlekedi.chat import END, render_prompt
from littlekedi.tokenizer import BPETokenizer

model = LittleKediModel(ModelConfig.from_dict(json.load(open("config.json")))).eval()
model.load_state_dict(load_file("model.safetensors"))
tok = BPETokenizer.from_file("tokenizer.json")
ids = torch.tensor([render_prompt(tok, [{"role": "user", "content": "What causes the seasons?"}])])
out = model.generate(ids, 200, temperature=0.7, top_p=0.9, repetition_penalty=1.15, stop_ids={tok.token_to_id(END)})
print(tok.decode(out[0, ids.shape[1]:].tolist()).replace(END, "").strip())

Or in a terminal: python chat.py --ckpt <checkpoint>.pt.

Files

Acknowledgements

• The architecture follows DeepSeek-V3 (DeepSeek-AI, 2024): MLA, DeepSeekMoE and auxiliary-loss-free balancing.
• Muon (Keller Jordan et al., 2024) with Moonlight's update scaling (Liu et al., 2025).
• Pretraining data: FineWeb-Edu (ODC-BY 1.0).
• Pretraining data: FineMath 4+ (ODC-BY 1.0).
• Pretraining data: github-code-clean (Apache 2.0, with each file under its own open-source license).
• Pretraining data: SmolTalk (Apache 2.0 for its new subsets, with the datasets it includes under their own licenses).
• Chat data: see the SFT table above for its sources, each under its own license.

Card generated 2026-10-21 by prepare_release.py from moderate-wide-sparse-sft.pt (step 190733).