Overview | NeMo Curator

Score and remove low-quality content using heuristics and machine learning classifiers to prepare your data for model training.

Large datasets often contain many documents considered “low quality.” In this context, low-quality data is unsuitable for downstream model training. High-quality data contains the characteristics that you want downstream models to learn. The metrics that define quality vary widely.

How It Works

NeMo Curator’s filtering framework includes several components that work within the data processing architecture:

ScoreFilter

Filter and Score Modules

The ScoreFilter is at the center of filtering in NeMo Curator. It applies a filter to a document and optionally saves the score as metadata:

from nemo_curator.pipeline import Pipeline
from nemo_curator.stages.text.io.reader import JsonlReader
from nemo_curator.stages.text.io.writer import JsonlWriter
from nemo_curator.stages.text.filters import ScoreFilter
from nemo_curator.stages.text.filters.heuristic import WordCountFilter
# Create pipeline
pipeline = Pipeline(name="quality_filtering")
# Load dataset
reader = JsonlReader(
    file_paths="books_dataset/*.jsonl",
    fields=["text", "id"]
)
pipeline.add_stage(reader)
# Create and apply filter
filter_stage = ScoreFilter(
    filter_obj=WordCountFilter(min_words=80),
    text_field="text",
    score_field="word_count",
)
pipeline.add_stage(filter_stage)
# Save filtered dataset
writer = JsonlWriter(path="long_books/")
pipeline.add_stage(writer)
# Execute pipeline (uses XennaExecutor by default)
results = pipeline.run()

Default Executor: When you call pipeline.run() without specifying an executor, NeMo Curator automatically uses XennaExecutor() as the default. You can optionally specify a different executor by passing it as a parameter: pipeline.run(executor=my_executor).

The filter object implements two key methods:

score_document: Computes a quality score for a document.
keep_document: Determines whether to keep a document based on its score.

Filtering Approaches

Heuristic Filtering

Filter text using configurable rules and metrics rules metrics fast

Classifier Filtering

Filter text using trained quality classifiers ml-models quality scoring

Distributed Classification

GPU-accelerated classification with pretrained models gpu distributed scalable

LLM Judge Workflow

Evaluate and filter records with config-driven large language model (LLM) judges and structured rubrics llm evaluation structured-scoring

Usage

NeMo Curator provides programmatic interfaces for document filtering through the Pipeline framework:

from nemo_curator.pipeline import Pipeline
from nemo_curator.stages.text.io.reader import JsonlReader
from nemo_curator.stages.text.io.writer import JsonlWriter
from nemo_curator.stages.text.filters import ScoreFilter
from nemo_curator.stages.text.filters.heuristic import WordCountFilter
# Create and configure pipeline
pipeline = Pipeline(name="document_filtering")
# Add data loading
reader = JsonlReader(
    file_paths="/path/to/input/data/*.jsonl",
    fields=["text", "id"]
)
pipeline.add_stage(reader)
# Add filtering stage
filter_stage = ScoreFilter(
    filter_obj=WordCountFilter(min_words=80),
    text_field="text",
    score_field="word_count"
)
pipeline.add_stage(filter_stage)
# Add output stage
writer = JsonlWriter(path="/path/to/output/filtered/")
pipeline.add_stage(writer)
# Execute pipeline (uses XennaExecutor by default)
results = pipeline.run()

Best Practices

When filtering large datasets, consider these performance tips:

Order matters: Place computationally inexpensive filters early in your pipeline.
Batch size tuning: Adjust batch sizes based on your hardware capabilities.
Use vectorization: Implement batched methods for compute-intensive filters.
Disk I/O: Consider compression and chunking strategies for large datasets.
Distributed processing: For TB-scale datasets, use distributed filtering with the XennaExecutor.

Refer to the following related documentation: