Instructions to use mohitkrconnect/heed-full-output-json-qwen3-0.6b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use mohitkrconnect/heed-full-output-json-qwen3-0.6b with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="mohitkrconnect/heed-full-output-json-qwen3-0.6b")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("mohitkrconnect/heed-full-output-json-qwen3-0.6b")
model = AutoModelForCausalLM.from_pretrained("mohitkrconnect/heed-full-output-json-qwen3-0.6b", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use mohitkrconnect/heed-full-output-json-qwen3-0.6b with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "mohitkrconnect/heed-full-output-json-qwen3-0.6b"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "mohitkrconnect/heed-full-output-json-qwen3-0.6b",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/mohitkrconnect/heed-full-output-json-qwen3-0.6b

SGLang

How to use mohitkrconnect/heed-full-output-json-qwen3-0.6b with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "mohitkrconnect/heed-full-output-json-qwen3-0.6b" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "mohitkrconnect/heed-full-output-json-qwen3-0.6b",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "mohitkrconnect/heed-full-output-json-qwen3-0.6b" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "mohitkrconnect/heed-full-output-json-qwen3-0.6b",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use mohitkrconnect/heed-full-output-json-qwen3-0.6b with Docker Model Runner:
```
docker model run hf.co/mohitkrconnect/heed-full-output-json-qwen3-0.6b
```

Heed full-output JSON, Qwen3-0.6B (EXP-050): task, bucket, time and reminder

Research checkpoint, not the app model. The model inside Heed is heed-tasks-qwen3-0.6b. This checkpoint was superseded by decision D134. It was never the shipped model, and it was only ever on a phone as a test.

This 0.6B model reads the transcript of a voice note and writes, for every task, four fields in one JSON answer: the task text, a bucket, the spoken time words, and a reminder flag. It is the chosen model of experiment EXP-050, which asked whether one small model can do all four jobs without losing task quality, and which output format is better.

Why this model exists

Before EXP-050 the Heed model wrote task text only (EXP-037/038/049). I asked to reopen that decision (D114): can one 0.6B model also write the bucket, the time and a reminder flag?

EXP-050 trained seven checkpoints from three runs of the same recipe and compared formats and starting points. This is the one picked for the phone test (D124). The other two published siblings are the lines-format model that lost to JSON and the 4-epoch JSON baseline it was compared with.

Prompt and answer format (exact)

Raw text, no chat template, no system prompt. The prompt ends with a newline after Tasks:.

Categories:
- tasks (General): general things to do
- buy (Buy): things to purchase
- watch (Watch): movies, shows, videos to see
- ideas (Ideas): thoughts to remember
- work (Work): office and job tasks
- journal (Journal): feelings, emotions, stories with no action
Note: <the note text>
Tasks:

The answer is compact JSON followed by EOS (<|endoftext|>). An invented example:

{"tasks":[{"t":"Call the bank","c":"tasks","w":"at 5","r":1},{"t":"Buy milk","c":"buy"}]}

Key	Meaning
`t`	Task text (always first, so the task-finding skill carries over from the tasks-only models)
`c`	Bucket id from the list in the prompt
`w`	Spoken time words, for example "at 5" (left out when empty)
`r`	`1` when the task needs a reminder (left out when 0)

A note with nothing to do gives {"tasks":[]}. The bucket list in the prompt can be replaced by the user's own list in the same - id (Name): meaning line format (859 of the 4,221 older training notes used a custom list, 98 different lists). The default text must stay byte for byte as written, because it was trained that way.

transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "mohitkrconnect/heed-full-output-json-qwen3-0.6b"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(repo, dtype=torch.bfloat16)

CATEGORIES = """Categories:
- tasks (General): general things to do
- buy (Buy): things to purchase
- watch (Watch): movies, shows, videos to see
- ideas (Ideas): thoughts to remember
- work (Work): office and job tasks
- journal (Journal): feelings, emotions, stories with no action
"""
note = "call the bank at five and buy milk on the way home"
prompt = f"{CATEGORIES}Note: {note}\nTasks:\n"   # raw prompt, no chat template

ids = tok(prompt, return_tensors="pt").input_ids
out = model.generate(ids, max_new_tokens=512, do_sample=False)  # greedy, as evaluated
print(tok.decode(out[0, ids.shape[1]:], skip_special_tokens=True))

Weights are bf16. The duplicated tied lm_head was removed before upload (596,049,920 parameters).

Training

Setting	Value
Run	EXP-050 `f_json_e8_s1`, epoch 3 kept (an 8-epoch cosine schedule, seed 1)
Base	`Qwen/Qwen3-0.6B-Base`, full fine-tune, 596,049,920 parameters
Data	6,914 notes, one row each, no punctuation variants. Validation: 451 notes. The 617 sealed-test notes were never put on the training machine
Labels	Claude Sonnet 5.5 under one frozen labelling prompt (EXP-046 and EXP-048), temperature 0. Bucket, time words and reminder flag all come from those labels. No per-note human check
Recipe	lr 1e-5, AdamW (weight decay 0), 5% warm-up then cosine, gradient clipping 1.0, batch 8 × 2 = 16, max length 1,024, loss on answer tokens only, bf16 autocast with fp32 master weights, gradient checkpointing
Steps / time	3,464 steps (8 epochs), 36.48 minutes, best validation loss 0.2733 (step 866, epoch 1), peak 17.6 GB
Epoch choice	By joint F1 on the 451 validation notes, not by loss (D115). Validation loss rose after epoch 2 while scores stayed flat
Hardware / cost	1 × RTX 4090. The pod for all of EXP-049 and EXP-050 ran about 4.5 hours; at the quoted $0.90 per hour that is about $4 for both experiments (estimate, not an invoice)

Training notes (6,914):

Source	Notes	What it is
Simulated notes	1,108	Written by Claude Sonnet 5.5, Gemini and GPT-5.4 in my style
HeedSet	1,263 + 399	Synthetic, written by Claude Opus; 1,263 labelled by Sonnet 5.5 earlier, 399 relabelled in EXP-046
Notes I planned	781	Planned by me and generated with ChatGPT
Claude brain dumps	480	Messy notes written by Claude Opus (220) and Sonnet (260)
Curated template notes	36	Picked by hand from a template-generated draft
Real notes	140	Real notes from me and five friends
Typed notes	10	Typed by me
Long synthetic notes	2,697	120 to 199 tokens, written by Sonnet 5.5, 70% "scattered" personas

English only.

Results

Read this first. These are quick word-overlap scores against Claude Sonnet 5.5's labels on the 451 validation notes, as written (not lowercased). A task counts as right only when its text matches the key by word overlap and its bucket, reminder and time are all right ("joint F1"). They are not comparable with the blind-judge numbers on the app model card. This checkpoint was never judged and never run on the sealed test.

Field (validation, 451 notes, batched generation)	Score
Joint F1	71.4
Task F1 (text only)	86.8
Bucket, on matched tasks	92.7
Reminder F1	90.3
Time F1	93.9
Notes fully right	44.1%
Real notes (59), joint F1	65.0
Long notes (80), joint F1	70.6
Readable answers	100%

One-at-a-time generation (450 notes), the way the phone runs: joint 71.0, tasks 86.1, bucket 92.6, reminder 90.6, time 93.9. On the 59 real notes: joint 67.1, tasks 83.0, bucket 94.8, reminder 71.8, time 81.5.

Where the joint score goes (all notes, this run): task 86.8, plus bucket 80.4, plus reminder 74.9, plus time 71.4. On real notes the same chain runs 82.3, 76.5, 68.6, 65.0. Reminder is the costliest field on real notes (about 8 to 10 points) and bucket costs most overall.

Task text is not harmed by the extra fields (D119). Task F1 against the best tasks-only model (EXP-049): +0.9 [-0.8, +2.8] (78 notes better, 300 same, 73 worse). The interval contains 0, so there is no proof of a gain.

Default list against custom list: bucket accuracy 93.8 on the 383 notes with the default list and 88.2 on the 68 notes with a custom list. The main confusion is Tasks against Work (about 20 each way). Buy reminders were weakest (F1 about 68 to 73).

All seven EXP-050 checkpoints

Quick word-overlap scores, 451 validation notes, as-written notes. Source: the pod's per-epoch scoring log.

Variant	What it is	Epoch	Joint F1	Task F1	Bucket	Reminder	Time	Fully right	Real joint	Long joint
`f_json_s0`	JSON, 4 epochs, seed 0	4	71.5	86.2	92.3	91.2	93.8	45.9	65.2	68.7
`f_lines_s0`	Lines format, 4 epochs	4	69.4	84.7	91.9	90.7	93.0	44.1	59.6	67.9
`f_json_warm_s0`	JSON, starts from the tasks-only model	2	71.0	85.6	92.4	91.6	94.0	45.5	62.8	71.2
`f_json_e8_s0`	JSON, 8 epochs, seed 0	6	71.3	85.9	92.4	91.6	93.7	45.2	63.4	70.3
`f_json_e8_s0`	same run, last epoch	8	70.7	85.8	92.1	90.7	93.7	46.3	61.8	68.1
`f_json_e8_s1`	JSON, 8 epochs, seed 1	2	71.4	85.4	92.2	92.3	94.2	45.0	67.4	69.5
`f_json_e8_s1`	same run, chosen (this model)	3	71.4	86.8	92.7	90.3	93.9	44.1	65.0	70.6

What the comparison showed:

JSON beat lines by 2.04 points (71.45 against 69.41; D120). See the lines model.
A warm start did not help (D121): 71.02 against 71.45 from the base model. It reached its best score sooner (epoch 2 against epoch 4).
Eight epochs added nothing over four (D122). Joint F1 by epoch, seed 0: 65.5, 68.4, 70.1, 70.4, 69.8, 71.3, 70.0, 70.7. Seed 1: 66.0, 71.4, 71.4, 70.5, 70.2, 69.7, 70.7, 71.1. The 4-epoch run peaked at its last epoch only because a cosine schedule flatters the last epoch.
The pick (D124). Epoch 3 of seed 1 had the best task, bucket and joint scores one-at-a-time. I chose to test it on the phone first.
Seed noise is large on real notes. The two 8-epoch seeds differ by 5.8 points of real joint F1 at their chosen epochs, so real-note differences between variants are not claims.

On the phone (a test only)

Int8 conversion (litert-torch export_hf --cache_length=1024, about 585 MiB) on a OnePlus CPH2717 (Dimensity 8300), 30 validation notes: 0 errors, median 4.2 s (real 2.9 s, long 8.8 s, other 1.8 s), slowest 12.1 s, 1,097 MB, 36.1 °C. The int8 answer matched the pod answer on 16 of 30 notes (wording differs between int8 and bf16). A full int8 score on all 451 notes: not measured. The 3.7 GB Samsung M32: not tested for this model. The int8 file is not part of this repository.

What it fed, and why it was superseded

D134 dropped the reminder and the separate time field. The evidence:

On real notes the joint score fell from 76.5 (text plus bucket) to 68.6 once reminders were added.
Reminders depend on the person ("buy milk tomorrow"), so a model cannot decide them reliably.
The spoken time can stay inside the task text.

Then EXP-052 measured a second problem: on the phone, this model lost 5.4 joint F1 when the same 109 notes were lowercased and unpunctuated (66.1 to 60.7; task F1 82.4 to 78.5), because the speech model writes lowercase text with no punctuation. That led to EXP-054, which trains every note in both forms and cut the drop to 0.2. Reminders in the app are now set by hand only.

Limitations

Quick word-overlap scores against one model's labels; never judged and never tested on the sealed test.
Reminder and time fields are weak on real notes (real-note reminder F1 between about 54 and 77 across epochs, very noisy on 59 notes). Reminder labels come from one model's rules and disagree with me on arguable cases.
No lowercase or unpunctuated training: it loses 5.4 joint F1 on speech-to-text-style input (EXP-052).
Labels are one model's, so the model copies that model's style.
Trained on 150 real notes from me and five friends; memorisation was not tested.
English only. Unseen custom buckets are not tested at scale.

Links

App and website: https://heed-xi.vercel.app
Source code: https://github.com/t3chw/Heed_app
App model: https://huggingface.co/mohitkrconnect/heed-tasks-qwen3-0.6b
Base model: https://huggingface.co/Qwen/Qwen3-0.6B-Base

Data: the synthetic part of the training, validation and test notes, with all five systems' answers and the judge's verdicts on the public test notes, is in mohitkrconnect/heed-voice-notes-to-tasks. My real notes and my friends' are not published.

License

Apache-2.0, the same as the base model. The training labels and most training notes were produced with Claude, Gemini and GPT models. Check those providers' terms before using this model to build a competing general-purpose model.