Arko007/Zenyx-100M-SFT-data

Zenyx 100M SFT Pre-Tokenized Binary Shards

Zero-Overhead High-Throughput Binary Training Shards for Zenyx-100M & Zenyx-Mini

149,571 Packed Sequences • 208.2 Million Trained Tokens • 15-Source Balanced Mixture • Context Window: 2,049 • Apache-2.0

---

🧭 Zenyx SFT Dataset Family: Which Dataset Should You Use?

The Zenyx SFT project provides three specialized datasets tailored for different stages of the alignment and training lifecycle. Use the matrix and decision guide below to navigate directly to the dataset that best fits your workflow:

Dataset	Primary Format	Volume & Tokens	Curation & Filtration	Best Suited For
Arko007/zenyx-sft-v2 (Curated SFT Dataset)	Clean Parquet (train & val splits)	191,002 conversations (~29.1M tokens)	Strictly Audited & Curated 34k+ substandard rows pruned; verified tools & <think> tags	Standard SFT & Fine-Tuning Fine-tuning any LLM on multi-turn dialogue, agentic tools, and customizable system prompts.
Arko007/Zenyx-100M-SFT-synth (Raw Generation Archive)	JSONL & JSON (21,976 files)	209k accepted + 114k rejected rows (~41M tokens)	Raw Generation & Provenance Contains raw accepted chunks, local/frontier repairs, and detailed rejection audit logs	Synthetic Data Research Studying LLM failure modes, data filtering pipelines, and generator telemetry across 98+ compute hours.
Arko007/Zenyx-100M-SFT-data (📍 You are here • Pre-Tokenized Binary Shards)	NumPy .npz (19 binary shards)	149,571 sequences of 2,049 tokens (208.2M trained tokens)	Pre-Tokenized & Loss-Masked 15-source balanced mixture; ready-to-train ids (int32) & mask (uint8)	High-Throughput GPU Training Direct, zero-CPU-overhead training of Zenyx-100M / BPE models with pre-computed cross-entropy loss masks.

🎯 Quick Navigation Decision Guide

• 🚀 If you want to train or fine-tune an LLM on clean, curated, and validated multi-turn dialogue & agentic tools: 👉 Go to Arko007/zenyx-sft-v2 (Clean Parquet format, 45 domains, drop-in ready for Hugging Face Trainer / SFT trainers).
• 🔬 If you are researching synthetic data generation, failure modes, prompt adherence, or want raw JSONL generation traces & negative rejection logs: 👉 Go to Arko007/Zenyx-100M-SFT-synth (Full provenance archive with 114k+ logged rejections across Qwen-3.5 and Spark-X2.6).
• ⚡ If you want maximum GPU training throughput with zero tokenization overhead for Zenyx-100M / BPE models: 👉 Go to Arko007/Zenyx-100M-SFT-data (Pre-tokenized NumPy .npz binary shards with pre-computed loss masks across 15 sources).

---

⚡ Pre-Tokenized Binary Shard Dataset Notice

This repository contains 19 pre-tokenized NumPy binary shards (shard-00000.npz – shard-00018.npz) formatted specifically for high-throughput GPU training of Zenyx-100M and Zenyx-Mini with zero tokenization overhead during training loops.

• Format: NumPy .npz archives containing integer token arrays (ids, int32) and loss masks (mask, uint8).
• Sequence Length: Fixed 2,049 tokens per sequence (2,048 context length + 1 next-token target).
• Identity Grounding: A 1.0% partition (identity) and 4.0% partition (zenyx_synth) embed native identity bindings for Zenyx-Mini (nickname Nini) with loss masking enabled over assistant responses.

Looking for Raw Text / JSONL Data? If you want raw JSON/JSONL conversations to inspect individual dialogue turns or adapt system prompts for other LLM personas, please refer to:

• Arko007/zenyx-sft-v2: Clean, deduplicated, 45-domain Parquet SFT dataset.
• Arko007/Zenyx-100M-SFT-synth: Complete synthetic generation archive with 114k+ failure/rejection traces.

---

Dataset Overview & Key Metrics

Arko007/Zenyx-100M-SFT-data is the pre-tokenized alignment corpus used to fine-tune the Zenyx language models. It merges 15 high-quality instruction, multi-turn reasoning, programming, mathematical problem-solving, and agentic tool-use sources into balanced, packed 2,049-token sequences.

Metric	Value
Total Shards	19 NumPy archives (shard-00000.npz to shard-00018.npz)
Total Dataset Size	1.43 GB (uncompressed arrays: ~1.53 GB)
Total Packed Sequences	149,571 sequences
Tokens Trained (Masked Target Tokens)	208,226,029 tokens (~208.2 Million)
Context Window Size	2,049 tokens (2,048 sequence + 1 target)
Vocabulary Size	Up to 49,152 tokens (matches Zenyx BPE tokenizer)
Tokenizer Hash (SHA-256)	d0b8b6f4cbf992cb05e3fb64df2b87f14abbceaaa6d15c7714fac8bf7c53043c
Pipeline Code Hash (SHA-256)	14dcac6f9908d0e97c517412bd8386c61534e8715fc5200c733fb219e57e7161
License	Apache 2.0

---

15-Source Mixture Distribution

The training mixture was carefully weighted across 15 diverse capabilities to prevent catastrophic forgetting and maintain strong reasoning, coding, and natural dialogue:

Source Identifier	Mixture Share	Upstream Origin / Benchmark	Capability / Focus Area
smoltalk	26.0%	HuggingFaceTB/smoltalk	Broad multi-turn dialogue, conversational fluency, and open-domain instruction
tulu3	15.0%	allenai/tulu-3-sft-mixture	Rigorous instruction following, negative constraints, and safety alignment
mot_science	10.0%	open-r1/Mixture-of-Thoughts	Chain-of-thought scientific reasoning, deductions, and structured logic
arith_levels	9.0%	Synthetic Tiered Arithmetic	Multi-tier arithmetic operations ranging from basic arithmetic to advanced calculations
arith_multi_mixed	7.0%	Synthetic Multi-Step Arithmetic	Chained multi-operator arithmetic with order-of-operations compliance
hierarchy	5.0%	Synthetic Structured Parsing	Hierarchical relation extraction, trees, and nested schema parsing
math_sft	5.0%	nvidia/Nemotron-SFT-Math-v3	Formal mathematical derivations, step-by-step proofs, and algebra
opc1_realuser	5.0%	OpenCoder-LLM/opc-sft-stage1	Authentic real-user programming queries across Python, C++, JS, and Shell
zenyx_synth	4.0%	Arko007/zenyx-v3-synthetic-sft-v4	High-density synthetic function calling, tool responses, and reasoning
arith_sagheer	4.0%	SagheerLab/Arithmetic-Reasoning	Mathematical word problem solving with natural language reasoning steps
tool_calc	3.0%	Synthetic Tool Execution	Calculator tool invocations (TOOL: {"name": "calculator"}) with execution feedback
mot_math	2.0%	open-r1/Mixture-of-Thoughts	Deep mathematical reasoning traces with intermediate thinking tokens
opc2_edu	2.0%	OpenCoder-LLM/opc-sft-stage2	Educational programming tutorials, algorithms, and data structure implementations
cardano	2.0%	decimalist/cardano	Cryptographic verification, decentralized protocol concepts, and precision logic
identity	1.0%	Synthetic Persona Grounding	Zenyx-Mini / Nini identity grounding, conversational etiquette, and persona boundaries

---

Shard Format & Internal Structure

Each shard is saved as a compressed NumPy .npz file containing exactly two arrays:

data = np.load("shard-00000.npz")
ids = data["ids"]    # shape: (N, 2049), dtype: int32
mask = data["mask"]  # shape: (N, 2049), dtype: uint8

• ids (int32, shape: [N, 2049]): Contiguous sequence of token IDs produced by the Zenyx BPE tokenizer (vocab size up to 49,152).
• mask (uint8, shape: [N, 2049]): Binary loss mask where:
  • 0: Prompt tokens, user messages, system instructions, and padding (loss is zeroed out during backpropagation).
  • 1: Assistant response tokens and tool call tokens (cross-entropy loss is computed and backpropagated).

Metadata & Manifest Files

• meta.json: Global dataset telemetry, context window (2049), sequence count (149,571), total trained tokens (208,226,029), component shares, and per-source effort distributions.
• manifest_sft.json: Exact upstream git commit revisions, file lists, and data format specifications for all 10 external upstream repositories.
• state.json: Checkpoint reader states, shard positions, synthesis counters, and epoch counts across all constituent sources.

---

High-Throughput PyTorch DataLoader Example

To stream and train with these binary shards with zero CPU tokenization overhead:

import glob
import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
from huggingface_hub import hf_hub_download

class ZenyxShardDataset(Dataset):
    def __init__(self, shard_path):
        data = np.load(shard_path)
        self.ids = data["ids"]    # shape (N, 2049)
        self.mask = data["mask"]  # shape (N, 2049)

    def __len__(self):
        return len(self.ids)

    def __getitem__(self, idx):
        # Input sequence: tokens 0 to 2047
        # Target sequence: tokens 1 to 2048 (next-token prediction)
        input_ids = torch.from_numpy(self.ids[idx, :-1].astype(np.int64))
        target_ids = torch.from_numpy(self.ids[idx, 1:].astype(np.int64))
        loss_mask = torch.from_numpy(self.mask[idx, 1:].astype(np.float32))
        
        return {
            "input_ids": input_ids,
            "target_ids": target_ids,
            "loss_mask": loss_mask
        }

# Download and load shard 0
shard_file = hf_hub_download(
    repo_id="Arko007/Zenyx-100M-SFT-data",
    filename="shard-00000.npz",
    repo_type="dataset"
)

dataset = ZenyxShardDataset(shard_file)
loader = DataLoader(dataset, batch_size=8, shuffle=True)

for batch in loader:
    input_ids = batch["input_ids"]    # [8, 2048]
    target_ids = batch["target_ids"]  # [8, 2048]
    loss_mask = batch["loss_mask"]    # [8, 2048]
    
    # Compute masked cross entropy loss:
    # loss = (cross_entropy(logits, target_ids, reduction='none') * loss_mask).sum() / loss_mask.sum()
    break

---

License & Citation

This pre-tokenized dataset is released under the Apache 2.0 License.

@dataset{zenyx_100m_sft_data_2026,
  author       = {Arko and Zenyx AI Contributors},
  title        = {Zenyx 100M SFT Pre-Tokenized Binary Shards},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/Arko007/Zenyx-100M-SFT-data}}
}