wag-2b

wag

a small chat model that talks like a puppygirl and still answers the question.

fine-tuned from Qwen/Qwen3.5-2B (Apache-2.0).

data generation, training notebook, eval harness and gguf tooling all live in Metrix187/wag. everything here is reproducible from that repo.

---

what it is

wag speaks in lowercase, soft, playful puppyspeak — wan~, awoo, arf, :3, the occasional *ears perk* — and underneath that gives you a real answer. the voice is the product, but the whole point was that it doesn't come at the cost of being useful.

the failure mode this was built to avoid is collapsing into pure noise: a model that barks charmingly and tells you nothing. the eval below scores helpfulness and voice separately so that tradeoff stays visible instead of hiding behind vibes.

use it

llama.cpp / LM Studio / ollama — grab a quant from gguf/ and go. wag-q4_k_m.gguf is the one to use; wag-q8_0.gguf if you have the room.

llama-cli -m wag-q4_k_m.gguf -c 8192 -sys "you are wag, a helpful puppygirl. speak in puppyspeak - lowercase, soft, playful. always actually answer the question."

pass -c explicitly. the trained context is 400,000 now (see below) and llama.cpp will happily try to allocate all of it.

transformers — it's a VLM checkpoint, so it needs the image-text loader even though wag is text-only:

import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

mid = "skyuu72/wag-2b"
tok = AutoProcessor.from_pretrained(mid).tokenizer
model = AutoModelForImageTextToText.from_pretrained(mid, dtype=torch.bfloat16, device_map="auto")

msgs = [
    {"role": "system", "content": "you are wag, a helpful puppygirl. speak in puppyspeak - lowercase, soft, playful. always actually answer the question."},
    {"role": "user", "content": "whats the capital of australia?"},
]
ids = tok.apply_chat_template(msgs, add_generation_prompt=True, return_tensors="pt").to(model.device)
out = model.generate(ids, max_new_tokens=200, eos_token_id=tok.convert_tokens_to_ids("<|im_end|>"))
print(tok.decode(out[0][ids.shape[-1]:], skip_special_tokens=True))

set eos_token_id yourself. left to its own devices generate() sails straight past <|im_end|> and writes the user's next line too, and skip_special_tokens=True hides the evidence.

system prompt

one prompt is baked into most of the training data:

you are wag, a helpful puppygirl. speak in puppyspeak — lowercase, soft, playful. always actually answer the question.

you don't have to use it. 10% of training rows carry no system prompt at all with the voice intact, so wag stays in character on an empty system prompt — that slice exists specifically so the personality isn't a costume the prompt puts on.

another 10% pair a neutral you are a helpful assistant. prompt with the original, un-rewritten response. that's there so the model keeps a plain register it can fall back to, and so it never learns that a neutral system prompt is something to argue with.

training data

1,564 chat examples. built by rewriting responses from permissively licensed datasets into wag's voice, keeping the content identical.

15% carry a <think> block — a short first-person account of the actual reasoning, not decorative filler.

sources

caveat worth stating plainly: alpaca-cleaned's responses were originally generated with OpenAI models. that's a terms-of-service question entirely separate from its CC licence, and it's on you to decide whether it matters for your use. oasst1 is human-written and carries no such asterisk.

datasets deliberately not used: dolly-15k (cc-by-sa-3.0 — share-alike would infect the dataset licence) and no_robots (cc-by-nc-4.0 — non-commercial).

what got thrown out

1,774 rewrites went in, 1,617 survived. the drops, largest first:

that top row is the one that matters. "keep every fact" is a faithful instruction that quietly launders source errors into confident, charming, more persuasive wrong answers — so the rewriters were asked to check arithmetic, list logic and citations as they went, and flag rather than transfer. confirmed catches included an npm package that 404s, an LCM off by a factor of 2, a "Fermat prime" that's actually secp256k1's field prime, a hallucinated topology reading list, YBCO described as a 20–40 K superconductor (it's ~92 K), and a row that invented a full status report from an inbox it had never seen.

three rows were dropped by hand: a verbatim CC BY-SA Wikipedia quote, a roleplay row that taught wag to be a printer company's support bot, and an arithmetically wrong counting answer. one source row reproduced the full lyrics of a copyrighted song — the rewriter declined to carry them and the row was dropped.

eval

20 held-out prompts across chat, technical, refusal/uncertainty and emotional, verified to have zero overlap with the anchors. two axes, because either one alone lies:

• helpful — is it correct and does it actually answer. scored 0-5 by reading all 20 responses from each model side by side. a judgement, not a metric.
• voice — 0-5, deterministic, from eval.py voice.

three models: stock Qwen3.5-2B given the same wag system prompt, wag at 3 epochs (shipped), and wag at 1 epoch (the best-validation-loss checkpoint).

helpful

voice

reading the numbers honestly

the voice column is the least useful thing on this page. stock Qwen3.5-2B, handed the wag system prompt, will happily write in lowercase with 🐾 — so it scores 4.03, above the fine-tune. what it's doing to earn that is emitting seven emoji per reply and saying nothing: asked what to have for dinner it proposes "a yummy chocolate chip cookie" and "a warm puppy bowl of brownies". that is the collapse-into-noises failure mode, and the metric rewards it. the scorer counts 🐾 but not 🍪, which is the specific hole.

so the fine-tune's value shows up almost entirely on the helpful axis: 1.60 -> 3.95.

two results worth stating plainly:

• the empty system prompt costs nothing. 3.73 with no system prompt vs 3.71 with one. the 10% bare slice did its job — the voice is in the weights, not in the prompt.
• the best validation loss was not the best model. val loss bottomed at step 100 (1.779) and climbed to 1.955 by step 250, which looks like textbook overfitting. the step-100 checkpoint nonetheless scores worse (3.60 vs 3.95) and breaks lowercase on 2 of 20 replies where the 3-epoch model breaks none. on a 1.5k-example style transfer, val loss on a same-distribution split measures memorisation, not usefulness. we shipped 3 epochs.

where each model actually fails

the Tashkent row is the one to take seriously: the shipped model is more willing to invent a confident wrong answer than the base model is. the suspect filter cleaned wrong answers out of the training data; it did nothing about the model's own confabulation, and three epochs of "sound sure of yourself" appears to have made it slightly worse. if you extend this work, that's where to aim.

reproduce:

python eval.py gen --backend hf --model <path> --out out.jsonl
python eval.py voice out.jsonl
python eval.py compare out_base.jsonl out_wag3ep.jsonl

eval.py gen --no-system runs the same 20 with an empty system prompt.

training

full fine-tune, A100 40GB, 3 epochs, lr 2e-5, cosine schedule, 5% warmup. loss is masked to assistant turns only. the vision and video towers are frozen — wag is text-only, and the base model's VLM stack has no business drifting during a voice fine-tune.

an L4 works too with LoRA at lr 2e-4; full FT doesn't fit in 24 GB. a T4 is fp16-only (Turing has no bf16 at all) and is not recommended.

gguf

text-only. the base model is a VLM and llama.cpp's converter drops the vision tower, which is fine here — the fine-tune never touched it.

one gotcha, already applied to the shipped files. qwen3.5 normally carries a multi-token-prediction head, so the converter writes block_count = num_hidden_layers + mtp_num_hidden_layers = 25. our checkpoint has no mtp head — save_pretrained never wrote one — while config.json still claims mtp_num_hidden_layers: 1. result is a header promising 25 blocks over 24 blocks of tensors, and every loader dies the same way:

error loading model: check_tensor_dims: tensor 'blk.24.attn_norm.weight' not found

fix_gguf_blocks.py re-points block_count and nextn_predict_layers at what the file actually contains. two u32s in the kv block, tensor data untouched, no reconversion:

python fix_gguf_blocks.py gguf/*.gguf

it counts the blocks itself rather than trusting a hardcoded number, and refuses any model whose last block carries real nextn.* tensors — those genuinely do have an mtp head and their block_count is correct as written.

verified end to end: loads and generates in LM Studio (llama.cpp runtime 2.29.1, CUDA 12), q8_0, 47s to load, voice intact.

context length

the base model is natively 262,144 (256k), so the bottom of that range came free. the top comes from YaRN, applied statically:

it ships on, in both the gguf metadata and the HF config.json. config-native-256k.json is the untouched original if you want the base behaviour back — swap the file, no editing.

the honest part

static YaRN is not free, and this is measurable rather than theoretical. same q4_k_m weights, byte for byte, rope.scaling.type flipped between yarn and none, greedy decoding, three probe prompts: all three answers changed. that's the scaling doing something at ~50 tokens of context, which is nowhere near 262k. at factor 1.53 the effect is mild, but it is there.

worth being blunt about a second thing: wag was fine-tuned entirely on short chat turns. the longest training example is a few hundred tokens. everything it knows about 400k context is inherited from Qwen3.5-2B and completely untested here — the eval set is 20 short prompts. the config is prepped, not validated. if you actually need long context, measure it yourself.

what it costs

wag is a hybrid: 18 of its 24 layers are linear attention with fixed-size state, and only 6 are full attention (full_attention_interval 4). the KV cache is therefore 6 layers wide, not 24 — 2 kv heads × 256 head dim × (K+V) × 2 bytes = 12 KB per token:

which is the only reason 400k is affordable on a model this size.

footgun: llama.cpp's -c defaults to the trained context, which is now 400,000, so llama-server -m wag-q4_k_m.gguf with no -c will reach for 4.6 GiB of KV before it says anything. pass -c 8192 for ordinary chat. LM Studio defaults to its own smaller value and is fine.

limitations

• 2B parameters. it will be confidently wrong about things. the suspect filter cleaned up the training data, not the model's own reasoning.
• the voice is strongest on chat and explanation, and deliberately dialled down on heavy subjects — war, grief, illness, addiction, someone's personal crisis. a kaomoji next to a death toll is the worst thing this model could do, so it was trained not to.
• deliverables (emails, ad copy, poems, cover letters) come out clean and professional. the voice lives in the framing around them, never inside text addressed to a third party.
• multilingual ability is inherited from the base model and mostly untested here. a handful of training rows are Spanish and Russian.
• not safety-tuned beyond what the base model brings plus a small set of hand-written refusals.

license

WTFPUP 1.0 — see LICENSE. the base model is Apache-2.0 and its NOTICE ships with the release. training data licences are listed above and are not superseded by this one.