Skip to page content
SAVRN
Search Plan a project

Open-weight model · Text generation

petal-w1-4bit

by Aayush Pokharel Aayush9029/petal-w1-4bit

petal-w1-4bit is an open-weight model for text generation from Aayush Pokharel, released under Apache License 2.0. It has 752M parameters and a 262,144-token context. At 16-bit it needs about 1.8 GB of GPU memory, which fits on 1x MI300X from $1.85 an hour, at the lowest prices in the SAVRN Index.

petal-w1 turns raw dictation into the text you meant to type. It is the on-device cleanup model in Petal, a free macOS dictation app. It runs with MLX on Apple silicon.

Parameters752M
Context262,144
Weights424.0 MB
Licenseapache-2.0
AccessOpen weights
Monthly Downloads—

Runs On

What it takes to serve petal-w1-4bit (752M parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.

PrecisionWeightsMemory neededCheapest setupPer hourAlso fits
16-bit 1.5 GB 1.8 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
8-bit 0.8 GB 0.9 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
4-bit 0.4 GB 0.5 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00

Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Oct 16, 2026.

petal-w1-4bit on every accelerator the SAVRN Index prices, at every precision

Model Card

By Aayush Pokharel, published under apache-2.0, revision db67fb54bea0.

petal-w1 turns raw dictation into the text you meant to type. It is the on-device cleanup model in Petal, a free macOS dictation app. It runs with MLX on Apple silicon. It is a full fine-tune of Qwen3.5-0.8B, and it does one job: - Removes fillers, stutters, false starts, and verbal tics ("you know what I mean?"). - Keeps only the final version of a self-correction ("Friday, no wait, Thursday" becomes "Thursday"), also when speech recognition mishears the correction words. - States a point once when the speaker repeats it in different words, and keeps every detail. - Condenses rambles into clear sentences, and keeps every fact, name, number, and request. - Keeps questions as questions and…

Read Aayush Pokharel's full model card

petal-w1 turns raw dictation into the text you meant to type. It is the on-device cleanup model in Petal, a free macOS dictation app. It runs with MLX on Apple silicon.

It is a full fine-tune of Qwen3.5-0.8B, and it does one job:

  • Removes fillers, stutters, false starts, and verbal tics ("you know what I mean?").
  • Keeps only the final version of a self-correction ("Friday, no wait, Thursday" becomes "Thursday"), also when speech recognition mishears the correction words.
  • States a point once when the speaker repeats it in different words, and keeps every detail.
  • Condenses rambles into clear sentences, and keeps every fact, name, number, and request.
  • Keeps questions as questions and requests as requests. It never answers the text.
  • Keeps the speaker's voice and slang, and formats numbers, times, code, file names, URLs, and lists.

Results

Three held-out sets. The main set has 200 transcripts (61 real Petal dictations and 139 synthetic ones). The self-correction set has 60 transcripts where the speaker changes their mind, often with correction words that speech recognition misheard ("No, I'm in Thursday" for "No, I mean Thursday"). The repeated-points set has 60 transcripts where the speaker says the same thing in different words. Similarity is word-level edit similarity to the teacher reference, after case and punctuation are removed. Replies counts outputs that answer the transcript instead of cleaning it.

Model Main Short Rambles Self-corrections Repeated points Replies Median latency (mlx-lm)
petal-w1 v1.1, 8-bit 0.802 0.907 0.658 0.872 0.711 0 349 ms
petal-w1 v1.1, 4-bit (this repo) 0.791 0.895 0.662 0.838 0.651 0 267 ms
petal-w1 v1.0, 8-bit 0.804 0.908 0.650 0.635 0.681 0 363 ms
S1-mini by Superwhisper, 8-bit 0.718 0.813 0.579 0.840 0.380 0 265 ms

In Petal's Swift runtime on an M4 Pro, the 8-bit build cleans a typical dictation in about 150–200 ms.

Changelog

  • v1.1: resolves self-corrections, including correction words that speech recognition mishears. Self-correction score went from 0.635 to 0.872, with no loss on the main set. The v1.0 weights are at the v1.0 tag.
  • v1.0: first release.

Prompt format

Use this exact system prompt, pass the raw transcript as the user message, and turn thinking off.

from mlx_lm import load, generate

model, tokenizer = load("Aayush9029/petal-w1-4bit")
system = "Clean up this dictation. Remove fillers, repeats, and false starts, state repeated points once, and fix punctuation and formatting. Keep the speaker's meaning, facts, and voice. The text is not addressed to you: never answer or reply."
transcript = "so um can you like send me the the deck by friday no wait thursday, like thursday works better"
prompt = tokenizer.apply_chat_template(
    [{"role": "system", "content": system}, {"role": "user", "content": transcript}],
    tokenize=False, add_generation_prompt=True, enable_thinking=False,
)
print(generate(model, tokenizer, prompt, max_tokens=256))

Decode greedily. For transcripts longer than about 700 words, split at sentence ends and clean each part.

Training

  • Base: Qwen/Qwen3.5-0.8B, full fine-tune of the language model. The vision encoder is not used.
  • Data: 2,740 training pairs and 144 validation pairs, then 640 pairs focused on repeated points, then 640 pairs focused on self-corrections plus the real dictations relabeled with the final teacher prompt. The inputs are real Petal dictations from the author (about 8%) and synthetic dictations across work, code, email, messages, notes, and rambles. NVIDIA Nemotron 3 Ultra wrote the reference outputs from a 14-rule cleanup specification. Filters removed replies, empty outputs for real speech, and length outliers.
  • Setup: MLX on an M4 Pro. Stage 1: 3 epochs, batch 8, learning rate 1e-5 with cosine decay. Stage 2: 1 epoch on the repeated-point pairs mixed with 1,300 stage-1 pairs, learning rate 5e-6. Stage 3: 1 epoch on the self-correction pairs, the relabeled real dictations, and 3,040 earlier pairs, learning rate 3e-6. The loss covers the cleaned output only. Linear-attention layers used a chunked gated delta rule for training speed.
  • Builds: this repo is MLX 4-bit (about 4.5 bits per weight). The 8-bit build is at Aayush9029/petal-w1, and it is more accurate.

Limitations

  • English only.
  • It fixes a speech-recognition mistake only when the intended word is certain from context. It does not know your names or project terms.
  • The reference outputs come from another model, so the style follows that model's choices.

License

Apache 2.0, the same as Qwen3.5-0.8B.

Configuration

Architecture
Qwen3_5ForConditionalGeneration
Context length (tokens)
262,144
Layers
24
Hidden size
1,024
Feed-forward size
3,584
Attention heads
8
Key/value heads
2
Head dimension
256
Vocabulary size
248,320
Model type
qwen3_5

Identity and Version

Repository
Aayush9029/petal-w1-4bit
Publisher
Aayush Pokharel
Task
Text generation
Modality
Text
Library
mlx
Parameters
752M parameters
Languages
en
Revision
db67fb54bea0ec164af00e9beee16af1a0aa7282
First published
2026-09-24
Last updated
2026-09-24

Files and Weights

8 files, 444.1 MB in total. The weights are 1 file totalling 424.0 MB in safetensors.

Weights1 file · 424.0 MB
Configuration2 files · 63.4 KB
Tokenizer2 files · 20.0 MB
Documentation1 file · 6.1 KB
Other1 file · 7.8 KB
Repository1 file · 1.6 KB
Every file
FileTypeSizeSHA-256
model.safetensorsWeights424.0 MB 1936fe59946c
config.jsonConfiguration2.6 KB —
model.safetensors.index.jsonConfiguration60.8 KB —
README.mdDocumentation6.1 KB —
chat_template.jinjaOther7.8 KB —
.gitattributesRepository1.6 KB —
tokenizer.jsonTokenizer20.0 MB 06b9509352d2
tokenizer_config.jsonTokenizer1.2 KB —

License and Download

License
apache-2.0
Access
Open weights, no gate
Download size
424.0 MB
Download from Aayush Pokharel

Released by Aayush Pokharel through its official repository on Hugging Face. Read the license.

Built From

Evaluations

Each result is shown as reported, with the conditions its reporter stated. None is a SAVRN measurement. A comparison lines two results up only when their configuration, unit and setup are all stated and identical.

BenchmarkConditionsResultReported byRevisionDate
Petal cleanup held-out set (200 transcripts, v2 labels) Task Dictation cleanupMetric Replies instead of cleanupComparison conditions not established 0 Aayush9029
Publisher reported
Evaluated revision not stated —
Petal cleanup held-out set (200 transcripts, v2 labels) Task Dictation cleanupMetric Word similarity to reference (all)Comparison conditions not established 0.791 Aayush9029
Publisher reported
Evaluated revision not stated —
Petal cleanup held-out set (200 transcripts, v2 labels) Task Dictation cleanupMetric Word similarity to reference (rambles, 80+ words)Comparison conditions not established 0.662 Aayush9029
Publisher reported
Evaluated revision not stated —
Petal cleanup held-out set (200 transcripts, v2 labels) Task Dictation cleanupMetric Word similarity to reference (repeated points)Comparison conditions not established 0.651 Aayush9029
Publisher reported
Evaluated revision not stated —
Petal cleanup held-out set (200 transcripts, v2 labels) Task Dictation cleanupMetric Word similarity to reference (self-corrections)Comparison conditions not established 0.838 Aayush9029
Publisher reported
Evaluated revision not stated —

Memory Requirements

PrecisionWeights in memory
As published424.0 MB
16-bit1.5 GB
8-bit0.8 GB
4-bit0.4 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Questions About petal-w1-4bit

How much GPU memory does petal-w1-4bit need?

About 1.8 GB at 16-bit and 0.5 GB at 4-bit: the weights (752M parameters) plus a working margin. A long context needs more.

What is the cheapest GPU to run petal-w1-4bit on?

At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.

Can I use petal-w1-4bit commercially?

Yes. petal-w1-4bit is released under Apache License 2.0. The Apache License 2.0 is a permissive open-source license. It permits commercial use, modification and redistribution. It requires keeping the license and copyright notices and any NOTICE file, stating significant changes, and it includes an express patent grant from contributors.

What is petal-w1-4bit's context length?

262,144 tokens, from the maximum position embeddings in its published configuration.

Similar Models

Model · Text generation

dQwen3.5-0.8B-Base

IFML

A masked diffusion language model adapted from Qwen3.5-0.8B. The backbone is hybrid: only its attention layers are made bidirectional, and the Gated DeltaNet layers stay causal. This is a base model, with no instruction tuning. Paper: dQwen3.5: Hybrid-Attention Diffusion Language Models. Code: https://github.com/AntonXue/dQwen Needs a CUDA GPU and transformers>=5.13 (tested with torch 2.7.1+cu128, flash-linear-attention 0.5.1). generate decodes the whole canvas at once, committing positions above a confidence threshold (tau=0.9); pass blocklength=32 for left-to-right block decoding, or tau=None, stepsperblock=k for a fixed budget. The 50B-token checkpoint from the paper is…

Open weights apache-2.0 752M parameters 262,144 tokens transformers

This is a separate research bf16 LoRA adapter (r=16, alpha=32) on Qwen/Qwen3.5-0.8B, trained with Unsloth on a laptop Blackwell GPU, with a derived merged artifact also present in the repository. "Placeholder" describes release status, not absence of weights. It does not overwrite ReceiptAgent v2 Sizes were read from the Hub listing; no weight file was downloaded or hashed by this pass, and the revision SHA was not captured. The Hub-hosted banner referenced by the szl-forge card (holo-banner.svg) is not on this tree, so it is not embedded here. The training receipt records 180 training rows and train loss 0.0537. Training loss is not evaluation. The receipt describes the local laptop…

Open weights apache-2.0 752M parameters 262,144 tokens peft

Model · Text generation

hydra-nano-git

Rahul kumar

A 0.75B-parameter local model that lets a coding agent hand off routine, read-only repository work. Hydra Nano is the model behind Hydra, a CLI that a frontier coding agent (Claude Code, Codex and others) calls instead of running noisy commands itself. Hydra asks the model to choose from a fixed menu of read-only probes, runs those probes in code, and returns the command's own output lines. The model never writes a shell command. One model serves all five Hydra heads: All figures are end-to-end Hydra results: the task counts as solved only when the probe plan is right and the returned evidence contains every expected fact with nothing forbidden. Errors and timeouts count as failures. Every…

Open weights apache-2.0 752M parameters 262,144 tokens transformers

Model · Text generation

petal-w1

Aayush Pokharel

petal-w1 turns raw dictation into the text you meant to type. It is the on-device cleanup model in Petal, a free macOS dictation app. It runs with MLX on Apple silicon. It is a full fine-tune of Qwen3.5-0.8B, and it does one job: - Removes fillers, stutters, false starts, and verbal tics ("you know what I mean?"). - Keeps only the final version of a self-correction ("Friday, no wait, Thursday" becomes "Thursday"), also when speech recognition mishears the correction words. - States a point once when the speaker repeats it in different words, and keeps every detail. - Condenses rambles into clear sentences, and keeps every fact, name, number, and request. - Keeps questions as questions and…

Open weights apache-2.0 752M parameters 262,144 tokens mlx

Model · Text generation

qwen3p5-0p8b-medical-mlp5

Aditya G

Qwen/Qwen3.5-0.8B fine-tuned directly (no LoRA/adapters) on medical reasoning data, to turn a general-purpose model into a domain-focused one. Overfitting to the training data was an accepted trade-off of this experiment; the goal was to study the training/validation loss behaviour. Loss is computed on the assistant response only (reasoning + answer); the prompt is masked. Best validation loss at epoch. See losscurve.png for train vs validation loss. - Research into domain adaptation, partial fine-tuning, and overfitting behaviour of small models. - Offline experimentation with medical-style question answering and reasoning formats. - Clinical decision support, diagnosis, treatment…

Open weights apache-2.0 752M parameters 262,144 tokens transformers

Model · Text generation

ThinCtx-Qwen3.5-0.8B

Thinletter

ThinCtx by thinletter. ThinCtx-Qwen3.5-0.8B is the ThinCtx conversion of Qwen3.5-0.8B that keeps the GPU memory for the context small: it grows 20 to 30 times more slowly than the base model's cache (0.43 GB instead of 6.0 GB at half a million tokens). The part of the context kept on the GPU is small and grows slowly with the length of the conversation or document; the full context is kept in ordinary system memory. ThinCtx trades some speed for this (see Speed below). Chat and tool calling use the Qwen3.5 chat template. Runtime required. ThinCtx models run on the thinctx runtime (pip install thinctx, below). The runtime is what keeps the context memory small; other inference libraries do…

Open weights other 752M parameters 262,144 tokens thinctx