FreeBot Dataset

Live site: https://freequillbot.netlify.app

Author: Vatsal K. (alias VatsalDaPro)

Training and evaluation data for FreeBot — a free, self-hosted paraphrasing tool built as a personal project. The goal: replicate the core behavior of tools like QuillBot's paraphraser using small open models fine-tuned locally, rather than a commercial API.

Current version: Mark II. Mark II adds 720 structure-preserving training examples (the mark_ii/ folder) on top of the original Mark I set. See Mark II below. The original Mark I files are unchanged.

Why this dataset exists

Zero-shot prompting of small instruct models (Qwen2.5-0.5B/1.5B, and others tested in an initial 6-model bake-off) only ever produced synonym-swapping — near-identical sentence structure with a few words substituted. It never did genuine structural restructuring. Fixing that required fine-tuning on real paraphrase pairs, which meant assembling a dataset that:

• Covers 4 distinct paraphrase modes: Natural, Formal, Simple, Shorter — each with genuinely different rewriting behavior, not just a different prompt on the same rewrite.
• Spans 3 length tiers: small (single sentence), medium (paragraph), large (multi-paragraph).
• Doesn't leak into the held-out evaluation set used to measure fine-tune quality.

How it was built

1. Dataset survey — surveyed a wide range of candidate public paraphrase datasets. Most were rejected for wrong shape (detector-style, not generation pairs), too-high word overlap (built for paraphrase detection rather than generation — useless for teaching restructuring), semantic drift, or eval-set leakage.
2. Real-corpus mining — for the sources that passed, applied a length-dependent "genuinely shorter/different" heuristic (character-count based, tiered by input length) plus spaCy NER-based entity-loss detection to catch dropped named entities.
3. LLM-assisted generation — used a local 4B-class quantized model to generate additional Formal/Simple pairs from real source sentences (not synthetic prompts), tiered by length, filtered inline for: overlap ratio, content-word retention (info-loss detection), refusal-phrase blocklist, and question-mark-preservation (task-non-compliance detection — catches the model answering a question instead of paraphrasing it).
4. Hand-written + user-curated pairs — supplemented underrepresented modes with manually written and manually reviewed examples.
5. Dedup + leak-check — every source deduped internally, against each other, and against the frozen held-out eval set (eval_set.json, 167 examples, never used in training).

Files

Mark II (current)

• mark_ii/training_set_with_structure_720.json — the Mark II training set: 5,920 examples = the original 5,200-example Mark I set plus 720 structure-preserving examples (Formal 2,180 / Simple 1,380 / Natural 1,180 / Shorter 1,180). Same schema as training_set.json. The 720 new rows have source: null.
• mark_ii/structure_training_batch_combined.json and mark_ii/structure_training_batch_twins2.json — the two source batches (360 examples each) that together make up exactly the 720 structure rows, kept separate so the new data is easy to inspect or reuse. Schema: mode, source_text, paraphrase.
• mark_ii/training_data/ — everything else from the Mark II data work, for reproducibility: the intermediate training sets (training_set_v2_structure.json 5,520 rows, training_set_with_structure_2x.json 5,520 rows, training_set_with_structure_240.json 5,680 rows — the superseded 240-example retrain) and the earlier source batches (structure_training_batch.json, _twins.json, _expansion_a.json, _expansion_b.json). Same schemas as above. These are superseded by the 720 set and kept only so earlier results can be reproduced.
• mark_ii/structure_heldout.json — 12 documents with headings and lists, never used in training, used to measure generalization of structure preservation. Schema: mode, source_text (inputs only; run each through all four modes).

Mark I (unchanged)

• training_set.json — the original assembled training set: 5,200 examples (Formal 2,000 / Simple 1,200 / Natural 1,000 / Shorter 1,000), each with mode, length_tier, source_text, paraphrase, source (provenance tag).
• eval_set.json — 167-example frozen held-out evaluation set. Never used as training data, in Mark I or Mark II.
• finetune_eval_results.json — aggregate overlap-ratio results from evaluating the Mark I fine-tuned model against eval_set.json.
• datasets/ — raw and intermediate per-source filtered pools (one file per source, plus mined/heuristic-checked intermediate files) that feed into training_set.json.
• Root-level dataset_*.json files — per-mode intermediate pools (hand-written, filtered, LLM-generated) before final assembly.

Mark II

Real traffic exposed a weakness the Mark I fine-tune never showed in testing: it paraphrased plain prose well but flattened structured documents (numbered headings, bullet lists) into one undifferentiated paragraph. Prompt-level patches only covered the exact reported pattern, and some made it worse (silently deleting content), so the fix had to come from the training data.

What the 720 structure examples are: 180 unique structured documents, each rewritten in all 4 modes (180 per mode), with the headings/list structure preserved in the paraphrase. Three retrain attempts showed that diversity matters more than repetition: repeating a small pool of documents many times taught the model those documents, not the pattern, while more unique documents seen once generalized.

Results

Structural preservation = headings, list items, and paragraph breaks in the input survive in the output.

Metric	Mark I model	240-example retrain	Mark II (720)
Structural, adversarial (headings/lists; documents from the training pool)	6.2% (45/720)	97.1% (233/240)*	95.4% (687/720)
Structural, held-out (12 documents never trained on × 4 modes)	10.4% (5/48)	66.7% (32/48)	77.1% (37/48)
Overlap ratio on eval_set.json (lower = more restructuring)	0.430	0.407	0.418
Semantic similarity on eval_set.json	0.833	0.827	0.830
Entailment on eval_set.json	0.600	0.592	0.571

* The 240 retrain was run against its own 240-document pool, not the 720-document pool, so the two adversarial percentages are not measured on identical documents. Adversarial scores are measured on documents drawn from the training pool and so reflect training fit, not generalization; the held-out row is the like-for-like generalization comparison.

Zero overlap was verified between mark_ii/structure_heldout.json and every training file, and between eval_set.json and the Mark II training set.

Correction to the Mark I results

The Mark I overlap numbers below (0.30–0.45) were measured on the unmerged LoRA adapter and reproduce exactly. The GGUF file that was initially served to the public did not reach them: re-measured at 0.60 overlap, barely better than zero-shot. Root cause was in the serving stack, not the data (llama-cpp-python did not feed the prompt into its repetition-penalty sampler, and its default penalty window was too short). With that fixed, the served model reproduces the documented numbers (0.37–0.38 overall overlap on eval_set.json, ~0.2 s per request).

Known limitations

• Fact drift. Across every model version tested, outputs invent or drop a small fact (a rounded number, a swapped medical detail) roughly one time in seven or eight. Double-check names, numbers, and dates before relying on output.
• Weakest case. Shorter mode on dense mixed lists is the lowest-scoring cell in both retrains; it is where more authored examples would help most.
• Summarization is not covered by this dataset. The Summarize tab on the site uses the untrained base model; no summarization training data is included here.

The fine-tuned model

The model trained on this dataset is published at Pixiano45/freebot_qwen0.5 (gated).

Qwen2.5-0.5B-Instruct + LoRA (rank 16, alpha 16, targeting all attention + MLP projections), trained via Unsloth, mode-conditioned via a prompt prefix per example ("Paraphrase the following text so it sounds natural/formal/simply/concisely..."), formatted with the model's own chat template.

• 8.8M trainable params out of 502.8M total (LoRA).
• Mark I: 3 epochs on the 5,200-example set, 975 steps, batch size 4 × grad accum 4 (effective 16), lr 2e-4 with warmup+decay, bf16. Final training loss ~1.40-1.44.
• Mark II: 3 epochs on the 5,920-example set, 1,110 steps. The Q8_0 GGUF served on the site is produced from this run.

Mark I results — held-out eval overlap ratio (lower = more genuine restructuring, not synonym-swapping)

Mode	Zero-shot baseline (avg)	Fine-tuned (avg / median)
Natural	~0.60-0.79	0.305 / 0.324
Formal	~0.60-0.79	0.409 / 0.414
Simple	~0.60-0.79	0.378 / 0.375
Shorter	~0.60-0.79	0.454 / 0.429

The fine-tune roughly halved the word-overlap ratio against the source text across every mode compared to zero-shot prompting of the same base model — confirming it learned genuine structural rewriting rather than word substitution. Manual review of the worst-case (highest-overlap) outputs per mode showed no hallucination or meaning drift; the highest-overlap cases were simply source sentences that were already maximally concise for their target mode (e.g. "Restart your router if the connection drops for more than a minute" has little room to restructure further without changing meaning).

Inference speed: Mark I, unquantized bf16, single sequence, RTX 5060 Ti: ~45ms/token, ~1.2s average per output. Mark II, GGUF Q8_0: ~0.2s per request.

License / usage

Access to this dataset requires agreeing to the repository's usage terms before use. Contact vatsaldapro@gmail.com for permitted-use details before any reuse, redistribution, or derivative work.

---

Author: Vatsal K. (alias VatsalDaPro)