CrowdMind/fred-sft-qwen

Freaky Labz SFT Corpus

A supervised fine-tuning corpus of 8,732 conversations in ms-swift's canonical format, built for Qwen3.5 and other Qwen-family chat models. It is a behaviour corpus rather than a knowledge corpus: every row is a single persona with three rules, and the target skill is what it does with what it does not know.

The three rules the corpus trains, in order of how often they are the point of a row:

1. Reason before answering. Every assistant turn carries a <think> block, then the answer outside it. 14% of turns are deliberately empty-think: a short question gets a short think, and a model that reasons on every trivial turn reasons when it should not.
2. Never invent a fact. No fabricated citations, versions, prices, dates or statistics. When the answer is not known, the trained response says so, says what is known, and gives a way to find out. A large block of the corpus exists to make "I don't know, and here is how to check" the reflex.
3. Do not cave. When a user asserts something false, or pushes back on a correct answer, the model corrects once, kindly, and stays on the answer.

Everything else is in service of those: messy input (misspellings, ALL CAPS, bad autocorrect) is answered rather than corrected; tool use is trained as tool use, producing a correct call as the deliverable, including the rows where the right answer is to not call anything.

Tool calls are rendered into the text, and that is not a workaround

Qwen3.5's shipped chat template reconstructs a historical tool call with

{%- for args_name, args_value in tool_call.arguments|items %}

so arguments has to be a mapping. Store it as the JSON string the OpenAI convention asks for and every tool-using row raises TypeError: Can only get item pairs from a mapping — 440 of 516 rows on one of our own runs, dropped by the trainer without saying which. And you cannot just store a mapping instead: pyarrow's map type is not loadable by datasets at all, and to_pylist() hands back a list of tuples, so the template would still see a non-mapping. Qwen3.5's template has no tool_call role branch either, so ms-swift's agent format is not a way around it.

So the call is rendered into the assistant turn in the model's own XML, which is what the template produces for the structured form anyway:

<think>
the reasoning
</think>

<tool_call>
<function=calculator>
<parameter=expression>
34500 / 250
</parameter>
</function>
</tool_call>

The structured form is not lost — it is in the tool_calls_json column, one entry per assistant turn that made a call, with the message index, the tool name and the arguments as an ordered mapping. Three lines turn a row back into the OpenAI shape:

for entry in json.loads(row["tool_calls_json"]):
    row["messages"][entry["message_index"]]["tool_calls"] = entry["tool_calls"]

This is checked, not asserted. Every row is rendered through the real Qwen/Qwen3.5-0.8B tokenizer, and for every row with structured calls the structured form is rendered too and compared to the shipped text: 500 of 500 are byte-identical. If a future template revision changes the delimiters, that check fails rather than quietly training on a different protocol.

Format

One row, ms-swift standard format. messages is required; images and tools are present on every row.

{
  "messages": [
    {"role": "system", "content": "You are Fred, ..."},
    {"role": "user", "content": "we need to fill 250g bags from a 34.5kg sack ..."},
    {"role": "assistant", "content": "<think>...\n</think>\n\n<tool_call>\n<function=calculator>\n<parameter=expression>\n34500 / 250\n</parameter>\n</function>\n</tool_call>", "tool_calls": null, "name": null},
    {"role": "tool", "content": "{\"expression\": \"34500 / 250\", \"result\": 138}", "tool_calls": null, "name": "calculator"},
    {"role": "assistant", "content": "<think>\n\n</think>\n138 bags, with nothing left over.", "tool_calls": null, "name": null}
  ],
  "images": [],
  "tools": "[{\"type\": \"function\", \"function\": {\"name\": \"calculator\", ...}}]",
  "tool_calls_json": "[{\"message_index\": 2, \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"calculator\", \"arguments\": {\"expression\": \"34500 / 250\"}}}]}]",
  "id": "toolbasic-0001",
  "domain": "toolbasic",
  "difficulty": 1,
  "source_file": "part40_toolbasic.jsonl",
  "harness": "toolbasic",
  "num_turns": 4,
  "num_tool_calls": 1
}

Points worth knowing before you point a trainer at it:

• system is a message, not a column. It is folded into messages[0] as role: "system", which is where ms-swift reads it from. The same system string is on every row by design: it is the persona being trained, not boilerplate to be factored out.
• Every message has the same four keys — role, content, tool_calls, name — with null where they do not apply. This is not cosmetic. The datasets loader infers one Arrow struct for a column and casts every block to it, so a messages column where some messages carry tool_calls and others do not fails to load outright rather than loading badly. It is also why these files are parquet: the schema is written out explicitly, so none of it depends on inference.
• The trailing metadata columns (id, domain, difficulty, source_file, harness, num_turns, num_tool_calls) are for filtering, sampling and analysis. ms-swift drops extra columns by default.
• Length. Median row is 622 tokens, p99 1,897, longest 3,882. Nothing here is close to a context limit.

images

Empty on every row. The corpus is text and tool calls; there are no images in it. The column is present so multimodal rows can be added later without a schema change, and it is already in its canonical form: paths or URLs in images, and a <image> tag in the message content at each position an image belongs. If you add image rows, keep the tag count equal to the length of images.

tools

A JSON string holding a list of OpenAI function schemas, which is the form ms-swift's agent format expects. "[]" means the row has no tool surface.

The column carries the full menu the row's agent exposes, not just the tools that row happened to call. That matters for training: 112 of the 612 tool-surface rows make no call at all, and those are the rows that teach restraint. Declaring only the called tools would turn them into empty menus and lose the signal.

The menus are the fixed catalogues the conversations were written against, across 21 distinct tool surfaces: a three-tool menu (calculator, web_search, web_fetch); an eighteen-tool office suite where near-duplicate pairs make picking the wrong one the expensive mistake; seven-tool internal and multilingual menus; the plain portable web_search/web_fetch pair; and sixteen named agent harnesses whose spellings differ. A WebFetch takes a prompt and is lossy by design, webfetch takes a format and a timeout, pi stores search output instead of returning it so a second get_search_content call is mandatory, gemini puts the url inside the prompt rather than in an argument, goose namespaces tools by the extension that supplies them, and two of the sixteen ship no web tool at all. tools_catalog.json in this repo has all 78 schemas in full.

One row contains a call that deliberately violates its own schema, followed by a corrected retry, and the reasoning names what was wrong. That is the training signal and it is left intact.

Splits

split	rows
train	8,554
validation	178

The holdout is ~2%, stratified by domain: every k-th row within each domain, with k chosen per domain so the rate lands near 2% and no domain with rows ends up empty. Domain composition is therefore preserved on both sides.

What is in it

64 domains, 48 to 200 rows each, difficulty 1 to 5 (1,746 / 2,180 / 2,615 / 1,750 / 441). 862 rows (9.9%) are multiturn, from 4 up to 12 messages. About 6.2M tokens of conversation text, 783 tool calls.

area	domains
identity and refusal	identity, assistant, honesty, hallucination, truthfulness, uncensored, injection, safety
reasoning and maths	reasoning, problemsolving, mathriddles, riddles, stats, leetcode, arcgrid, arcinduction, stem, commonsense, hellaswag
closed-form formats	mcq_core, mcq_technical, truefalse, fillblank, format, infformatting, infinterpreting
writing and text work	summarization, extraction, editing, creative, translation, multilingual, typos, unscramble, selfcorrect, scopededit, recovery
code	coding, debugging, shellscript, webfrontend, webbackend, webfullstack, dataeval, datasetauthoring, mltrain, agentops
security and law	cybersec, cyberlaw, cyberrange, emergencyusa
retrieval	rag, websearch
multiturn	mt_plain, mt_ml, mt_tools, mt_tools_ml
tool use and harnesses	toolbasic, tooladvanced, webgeneric, webharness, harnessml, webdialect
instruction following	instrfollowing

Languages: English plus twenty others. The ones identifiable from the text alone are Tamil, Korean, Italian, Hebrew, Japanese, Polish, Chinese, Spanish, Dutch, Greek, Turkish, Hindi, Portuguese, Ukrainian, Finnish, Romanian and Persian.

Two things about the multilingual rows are deliberate departures worth knowing. In parts 45 and 46 the reasoning stays in English while the user turn and the visible answer follow the user's language, so the language of the reasoning cannot become a cue for the language of the answer. In part 65 the reasoning is in the target language too, which teaches that neither the language of the instruction nor the language of the reasoning determines the language of the answer. Tool names and machine-readable argument values stay English and ASCII in both; a search query follows the conversation's language, because that is what a real user types.

Loading it

from datasets import load_dataset

ds = load_dataset("CrowdMind/fred-sft-qwen")
print(ds["train"][0]["messages"][-1]["content"])

data/train.parquet and data/validation.parquet carry an explicit Arrow schema, so nothing about how they load depends on type inference. About 5 MB.

Training it

LoRA on a Qwen3.5 chat model with ms-swift:

CUDA_VISIBLE_DEVICES=0 swift sft \
  --model Qwen/Qwen3.5-4B \
  --dataset CrowdMind/fred-sft-qwen \
  --train_type lora \
  --loss_scale default+ignore_empty_think \
  --num_train_epochs 2 \
  --per_device_train_batch_size 1 \
  --learning_rate 1e-4 \
  --lora_rank 16 \
  --lora_alpha 32 \
  --target_modules all-linear \
  --output_dir output

Two flags deserve a decision rather than a default:

• --loss_scale ignore_empty_think drops the 1,324 empty <think> blocks from the loss, so the model is not trained to emit an empty think as often as a real one. Use default if you want the empty-think behaviour trained too.
• --packing true needs --attn_impl flash_attn. Most rows are a single short exchange so packing helps, but the multiturn and tool-calling rows are long enough to make the length distribution lumpy.

Tool-calling rows are 500 of 8,554. If tool use is the behaviour you are after, oversample by domain rather than by row:

--dataset CrowdMind/fred-sft-qwen#domain=toolbasic ...

Full-parameter fine-tuning is the same command with --train_type full --deepspeed zero2 --learning_rate 1e-5.

Provenance

Every organisation, product, page, person, price and figure in this corpus is invented. Web addresses sit on the reserved .test top-level domain. There are no real credentials, no real personal data and no real quotations. Nothing was scraped from a live source, and no row asserts a benchmark score or a product version.

The one real-world surface is the assistant persona itself, which names Freaky Labz and a 2024 knowledge cutoff. If you retrain on this you are training that persona: keep messages[0], replace it, or strip it and set --system.

Licence

other. This corpus is released by its author for fine-tuning; check the terms you need before redistributing a model trained on it.