Ethosoft/nedo-turkish-65k-tokenized-60b

NEDO Turkish 65K Tokenized FineWeb Corpus - 60.95B Token Snapshot

This dataset is a tokenized Turkish web-text pretraining corpus prepared for the NEDO Turkish SLM project.

It is intended for training decoder-only Turkish language models and reproducing the NEDO Turkish SLM data pipeline. The dataset does not contain raw text files. Instead, it contains binary token shards produced with the NEDO Turkish 65K tokenizer.

Quick summary

• Dataset type: tokenized language-model pretraining corpus
• Language: Turkish
• Source style: FineWeb / FineWeb2 / Common-Crawl-style Turkish web corpus
• Original local source file: finewebtr_combined.jsonl
• Tokenizer: NEDO Turkish Tokenizer
• Tokenizer mode: typed_surface
• Vocabulary size: 65,536
• Binary dtype: uint16
• Total tokens: 60,953,033,328
• Train tokens: 60,366,381,667
• Validation tokens: 586,651,661
• Total binary size: approximately 121.9 GB decimal, about 115 GiB on disk
• Train shards: 16
• Validation shards: 16
• Corrupt/bad shard count in manifest: 0

This release should be understood as a 60.95B-token snapshot of the encoded corpus, not as the full upstream web corpus.

What this dataset contains

The repository contains raw uint16 token arrays:

train/train_part_0000.bin
train/train_part_0001.bin
...
train/train_part_0015.bin

val/val_part_0000.bin
val/val_part_0001.bin
...
val/val_part_0015.bin

metadata/manifest.json

Each .bin file is a flat array of token IDs. It can be read with NumPy as a memory-mapped uint16 array.

What this dataset does not contain

This dataset does not include:

• raw HTML
• raw Common Crawl WARC files
• raw cleaned text
• document boundaries
• URLs or metadata for individual documents
• tokenizer source files
• model checkpoints

It is a tokenized binary corpus snapshot for language-model pretraining.

Tokenizer

The corpus was encoded with the NEDO Turkish Tokenizer.

Tokenizer configuration:

• vocab_size: 65536
• token_mode: typed_surface
• dtype: uint16
• special tokens: pad, bos, eos, unk

Because token IDs are stored as uint16, downstream users should load the binary files with dtype uint16.

Example:

import numpy as np

tokens = np.memmap(
    "train/train_part_0000.bin",
    dtype=np.uint16,
    mode="r",
)

print("Number of tokens:", len(tokens))
print("First 20 token ids:", tokens[:20])

File-level statistics

The exact file sizes are also stored in metadata/manifest.json.

Training shards

File	Tokens	Approx. size
train/train_part_0000.bin	3,773,551,647	7.55 GB
train/train_part_0001.bin	3,774,173,573	7.55 GB
train/train_part_0002.bin	3,766,122,494	7.53 GB
train/train_part_0003.bin	3,770,485,820	7.54 GB
train/train_part_0004.bin	3,779,485,470	7.56 GB
train/train_part_0005.bin	3,776,738,563	7.55 GB
train/train_part_0006.bin	3,741,697,902	7.48 GB
train/train_part_0007.bin	3,770,050,646	7.54 GB
train/train_part_0008.bin	3,785,291,031	7.57 GB
train/train_part_0009.bin	3,769,850,121	7.54 GB
train/train_part_0010.bin	3,784,696,549	7.57 GB
train/train_part_0011.bin	3,777,305,750	7.55 GB
train/train_part_0012.bin	3,776,274,413	7.55 GB
train/train_part_0013.bin	3,771,660,162	7.54 GB
train/train_part_0014.bin	3,771,426,423	7.54 GB
train/train_part_0015.bin	3,777,571,103	7.56 GB

Training total: 60,366,381,667 tokens.

Validation shards

File	Tokens	Approx. size
val/val_part_0000.bin	36,011,554	72.02 MB
val/val_part_0001.bin	36,023,044	72.05 MB
val/val_part_0002.bin	38,067,404	76.13 MB
val/val_part_0003.bin	36,103,430	72.21 MB
val/val_part_0004.bin	38,114,831	76.23 MB
val/val_part_0005.bin	36,021,072	72.04 MB
val/val_part_0006.bin	36,022,859	72.05 MB
val/val_part_0007.bin	38,029,369	76.06 MB
val/val_part_0008.bin	38,021,458	76.04 MB
val/val_part_0009.bin	36,020,964	72.04 MB
val/val_part_0010.bin	36,042,847	72.09 MB
val/val_part_0011.bin	36,019,253	72.04 MB
val/val_part_0012.bin	36,022,273	72.04 MB
val/val_part_0013.bin	36,092,029	72.18 MB
val/val_part_0014.bin	36,023,451	72.05 MB
val/val_part_0015.bin	38,015,823	76.03 MB

Validation total: 586,651,661 tokens.

Example: creating a simple token stream loader

import numpy as np
from pathlib import Path

root = Path(".")
train_files = sorted((root / "train").glob("train_part_*.bin"))

arrays = [
    np.memmap(path, dtype=np.uint16, mode="r")
    for path in train_files
]

print("Number of train shards:", len(arrays))
print("Tokens in first shard:", len(arrays[0]))

For large-scale training, users will usually want to sample chunks from these memmaps rather than load the full dataset into RAM.

Example: random block sampling

import numpy as np
from pathlib import Path

block_size = 1024
rng = np.random.default_rng(42)

shard_path = Path("train/train_part_0000.bin")
tokens = np.memmap(shard_path, dtype=np.uint16, mode="r")

start = rng.integers(0, len(tokens) - block_size - 1)
x = tokens[start : start + block_size]
y = tokens[start + 1 : start + block_size + 1]

print(x.shape, y.shape)

Relationship to FineWeb

FineWeb is a large-scale web dataset family introduced in the paper:

The FineWeb Datasets: Decanting the Web for the Finest Text Data at Scale

The upstream FineWeb work studies high-quality web-data curation for language-model pretraining and releases large Common-Crawl-derived corpora and curation code.

This NEDO release is not the original FineWeb dataset. It is a Turkish tokenized derivative/snapshot prepared for Turkish SLM pretraining experiments.

OpenReview:

https://openreview.net/forum?id=jRUZXaQYDv

OpenReview PDF:

https://openreview.net/pdf?id=jRUZXaQYDv

arXiv:

https://arxiv.org/abs/2406.17557

Citation

If you use this dataset, please cite the FineWeb paper and mention the NEDO Turkish tokenization/preprocessing pipeline.

@misc{penedo2024fineweb,
  title={The FineWeb Datasets: Decanting the Web for the Finest Text Data at Scale},
  author={Guilherme Penedo and Hynek Kydlíček and Loubna Ben Allal and Anton Lozhkov and Margaret Mitchell and Colin Raffel and Leandro von Werra and Thomas Wolf},
  year={2024},
  eprint={2406.17557},
  archivePrefix={arXiv},
  primaryClass={cs.CL},
  url={https://arxiv.org/abs/2406.17557}
}

Suggested dataset attribution:

NEDO Turkish 65K Tokenized FineWeb Corpus - 60.95B Token Snapshot.
Tokenized with the NEDO Turkish 65K typed_surface tokenizer.
Released by Ethosoft for Turkish SLM pretraining research.

License

This dataset card uses the odc-by license tag.

The upstream FineWeb/FineWeb2-style data is derived from web crawl data and is subject to the licenses and terms of the upstream sources, including Common Crawl terms where applicable.

Users are responsible for ensuring that their use complies with applicable law, third-party rights, privacy rights, copyright, and the terms of the upstream data sources.

Intended use

This dataset is intended for:

• Turkish language model pretraining
• small language model research
• tokenizer research
• reproducibility of the NEDO Turkish SLM experiments
• studying Turkish web-corpus tokenization at scale

Out-of-scope use

This dataset is not intended for:

• reconstructing or redistributing raw web text
• identifying individuals or extracting private information
• high-stakes deployment without additional filtering and evaluation
• claiming that this is the complete original FineWeb corpus
• direct human-readable text analysis without a compatible tokenizer

Known limitations

• This is a tokenized binary dataset, not raw text.
• The release is a 60.95B-token snapshot, not the full upstream corpus.
• Some noisy, duplicated, outdated, biased, or sensitive web content may remain from the upstream crawl.
• Document boundaries and original URLs are not included in this binary snapshot.
• Users need a compatible NEDO Turkish tokenizer to decode or train conveniently.
• The exact upstream source snapshot should be verified by downstream users if strict provenance tracking is required.

Provenance note

The local preprocessing pipeline used a Turkish FineWeb-style combined JSONL source and encoded it into uint16 token shards with the NEDO Turkish 65K tokenizer.

The final manifest reports:

• 32 binary shard files
• 16 train shards
• 16 validation shards
• 60,953,033,328 total tokens
• 0 bad/corrupt files

Contact

For questions about this dataset, tokenizer compatibility, or the NEDO Turkish SLM project, please open a discussion on this dataset repository.