data-juicer

Data-Juicer: The Data Operating System for the Foundation Model Era

Data-Juicer (DJ) transforms raw data chaos into AI-ready intelligence. It treats data processing as composable infrastructure—providing modular building blocks to clean, synthesize, and analyze data across the entire AI lifecycle, unlocking latent value in every byte.

Whether you're deduplicating web-scale pre-training corpora, curating agent interaction traces, or preparing domain-specific RAG indices, DJ scales seamlessly from your laptop to thousand-node clusters—no glue code required.

Alibaba Cloud PAI has deeply integrated Data-Juicer into its data processing products. See Quickly submit a DataJuicer job.

🧃 Juicer, our natural-language data-refinement model, turns cleaning instructions, filtering rules, and semantic-tagging requirements into structured outputs. Try it on HuggingFace or ModelScope, or see the Juicer docs.

---

🚀 Quick Start

Zero-install exploration:

• JupyterLab Playground with Tutorials
• Ask DJ Copilot

Install & run:

uv pip install py-data-juicer
dj-process --config demos/process_simple/process.yaml

Or compose in Python:

from data_juicer.core.data import NestedDataset
from data_juicer.ops.filter import TextLengthFilter
from data_juicer.ops.mapper import WhitespaceNormalizationMapper

ds = NestedDataset.from_dict({
    "text": ["Short", "This passes the filter.", "Text   with   spaces"]
})
res_ds = ds.process([
    TextLengthFilter(min_len=10),
    WhitespaceNormalizationMapper()
])

for s in res_ds:
    print(s)

---

✨ Why Data-Juicer?

1. Modular & Extensible Architecture

• 200+ operators spanning text, image, audio, video, and multimodal data
• Recipe-first: Reproducible YAML pipelines you can version, share, and fork like code
• Composable: Drop in a single operator, chain complex workflows, or orchestrate full pipelines
• Hot-reload: Iterate on operators without pipeline restarts

2. Full-Spectrum Data Intelligence

• Foundation Models: Pre-training, fine-tuning, RL, and evaluation-grade curation
• Agent Systems: Clean tool traces, structure context, de-identification, and quality gating
• RAG & Analytics: Extraction, normalization, semantic chunking, deduplication, and data profiling

3. Production-Ready Performance

• Scale: Process 70B samples in 2h on 50 Ray nodes (6400 cores)
• Efficiency: Deduplicate 5TB in 2.8h using 1280 cores
• Optimization: Automatic OP fusion (2-10x speedup), adaptive parallelism, CUDA acceleration, robustness
• Observability: Built-in tracing for debugging, auditing, and iterative improvement

⭐ If Data-Juicer saved you time or improved your data work, please consider starring the repo. It helps more people discover the project and keeps you notified of new releases and features.

---

📰 News

• 🎯 Boundary-Correct Selectors & Filters — explicit top_ratio: 0 and zero-row random selections now keep zero rows; single-sided range_specified_field_selector bounds apply instead of returning the whole dataset; topk_specified_field_selector ranks top-level numeric strings numerically and tolerates None; specified_numeric_field_filter keeps 0 and 0.0; suffix_filter normalizes txt, .TXT and .txt alike.
• 🛡️ Broader PII Redaction — pii_redaction_mapper also redacts JWTs, international phone numbers, MAC addresses, Feishu/DingTalk open IDs and bracketed IPv6 addresses; CN phone and ID numbers and these tokens are caught when they sit directly next to CJK text; secret and ID values (user_id: 42, {"user_id": "u-123"}, Authorization: Bearer ...) are redacted whole while keeping the key, separator and quotes, full-width ： is accepted, and values no longer run onto the next line unless it is indented. clean_email_mapper matches uppercase domains; clean_ip_mapper matches compressed IPv6 and IPv6-embedded IPv4 addresses.
• ⚡ Faster Dedup, Loading & Field Selectors — exact, simhash, image and video deduplication compute kept rows from the hash columns instead of decoding every column; line dedup counts line hashes from the hash column; MinHash band collisions are unioned during the scan; unify_format skips the None-text filter when no text column has nulls; four field selectors read their column in 10,000-row batches.
• 🔧 Media, Loading & Job Fixes — image OPs write results back as PNG bytes so chained image OPs can read them; video frame processing keeps the audio track; lenient JSONL keeps the BOM-prefixed first record and loads .jsonl.gz/.jsonl.zst shards whose suffixes are uppercase or mixed-case; inline LaTeX comments no longer consume the preceding character; expand_macro_mapper expands macros at the end of the text or directly followed by another macro; job progress reads metrics from completion-event metadata; nltk upgraded to 3.10.4 and GitPython to 3.2.1.

• 🎛️ Throughput-Aware GPU Actor Planning — ray_partitioned runs a GPU preflight that measures each GPU operator's memory, steady-state throughput, and output ratio, then plans actor counts independently of the partition count. Partitions in one execution group share an actor pool to avoid repeated model loading. Enabled by default; set partition.gpu_preflight_enabled: false to keep explicitly configured GPU resources.
• 🪄 Adaptive GPU Microbatching (opt-in) — With elastic_juicer_adaptive_batching: true, eligible CUDA mappers retry the same rows in smaller microbatches after an OOM and cautiously grow back once input pressure eases. elastic_juicer_profile_seed: true reuses compatible batch bounds across execution groups and replacement actors within one ray_partitioned run. Both are off by default.
• 🧮 Leaner Ray MinHash Dedup — ray_bts_minhash_deduplicator keeps edge buffers and hash keys in packed NumPy arrays instead of Python objects, reducing memory overhead with unchanged configuration and results.
• 🔧 Operator Fixes — clean_html_mapper works with selectolax 1.0; remove_specific_chars_mapper escapes regex characters and no longer strips |; remove_header_mapper now applies its default drop_no_head=True and clears texts without a LaTeX header; the entity-relation and support-text extractors honour drop_text; general_field_filter accepts negative numbers in conditions; local Hugging Face embeddings in text_embd_similarity_filter no longer mix the model's repr into the input text.
• 🗂️ Loading, Analysis & Tool Fixes — The HuggingFace load strategy applies limit after loading; datasets allotted zero samples under max_sample_num are skipped; the lenient JSONL cache refreshes when source files change; overall analysis keeps stats columns whose first value is null; the visualization app no longer raises KeyError when no filter has tunable stats; the GPT evaluator excludes failed judge calls from averages and reports their count.

• 🧮 Cluster-Aware Partitioning — Automatic partition counts use live Ray cluster resources. Manual partition.size targets split data at row boundaries, including inputs with fewer blocks than partitions.
• ✅ Config Validation — Pipeline preflight catches invalid operator settings and executor/schema mismatches before processing. Reader defaults now apply consistently across execution and analysis.
• 🔌 LiteLLM Backend — Select api_backend="litellm" in prepare_api_model for chat, embedding, and Responses requests through provider-specific model routing; the existing OpenAI-compatible backend remains the default.
• 📚 Documentation Refresh — Rewritten English and Chinese guides cover installation, processing, analysis, configuration, export, and the playground. Added documentation for 28 existing operators, corrected examples, and separated guide and API navigation with incremental versioned documentation builds.
• 🗄️ Unified Remote Export — Local, S3, and HDFS export share filesystem dispatch; JSONL export now serializes Python dates and datetimes in ISO format.
• 🖼️ Image OHEM Selector — New image_ohem_selector selects high-loss image samples using a user-supplied scoring function and a top-k or ratio budget.
• ⚡ Bounded Tokenizer Batches — Token-count filters limit tokenizer batch sizes to reduce peak memory on long inputs.
• 🔧 Robustness Fixes — Fixed fused-filter cache isolation, MinHash state reuse and empty inputs, deduplicator execution-mode declarations, empty text chunks, gzip JSONL HPO sampling, and pandas extension-dtype handling. HPO modules can now be imported without starting a sweep.

• 🧃 Natural-Language Data Refinement — Juicer follows natural-language instructions for text cleaning, filtering, and semantic labeling.
• 🏠 Local Deployment — Download the model for local deployment.
• 🧪 Playground — Try data-refinement recipes in the Juicer Playground.

• 🧩 External OP Plugins — Third-party operators can now be shipped as standalone pip packages and auto-registered via Python entry points.
• 🗄️ HDFS I/O — Added hdfs:// support for dataset loading and exporting, aligned with the existing S3 path.
• ⚡ Ray Data Optimizations — Removed eager actions that forced premature execution, migrated to the public TaskPoolStrategy/ActorPoolStrategy APIs, parallelized partitioned execution, preserved elastic actor pool concurrency, and kept partition checkpoints valid across block-layout changes.
• 🌐 Elastic Multi-node Sharding — New runnable reference workflow under demos/elastic_sharding/ that shards large JSONL datasets across nodes via node-local Ray executors, with retries and ordered merge.
• 📊 Distributed RayAnalyzer — New RayAnalyzer computes and aggregates dataset stats with Ray native operators, avoiding pandas materialization.
• 🧮 Memory Optimizations — Streamed n-gram counting in repetition filters and block-wise MinHash permutations cut peak memory (768 → 272 MiB RSS) without changing results.
• 🔧 Robustness & Dependency Fixes — Fixed text_chunk_mapper delimiter leakage, calibrate_response_mapper output_pattern handling, and null captions in image_diffusion_mapper; added membership operators to general_field_filter; relaxed numpy/fsspec/pandas bounds for Python 3.13+ and pyarrow>=17.

• 🧑‍🤝‍🧑 New OPs — Added 9 human-centric video understanding operators (human track extraction, active-speaker detection, audio ASR, speech emotion & age/gender detection, face demographic & attribute/emotion captioning, face-ratio filtering) for building HumanVBench (CVPR'26)-style pipelines.
• ⚡ Batch-local Stage Fusion — New FusedSequentialBatchOp fuses consecutive OPs within a batch to cut inter-op overhead and speed up sequential processing.
• 🔧 Robustness & Install Fixes — Fixed Ray deduplicator shared-state handling, resolved a relative-path issue in the Ray checkpoint writer, made clean_html_mapper robust to null text values, handled boolean stat columns in ColumnWiseAnalysis, and unblocked ARM64 (aarch64) installation via precise decord/torchcodec platform markers.
• 🧪 Test Coverage & Cleanup — Expanded tests for utility functions and model handling, plus assorted code cleanup.

• 🤖 VLA Ops Enhancements — Expanded embodied-AI processing with 10+ new/renamed VLA operators (camera calibration via DeepCalib/DroidCalib/MoGe, atomic action segmentation, hand action computation & motion smoothing, clip reassembly, trajectory overlay, LeRobot export) and a complete VLA pipeline demo.
• 🔄 Ray Repartition Pipeline — New ray_repartition_pipeline for dataset-level block repartitioning in Ray mode.
• ⚡ Scalable Ray Data Reads — Wired override_num_blocks through the full call chain for controlling block parallelism on PB-scale datasets.
• 🧪 Test Coverage Expansion — Added 409 new test cases across 18 test files.
• 🐳 Stability & Robustness Fixes — JSONStreamDatasource schema unification, OP env version resolution, FUSE-safe rmtree for PartitionedRayExecutor, deprecated model name updates, and num_proc handling fixes.

• 🧹 New Deduplicator — Added DocumentLineDeduplicator for cross-document line-level dedup, removing boilerplate lines (templates, copyright notices, navigation bars) by global document frequency.
• 🤖 Agent Data Quality Toolkit — Shipped interaction-quality OPs & recipe, a bad-case HTML report, and more robust JSONL / HuggingFace meta loading.
• 📦 Leaner & Faster Install — Slimmed the default dependency set (Ray, audio, spaCy, av, etc. moved to on-demand extras) to speed up installation.
• 🐳 Stability & Robustness Fixes — Library-safe error handling (raise over exit(1)), Ray init/temp-dir fixes, valid API params (drop invalid max_new_tokens), PyArrow 20+ batch JSON reading, local-path aesthetics model support, and more performance/bug fixes.
• 🧠 Semantic LLM Operators — Introduced llm_extract_mapper, llm_condition_filter, and llm_structured_ops with unified llm_* naming and configurable inference strategies (join/agg/top-k planned).

• 📄 Two new LaTeX-focused mapper OPs shipped, extending data-juicer's document processing capabilities to handle .tex archives and figure contexts.
• 🗜️ Compressed dataset format support: json[l].gz files can now be loaded directly, and Ray datasets gain proper support for reading compressed JSON files.
• 📚 New documentation added covering cache, export, and tracing workflows to help users better understand and debug data processing pipelines.
• 🤖 Major refactor and upgrade of data-juicer-agents completed: The project architecture and CLI/session capabilities were comprehensively redesigned for better maintainability and extensibility. See date-juicer-agents for more details.

• 🚀 Enhanced Distributed Execution Framework -- Introduced partitioned Ray executor and OP-level isolated environments to improve fault tolerance, scalability, and dependency conflict resolution.
• 🤖 Expanded Embodied AI Video Processing -- Added specialized operators for camera calibration, video undistortion, hand reconstruction, and pose estimation to strengthen multi-view video handling.
• 💪🏻 System Performance & Developer Experience Optimizations -- Enabled batch inference, memory/log reduction, core logic refactoring, and updated documentation/templates.
• 🐳 Critical Bug Fixes & Stability Improvements -- Resolved duplicate tracking, parameter conflicts, homepage rendering issues, and outdated docs for higher reliability.

• 🤖 Q&A Copilot — Now live on our Doc Site | DingTalk | Discord. Feel free to ask anything related to Data-Juicer ecosystem!
  • Check 🤖 Data-Juicer Agents | 📃 Deploy-ready codes | 🎬 More demos for more details.
• 🎬 Video Bytes I/O — Direct bytes processing for video pipelines
• 🫆 Ray Mode Tracer — Track changed samples in distributed processing
• 🐳 Enhancements & fixes — refreshed Docker image, small perf boosts, GitHub Insights traffic workflow, Ray compatibility updates, and bug/doc fixes.

View All Release and News Archive

---

🔌 Users & Ecosystems

The below list focuses on developer-facing integration and usages in alphabetical order. Missing your project / name? Feel free to open a PR or reach out.

Data-Juicer plugs into your existing stack and evolves with community contributions:

Extensions

• data-juicer-agents — DJ Copilot and agentic workflows
• data-juicer-hub — Community recipes and best practices
• data-juicer-sandbox — Data-model co-development with feedback loops

Frameworks & Platforms

AgentScope · Apache Arrow · Apache HDFS · Apache Hudi · Apache Iceberg · Apache Paimon · Alibaba PAI · Delta Lake · DiffSynth-Studio · EasyAnimate · Eval-Scope · Huawei Ascend · Hugging Face · LanceDB · LLaMA-Factory · ModelScope · ModelScope Swift · NVIDIA NeMo · Ray · RM-Gallery · Trinity-RFT · Volcano Engine

Industry

Alibaba Group, Ant Group, BYD Auto, ByteDance, DTSTACK, JD.com, NVIDIA, OPPO, Xiaohongshu, Xiaomi, Ximalaya, and more.

Academia

CAS, Nanjing University, Peking University, RUC, Tsinghua University, UCAS, Zhejiang University, and more.

Contributing & Community

We believe in building together. Whether you're fixing a typo, crafting a new operator, or sharing a breakthrough recipe, every contribution shapes the future of data processing.

We welcome contributions at all levels:

• Good First Issues — Add operators, improve docs, report issues, or fix bugs
• Developer Guide — Optimize engines, add features, or enhance core infrastructure
• DJ-Hub — Share knowledge: recipes, papers, and best practices
• Connect: Slack · DingTalk · Discord

Discord	DingTalk

Data-Juicer is made possible by the users and community:

• Initiated by: Alibaba Tongyi Lab
• Co-developed with: Alibaba Cloud PAI, Anyscale (Ray team), Sun Yat-sen University, NVIDIA (NeMo team), and contributors worldwide
• Inspired by: Apache Arrow, Ray, Hugging Face Datasets, BLOOM, RedPajama-Data, ...

---

Documentation

For detailed documentation, please see here.

Quick Links:

• operator zoo — Browse 200+ operators with examples
• Agent interaction quality & bad-case — In-repo recipe, JSONL pipeline, HTML report (demos/agent/; operators such as agent_bad_case_signal_mapper are also listed in docs/Operators.md)
• data-juicer-hub — Community-driven recipes and best practices
• developer guide — Build your own code and contribute to DJ
• data-juicer-cookbook — resource archive
• awesome_llm_data — “Awesome List” for data-model co-development

---

📄 License & Attribution

Data-Juicer is released under the Apache License 2.0. Attribution is appreciated: please use our badge, or text as "This project uses Data-Juicer: https://github.com/datajuicer".

---

📖 Citation

If you find Data-Juicer useful in your work, please cite:

@inproceedings{djv1,
  title={Data-Juicer: A One-Stop Data Processing System for Large Language Models},
  author={Chen, Daoyuan and Huang, Yilun and Ma, Zhijian and Chen, Hesen and Pan, Xuchen and Ge, Ce and Gao, Dawei and Xie, Yuexiang and Liu, Zhaoyang and Gao, Jinyang and Li, Yaliang and Ding, Bolin and Zhou, Jingren},
  booktitle={SIGMOD},
  year={2024}
}

@article{djv2,
  title={Data-Juicer 2.0: Cloud-Scale Adaptive Data Processing for and with Foundation Models},
  author={Chen, Daoyuan and Huang, Yilun and Pan, Xuchen and Jiang, Nana and Wang, Haibin and Zhang, Yilei and Ge, Ce and Chen, Yushuo and Zhang, Wenhao and Ma, Zhijian and Huang, Jun and Lin, Wei and Li, Yaliang and Ding, Bolin and Zhou, Jingren},
  journal={NeurIPS},
  year={2025}
}

• (ICML'25 Spotlight) Data-Juicer Sandbox: A Feedback-Driven Suite for Multimodal Data-Model Co-development

• (CVPR'25) ImgDiff: Contrastive Data Synthesis for Vision Large Language Models

• (TPAMI'25) The Synergy between Data and Multi-Modal Large Language Models: A Survey from Co-Development Perspective

• (NeurIPS'25) Diversity as a Reward: Fine-Tuning LLMs on a Mixture of Domain-Undetermined Data

• (NeurIPS'25) MindGYM: What Matters in Question Synthesis for Thinking-Centric Fine-Tuning?

• (CVPR'26) HumanVBench: Exploring Human-Centric Video Understanding Capabilities of MLLMs with Synthetic Benchmark Data

• (ICML'26) DetailMaster: Can Your Text-to-Image Model Handle Long Prompts?

• (Data Scaling) BiMix: A Bivariate Data Mixing Law for Language Model Pretraining