Juicer

中文说明

Juicer is a locally deployable, natural-language-driven data-refinement model post-trained from Qwen3.6-35B-A3B. Its language model has 35B total parameters, with 3B activated per token. It turns cleaning recipes, filtering rules, and semantic-labeling instructions into strict tagged text or canonical JSON outputs for private data pipelines.

Evaluation on CDR-Bench.

Highlights

• Recipe execution from plain language. Example: "remove emails, deduplicate sentences, normalize whitespace" → <status>KEEP</status><clean_text>Contact for help.</clean_text>.
• Order-aware refinement. Juicer distinguishes "filter before cleaning" from "filter after cleaning", which matters when intermediate text changes the decision.
• Structured semantic labeling. Rubric tasks return JSON such as {"helpfulness":4,"correctness":4,"coherence":4,"complexity":1,"verbosity":2}.
• Flexible local deployment. Juicer retains the Qwen3.6 format and supports OpenAI-compatible serving engines such as vLLM and SGLang, as well as direct local loading with Transformers.

Model Overview

Motivation: Why Juicer?

Data-Juicer provides a rich operator toolbox for cleaning, filtering, and preparing training data. In real data pipelines, however, users often describe refinement logic in natural language, combine several operators on the fly, or need soft semantic judgments that cannot be expressed by a single deterministic rule. Juicer is built for that gap: it follows Data-Juicer-style recipes as model instructions, keeps strict output schemas, and can run locally on private data.

Juicer combines supervised fine-tuning and reinforcement learning during post-training. Its optimization covers nearly 70 diverse operators and compositional data-refinement recipes, while also strengthening general instruction following, including format constraints, step ordering, and multiple simultaneous requirements.

Juicer is not a replacement for deterministic Data-Juicer jobs. It is most useful as a natural-language execution layer, a prototyping bridge, or a semantic operator when hand-written rules are too rigid.

The training data covers a broad Data-Juicer operator set; the CDR-Bench evaluation and examples focus on core refinement operators across:

• text mappers: link cleanup, comment/bibliography removal, repeated-sentence removal, long-word removal, whitespace normalization, and formatting normalization;
• filters: text/word length filters, word-repetition and stopword-ratio filters, and other rule-based quality gates;
• PII operators: contact, location, time, identity, and person-related redaction;
• semantic operators: hallucination detection/correction, rubric scoring, safety classification, and tagging.

Capabilities

CDR-Bench

Juicer is evaluated on CDR-Bench on Hugging Face. Benchmark code and release artifacts are available from the CDR-Bench repository.

CDR-Bench tests whether language models can faithfully execute data-refinement recipes rather than merely produce fluent rewrites. It covers atomic operators, compositional recipes, order-sensitive mapping/filtering, and semantic extensions such as PII redaction and rubric scoring. Scoring is deterministic: tagged text is compared with the reference output, while structured tasks use canonical JSON matching.

Quickstart

We have also prepared a Juicer Playground to demonstrate Juicer’s usage and example outputs. For efficient deployment in real data workflows, the following options are recommended.

Serve the model

vLLM is the recommended serving option. On a single GPU with sufficient memory, start an OpenAI-compatible endpoint with:

export MODEL_ID=/path/to/juicer-model

vllm serve "$MODEL_ID" \
  --served-model-name juicer \
  --port 8000 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90 \
  --reasoning-parser qwen3 \
  --language-model-only

SGLang can be used as an alternative OpenAI-compatible server:

export MODEL_ID=/path/to/juicer-model

python -m sglang.launch_server \
  --model-path "$MODEL_ID" \
  --served-model-name juicer \
  --port 8000

For direct local loading without a serving engine:

from transformers import AutoModelForImageTextToText, AutoTokenizer

model_id = "/path/to/juicer-model"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
    model_id,
    torch_dtype="auto",
    device_map="auto",
)

Call the API

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
response = client.chat.completions.create(
    model="juicer",
    messages=[{
        "role": "user",
        "content": (
            "Remove emails and return "
            "<status>KEEP|DROP</status><clean_text>...</clean_text> only.\n"
            "<input>a@b.com hello</input>"
        ),
    }],
    temperature=0,
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
)
print(response.choices[0].message.content)

Qwen3.6 does not use /nothink as a soft switch. Disable thinking through chat_template_kwargs.enable_thinking=false when the serving stack supports it.

Use Cases

Juicer outputs should still be checked by deterministic validators or human review when the action is high-impact. It is not intended for unsupervised legal or compliance decisions, irreversible deletion without safeguards, or broad chat, coding, or vision benchmarking.

Citation & Contact

@misc{juicer2026,
  title        = {Juicer: Natural-Language Data Refinement with Qwen3.6-35B-A3B},
  author       = {Juicer Contributors},
  year         = {2026},
  howpublished = {Hugging Face model release}
}

Juicer builds on Qwen3.6-35B-A3B, CDR-Bench, Data-Juicer, and Trinity-RFT. Feedback and testing are welcome. For questions or discussion, please open a discussion on the model page or leave an issue on the Data-Juicer GitHub Homepage.