rycerzes/atarashi-dataset

Atarashi License Identification Dataset

Multi-class dataset for Atarashi — FOSSology's license identification agent, which answers "which license is this text?" across 3,015 license classes.

This is the second stage of a two-stage pipeline. Nirjas gates whether a text is license text at all; Atarashi then identifies which license.

source file → Nirjas gate → [license_related] → Atarashi (which license?)

⚠️ This is training data, not a benchmark

Do not report Recall@k on the test split as a license-identification result. It will look excellent and mean almost nothing.

The fragments were produced by sliding-window splitting of license texts. When you then match them against a reference index of those same license texts, 85.6% of test fragments are verbatim substrings of their own license's reference text (measured: 1,289 / 1,506 fragments whose license has a reference). Retrieval on this split largely measures substring lookup, not identification.

This is not fixable by cleaning. Leakage lives inside a dataset and dedup removes it (this build has zero cross-split overlap). Circularity lives between the queries and the index — the query text was cut out of the document it is scored against. The de-leaking pass moved circularity only 91.2% → 85.6%.

Use these instead for measuring identification quality:

benchmark	what it measures	why it's honest
SPDX-tag eval	real file headers, tag stripped	ground truth is the author-declared SPDX-License-Identifier:, independent of any matcher
Cross-rendering eval	ScanCode index vs FOSSology text	same license, two independently transcribed renderings — a hit means recognition, not retrieval

Both live in Minerva-Dataset-Generation PR #6:

uv sync --extra eval
uv run src/run_eval.py spdx-tag --per-lang 0 --max-per-license 150
uv run src/run_eval.py crossref --query-mode full

For reference, the lexical baseline scores macro-R@1 ≈ 0.65 on the SPDX-tag eval's answerable regime and R@1 0.79 on the cross-rendering divergent tier. With an abstention threshold calibrated on measured negatives (run_eval.py cascade --tau 0.30) it answers 59% of answerable queries at 0.924 precision, while falsely answering only 1.1% of the no-signal ones.

One finding from that work matters for anyone using this data: on real source files carrying an SPDX tag, 72% have no license prose at all once the tag is stripped — just a copyright line and code. For those the correct output is UNKNOWN, not a guess. This dataset contains no such abstention examples.

Dataset Summary

split	rows	distinct licenses
train	25,119	3,015
validation	1,729	1,083
test	1,643	1,026
total	28,491	3,015

Splits are content-hash frozen — a text always lands in the same split across rebuilds, so benchmark deltas are real and duplicates cannot leak across splits. Every label present in validation/test is also present in train.

Dataset Structure

Columns

• license_key — the license identifier (ScanCode key or FOSSology shortname), e.g. apache-2.0, mit, gpl-2.0
• text — the license text fragment
• source — provenance: scancode, fossology, synthetic

Sources (train)

source	count	origin
scancode	16,730	ScanCode LicenseDB license texts
synthetic	6,363	LLM augmentation for rare licenses
fossology	2,026	FOSSology licenseRef.json

Text lengths (train)

min 36 · median 510 · p90 1,064 · max 90,035 characters.

Class Distribution

Heavily long-tailed, as the real license space is:

• 3,015 classes in train
• 426 classes with exactly 1 example
• 912 classes with ≤ 3 examples

Any evaluation should report macro metrics. A micro average is dominated by whichever licenses happen to be frequent and will move when the class mix changes rather than when quality does.

Provenance and Cleaning

Built by the Minerva dataset pipeline:

1. Fetch license texts from ScanCode LicenseDB + FOSSology licenseRef.json
2. Sliding-window split with junk-fragment filtering
3. LLM-assisted augmentation for rare licenses
4. Content-hash frozen train/val/test split, per-license, with a learnability guard

Split hygiene (src/exporter/cleaning.py) runs inside the export, so the pipeline emits this build directly:

• MinHash (Jaccard ≥ 0.8) cross-split near-dedup, train-priority
• Short-fragment quarantine on the evaluation splits (test min length 63 chars)
• Train kept whole to preserve label coverage — no license lost

It is also runnable standalone (uv run src/exporter/cleaning.py) to clean an export produced before that was wired in — which is how this build was made.

Verified on this build: 0 / 1,729 validation and 0 / 1,643 test rows have text that also appears in train.

Usage

from datasets import load_dataset

ds = load_dataset("rycerzes/atarashi-dataset")
train = ds["train"]

Intended Use

Suitable for: training license classifiers/retrievers; evaluating how well a model identifies a license from an arbitrary body excerpt (a real capability — LICENSE file chunks, partial texts); as a source of per-license text for building reference indexes.

Not suitable for: benchmarking identification accuracy (see the warning above); as training data for a residual reranker — the residual case is paraphrased notices a lexical cascade already failed on, whereas ~86% of this data is verbatim body slices, the register a cascade handles natively.

Related

• rycerzes/nirjas-dataset — the upstream binary gate
• FOSSology Atarashi — the license identification agent
• FOSSology Nirjas — comment extraction + gate