davanstrien/rewire-jobs-demo

REWIRE on HF Jobs — a small, open, reproducible re-run

A proof-of-concept reproduction of REWIRE ("Recycling the Web", Meta/FAIR, COLM 2025 — arXiv:2506.04689), built entirely on Hugging Face Jobs with datatrove. REWIRE takes low-quality web documents that pre-training filters would throw away and rewrites them with an LLM into something worth keeping:

discarded web doc  ──▶  LLM rewrite      ──▶  re-score, same filter  ──▶  keep survivors
(median score 0.02)     (paper's prompt)      (rewrites: 0.6–0.8)         (≥ 0.530 bar)

The paper used Llama-3.3-70B (2025) as the rewriting teacher. This asks a 2026 question: can much smaller, current models do the same job — judged by the same kind of fastText quality gate the paper's pipeline uses?

Short answer, on this slice: yes, and the smaller model is better. A Qwen3.5-9B clears the filter more often than the paper's Llama-3.3-70B teacher, at roughly 13× lower cost per kept token — and a 4B matches the 70B.

This is a PoC, not a corpus. ~1,950 rewrites across four models, a few hundred documents per model, ~$11 in generation Jobs (≈$13 including pilot runs not in the shipped receipts). The paper's released dataset is 44.4B tokens. The point isn't the scale — it's that the pipeline works, the finding holds, and the whole thing is here to run bigger. The same code scales by changing two numbers (see Scaling up). If you have the budget, take it and run.

The finding

Every rewrite is scored with the stock DCLM fastText filter (mlfoundations/fasttext-oh-eli5) — the paper's own retrained variant is unreleased (see caveats). "Survival" = the fraction of rewrites that clear the median score of a stock-filter-scored sample of Meta's released REWIRE data (0.530). That's a comparison bar against what Meta shipped, not the paper's actual entry threshold.

model	median filter score	survival @ Meta bar	blind judges vs 70B	cost / 1k kept tokens
Llama-3.3-70B (paper's teacher)	0.506	49.6%	—	$0.0083
Qwen3.5-9B	0.798	61.7%	wins 20–4 (83%)	$0.0006
Qwen3.5-4B	0.646	54.2%	ties 6–6	$0.0006
Qwen3.5-122B	0.806	62.4%	(not run)	$0.0124

Validity check: our Llama-3.3-70B re-run has a similar median under the stock filter to Meta's own released 70B data (0.506 vs 0.530) — consistent with a faithful re-run rather than a broken pipeline.

Two rulers, and they disagree at the top end — which is itself the interesting part. On the pipeline's operative gate (the fastText filter that decides what enters pre-training), Qwen3.5-9B nearly matches the 122B (0.798 vs 0.806 median, 61.7% vs 62.4% survival). But blind paired judges still prefer the 122B's rewrites over the 9B's 71% of the time: the filter has a ceiling the judges can see past. Which ruler matters depends on your downstream claim — and the only definitive ruler is a pre-training run, which is out of scope here.

Verify it yourself (~30s, no GPU)

Don't take the table on trust. This re-scores every released rewrite with the stock filter and reproduces the survival numbers from the receipts (exits non-zero on mismatch):

uv run https://huggingface.co/datasets/davanstrien/rewire-jobs-demo/resolve/main/verify.py

What's in here

path	what
data/rewrites.parquet	1,953 rewrites (4 models). Columns documented below.
receipts/arm_results.json	per-model medians, survival rates, parse rates, measured job cost
receipts/survival_bar.json	the quality thresholds (Meta-data median, pool percentiles)
receipts/judging/	raw blind-judge votes + keys behind the pairwise numbers
pipeline/rewire_gen.py	the datatrove rewrite arm (runs on HF Jobs via JobsPipelineExecutor)
pipeline/score_arms.py	the fastText survival scorer
pipeline/prep_sources.py	builds the source pool from DCLM
verify.py	the audit script above
REPRODUCE.md	step-by-step walkthrough of the whole pipeline (prep → generate → score → verify)

Columns (data/rewrites.parquet)

column	type	description
slug	string	which model produced the rewrite: main-70b (Llama-3.3-70B, the paper's teacher), main-9b / main-4b / main-122b (Qwen3.5)
source_text	string	the original low-quality web document (sampled from DCLM; see provenance)
source_score	float	the source's score on the fastText quality filter, 0–1 (higher = higher quality). Sources are deliberately low: median ≈ 0.017
rewrite	string	the model's improved rewrite, parsed from between the prompt's <improved_response_starts>…<improved_response_ends> markers
rewrite_score	float	the rewrite's score on the same filter, 0–1. "Survival" = this clearing the 0.530 comparison bar (stock-filter median of Meta's released data)
completion_tokens	int	tokens generated for the rewrite (used for the cost-per-kept-token figures)

Each row is one source document rewritten by one model; the same source appears under multiple slugs where models were run on the same pool (used for the blind paired judging).

Scaling up

pipeline/rewire_gen.py is the whole generation arm. Scaling from this PoC to a real corpus is two numbers — tasks= (how many Jobs fan out) and --rows (documents per task):

executor = JobsPipelineExecutor(
    pipeline=[HuggingFaceDatasetReader(...), InferenceRunner(...), ParquetWriter(...)],
    tasks=20,              # fan out across 20 Jobs
    flavor="a100-large",
)

A finding worth carrying up (see pipeline/ notes): rewrite quality is predictable from a free source score (rewrite median by source quartile: 0.40 / 0.60 / 0.90 / 0.97), so score-gate before you rewrite — filter to sources above a floor, then rewrite only those. The source-score analysis suggests roughly half the GPU for nearly all the kept tokens versus the paper's rewrite-everything — suggested by the curve, not yet demonstrated at scale. Cheap 2026 models alone cut measured cost per kept token ~13×.

Naive extrapolation from the measured rates, for scale intuition: reproducing the volume of Meta's released 44.4B-token set would cost ≈$369k at the paper's-teacher rate ($0.0083/1k kept tokens) vs ≈$28k at 9B rates ($0.00064/1k) — before score-gating, which the curve suggests roughly halves it again. Linear scaling from 600-doc arms; co-tenant nodes can add up to ~2×. An order-of-magnitude estimate, not a quote.

Provenance & licence

This dataset mixes components with different terms — the repo licence tag is other for that reason:

• source_text comes from a ~1.2k-document sample of mlfoundations/dclm-pool-400m-1x, derived from Common Crawl and subject to the Common Crawl Terms of Use. We keep only a length-bounded band of the fastText score distribution (the paper's RefinedWeb rule-filters weren't reproduced — a documented deviation).
• Qwen3.5 rewrites (main-9b, main-4b, main-122b rows) are model outputs from Apache-2.0 models, released here under CC-BY-4.0.
• Llama-3.3-70B rewrites (main-70b rows, the paper's-teacher control arm) are Llama outputs and additionally subject to the Llama 3.3 licence terms for model outputs.
• We do not re-host Meta's released REWIRE data (facebook/recycling_the_web, CC-BY-NC + Llama naming clause) — we cite and compare against it.

Caveats (read these)

• PoC scale: 400–600 documents per model arm; small N.
• Stock filter: the paper's retrained fastText filter is unreleased, so we use the stock mlfoundations/fasttext-oh-eli5.
• No downstream validation: the definitive test is a pre-training run on the rewritten data. Not done here. The claims are about the filter and blind judges, not final model quality.
• Source pool is an approximation of the paper's discarded band (no RefinedWeb rule-filters).
• Family caveat: the winning small models are all Qwen3.5 — this isn't a statement about small models in general.
• Garbage in, garbage out: on an untrimmed bottom tier (cookie banners, landing pages), rewrite survival collapses. The score-gate above isn't optional — there has to be something worth rewriting.

Citation

@inproceedings{rewire2025,
  title     = {Recycling the Web: A Method to Enhance Pre-training Data Quality and Quantity for Language Models},
  author    = {Meta FAIR},
  booktitle = {COLM},
  year      = {2025},
  eprint    = {2506.04689},
  archivePrefix = {arXiv}
}

Built with datatrove on Hugging Face Jobs — largely by a coding agent (Claude Code) driving Jobs via the CLI, with human direction and review.