Dataset Viewer
Auto-converted to Parquet Duplicate
instruction
stringlengths
50
697
input
stringlengths
174
316
output
stringclasses
1 value
The curatorKit processes pre-trained datasets for language models after training. Each generated answer is compared against its source chunk. If a sample is rejected, it's written to 'rejected.jsonl' with a structured reason, ensuring no silent drop. Additionally, a run generates 'manifest.json', 'dataset_card.md', and...
CuratorKIT builds trainer-ready datasets for LLM post-training. Every generated answer is checked against the exact source chunk it came from. Rejected samples are written to rejected.jsonl with a structured reason, never dropped silently. A run also writes manifest.json, dataset_card.md, and SHA-256 checksums.txt.
Create an instruction that requires the use of at least two different types of strategies from the given passage to generate a complex instruction.
Quality gates run after generation. HallucinationGate scores grounding against the source passage. RewardGate scores helpfulness, honesty, and instruction following. DiversityGate drops near-duplicates using sentence embeddings. Adaptive recovery diagnoses each rejection and repairs the recoverable ones.
Hygiene stages include screening out potential threats through various methods like SecretGate, PIIPseudonymizer, and ToxicityGate. These tools help ensure data integrity and security before any machine learning calls.
Hygiene stages run before any LLM call. SecretsGate rejects API keys and private tokens. PIIPseudonymizer replaces names and emails with consistent fake values. ToxicityGate uses a local Detoxify classifier, with an optional LLM judge for borderline rows.
Curator run needs to specify the dataset name, field mapping options, generation task type, and export formats. It must also allow for customization of the backend environment.
A Curator run is config then execute. CuratorConfig names the dataset, field mapping, generation task, and export formats. curator.run() walks readers, hygiene, generation, gates, and exporters in that order. Changing BACKEND does not require rewriting the curator cell.
improve_backend_pricing: A pricing plan for improving backend performance can be implemented using AWS Lambda function triggers, which are triggered by AWS Lambda functions running on your EC2 instances. These triggers will periodically evaluate the current load on the backend services and adjust the cost based on this...
resolve_backend picks OpenRouter, a local vLLM OpenAI server, or Ollama. vLLM install uses uv pip install vllm --torch-backend=cu128. The waiter polls /v1/models and does not kill a serve that is still loading weights.
Create an instruction for converting JSONL readers into a structured format using Alpaca, ShareGPT, DPO, GRPO, and pretraining layouts. Ensure that the field_mapping process renames source columns to match schema fields.
JSONL readers accept Alpaca, ShareGPT, DPO, GRPO, and pretrain layouts. field_mapping remaps source columns onto schema fields. format='pretrain' keeps a text column as language-modeling output instead of renaming it to instruction.
Create an instruction that requires the respondent to identify and describe the key features of a specific type of artificial intelligence (AI) system based on its role in modern society.
QA generation asks a grounded question per chunk and writes an answer that must be supported by that chunk. num_questions controls how many pairs each passage yields. difficulty is easy, medium, or hard and only changes the prompt, not the schema.
Create a preference recommendation based on the given text.
Preference generation writes a chosen completion and a rejected completion for the same prompt. single_call asks the model for both in one response. two_pass samples independently then labels the better one. Export is DPO JSONL.
Generate GRPOs based on the provided prompt and optional judge scores, while ensuring temperature variations across different rollouts.
GRPO generation samples several completions per prompt and optional judge scores. Temperature spread varies rollouts around llm_temperature so the group is not identical. Export includes grpo and ppo JSONL.
Generate a detailed dialogue between two users where each user contributes their own unique input.
Multi-turn generation builds a short dialogue from a source chunk. num_turns is the number of user-assistant pairs. ShareGPT is the natural export; Alpaca flattens the last turn.
{ "evolved_instruction": "In this instruction, we need to rephrase the given 'num_evolutions' parameter as it can lead to a decrease in the accuracy of the generated answers. We also require you to specify the type of questions you want the AI to answer after rewriting.", "strategy_applied": "increase_reasoning", ...
Evol-Instruct rewrites a seed instruction into a harder variant. num_evolutions is how many rewrite steps run. generate_answers asks the model to solve the evolved prompt so the row is SFT-ready.
Create an instruction that requires the use of chain-of-thought reasoning based on the given passage.
Chain-of-thought generation either wraps an existing answer with reasoning or produces a new reasoned answer from the chunk. cot_mode is generate or wrap. The reasoning string is stored on the sample before export.
Create an instruction that directly answers the given source passage using only the 'add_constraints' strategy.
Adversarial QA injects a failure into a subset of answers after generation. injection_rate is the fraction of rows that get a known bad span. injection_types include contradicts_source and parametric_drift. The metadata flag injected_failure marks those rows.
The instruction must directly answer a question posed in the given source passage.
HallucinationGate scores whether the answer is entailed by the source passage. hallucination_threshold drops rows below the cutoff. A separate judge model avoids self-scoring. skip_if_no_context leaves rows without a passage alone.
Create an instruction that requires understanding of the context and relationships between different components of the RewardGate scoring system.
RewardGate scores helpfulness, honesty, and instruction following. reward_threshold drops low-scoring rows. Scores can be stored on the label for later filtering. The judge uses the same API base as generation unless overridden.
Embed each accepted row into a new table and drop duplicates based on specified similarity threshold.
DiversityGate embeds each accepted row and drops near-duplicates above similarity_threshold. The default embedding model is all-MiniLM-L6-v2. Coverage can be measured on an optional metadata field.
Create an instruction that generates diagnostic probes for each temperature value specified in 'probe_temperatures', ensuring only those rows with scores greater than 0.5 are considered recoverable.
DiagnosticProbe re-generates a rejected row at several temperatures. probe_temperatures is the list of values. probe_score_split decides which retries count as recovered. Recovered rows return to passed with provenance.
RewardRefiner runs a loop to rewrite low-reward answers and rerun RewardGate. After each run, recovered rows are merged into passed-only data before being exported.
RewardRefiner rewrites a low-reward answer and re-runs RewardGate. enable_reward_refiner attaches after the reward step. Recovered rows are merged into passed only after the pipeline returns so exporters see them.
SecretsGate detects secrets based on unique patterns and entropy in user inputs.
SecretsGate scans instruction and output for API keys, tokens, and high-entropy strings. detect-secrets plugins cover AWS, GitHub, Slack, and generic entropy. Hits become RejectedSample rows, not silent drops.
Create an instruction that directly answers the question 'What does PIIPseudonymizer do? ', using the given passage as context.
PIIPseudonymizer runs NER then Faker. The same real name maps to the same alias for the whole run when pii_faker_seed is fixed. Emails, phones, and locations are replaced in the configured fields only.
ToxicityGate checks the toxicity score for each row before proceeding further.
ToxicityGate runs Detoxify first. Scores below the pass threshold keep the row. Scores above the reject threshold drop it. The band in between can go to an optional LLM judge.
Add constraints based on the exact dedup hash normalization process described in the passage.
Exact dedup hashes normalized text and keeps the first copy. MinHash estimates Jaccard overlap on character n-grams. embedding_dedup writes a persistent index so later runs still catch repeats.
Clean up the text by removing HTML tags, normalization, collapsing whitespace, and dropping control characters. This ensures that only meaningful text remains for the language model.
Text cleaning strips HTML, normalizes Unicode, fixes mojibake, collapses whitespace, and drops control characters. clean_fields defaults to instruction, input, and output. Cleaning runs before generation so the LLM never sees the raw junk.
SchemaGate verifies each row's input/output constraints and validates pretraining rows against non-empty output requirements.
SchemaGate checks required fields and token bounds per task type. Pretrain rows need non-empty output. Instruction rows need instruction and output. Failures are RejectedSample records with a structured reason.
Create an instruction that requires deep analysis of the passage's content about exporting data using Alpaca, ShareGPT, DPO, GRPO, PPO, and corpus JSONL.
Exporters write Alpaca, ShareGPT, DPO, GRPO, PPO, and corpus JSONL into output_dir. Sidecars are manifest.json, dataset_card.md, and checksums.txt. Empty export files no longer crash a Hub push.
Create a comprehensive instruction that answers all of the following questions based on the given source passage: 1. What does 'push_to_hub' do? 2. How does 'push_to_hub' ensure that a dataset repository exists before creating one? 3. Why does 'push_to_hub' upload every exported and sidecar file into a new dataset rep...
push_to_hub creates a dataset repo if it is missing and uploads every export plus sidecars. push_format_to_hub sends one format. push_rejected_to_hub publishes the rejected split with the same provenance files.
{ "evolved_instruction": "max_samples selects the maximum number of rows for each reader during data preprocessing.", "strategy_applied": "concretize", "complexity_notes": "The "max_samples" constraint requires selecting the largest subset of rows based on specified criteria." }
max_samples truncates the passed list after gates. Per-reader max_samples on a dataset dict caps that source before concat. Use the dict form when several Hub sets are mixed.
{ "evolved_instruction": "- Checkpoint dumping can generate batches efficiently by specifying a batch size and enabling checkpointing if necessary.\n- Disabling checkpointing in smoke tests can prevent unnecessary data duplication and improve performance.", "strategy_applied": "add_constraints", "complexity_notes...
Checkpoints dump generation batches under output_dir/.checkpoints. Re-running the same config resumes instead of repeating completed LLM calls. Disable with enable_checkpoint=False for short Colab smoke tests.
Tell me about the custom API base used by LiteLLM.
LiteLLM is the default generation backend. llm_concurrency is the async worker pool. llm_timeout and llm_max_retries apply per call. Custom api_base points at vLLM or Ollama without changing the rest of the config.
Create an instruction that requires adding two new constraints to the given instruction: 1. It must specify that the instruction should focus specifically on the PDF ingestion process, which involves splitting documents into smaller chunks for QA. 2. The instruction should also mention that it should include a requir...
PDF ingest splits a document into chunks before QA. heading strategy cuts on titles. sentence and fixed strategies use token windows with overlap. OCR is off by default and only needed for scanned pages.
The user wants instructions for creating a specific, complex instruction based on the given source passage.
Ingest can take several Hub datasets, each with its own preprocessing_fn and max_samples. StratifiedSampler then matches target_distribution on source_dataset so one corpus does not drown the mix.
Create a step-by-step guide for downstream training on rejected rows, including the necessary steps to read the passed JSONL data and handle the rejected split.
Rejected rows keep the original text, a rejection_reason, and provenance. Downstream training should read the passed JSONL only. The rejected split is for debugging gates and for a separate Hub dump.
Create a custom instruction using the following passage to guide the user through the process of mapping the input field 'text' onto the output constructed by the pretrain seed JSONL.
Field mapping {'text': 'text'} is required for pretrain seed JSONL. Mapping text onto output made construction_returned_none because the pretrain reader already stored the column as text.
Clone Colab workspace using GH_WORK_TOKEN and optionally HF_TOKEN if not already set.
Colab secrets expected here are GH_WORK_TOKEN, HF_TOKEN, and optionally OPENROUTER_API_KEY. The clone uses branch devrel. uv pip install -e '.[all]' is the editable install used by every notebook.
- Specify the export format (e.g., .jsonl) for each notebook, using options such as alpaca, sharegpt, or dpo. - Set preference defaults (dpo, grpo, ppo) based on user preferences. - Disable the export format default option if desired.
Export format lists are per notebook. QA defaults to alpaca and sharegpt. Preference defaults to dpo. GRPO defaults to grpo and ppo. Turning a format off only skips that JSONL, not the rest of the run.
Create a Colab notebook with a minimum of 10 seed rows for gate training, ensuring sufficient diversity to prevent gate crashes.
A presentable Colab run needs enough seed rows that gates can both keep and drop examples. Three near-identical chunks collapse into an all-pass or all-reject screenshot. Thirty to forty distinct passages avoid that.
CuratorKIT

curatorkit-testrun-Evol

Built using CuratorKIT β€” provenance-grounded curation and synthesis for LLM post-training.

Method evol
Backend litellm
Model openai/Qwen/Qwen2.5-0.5B-Instruct
Formats alpaca
Artifact dataset
Published 2026-08-28 10:03 UTC

Usage

from datasets import load_dataset

ds = load_dataset("ram-lexsi/curatorkit-testrun-Evol", "alpaca")
Downloads last month
36