qleap/Knowledge_distilled_dataset_by_NAGISA_V3

NAGISA_V3 teacher shards

Training data distilled from self-play of the search engine attic reading the NNUE weights NAGISA_V3, in the shape the trainers read directly. Starting from a balanced-opening book, the engine played itself at MultiPV=5, recording the root score and the candidate moves at every ply; manaka-teacher turned that corpus into raw MPK1 streams, and manaka-pack folded identical positions into one row each and wrote these parquet shards.

• Rows: 280,621,202 (records before folding: 300,045,733)
• Shards: 12 (data/teacher-00000.parquet …)
• Total: 21,420,342,433 B

Each shard holds 25,000,000 rows; only the last one carries the remainder of 5,621,202. zstd compression, 8192-row row groups.

How this was generated

This section is the only source for the settings below. They cannot be recovered from the files: the parquet footer states the conventions the converter applied, not the conditions the games were played under.

The side that played the games

search engine	attic
evaluation function	NAGISA_V3 (NNUE)
FV_SCALE	28
search	go nodes 100000, MultiPV 5
move selection	softmax at a temperature of 30 cp; best move from ply 60 on, and whenever a mate was in sight
resignation	four consecutive scores of −3000 or worse from the same side
repetition	the same position (ply excluded) four times is a draw
maximum length	320 ply
opening book	56,326 balanced positions (ply 24 / ply 32)

The engine and the evaluation function are two different things. attic did the searching; NAGISA_V3 is the set of weights it loaded. An earlier version of this card put both on one engine row, and the shards published before 2026-08-28 carry that same conflation in their footer as engine=NAGISA_V3.

FV_SCALE is what makes a centipawn a centipawn. The raw value an NNUE accumulates becomes a score only after division by this number. Read the same weights at the engine default of 16 and every cp here would be 1.75× larger. Before mixing this data with anyone else's, check that this number agrees; teacher data blended across two scales trains on numbers belonging to neither.

The side that converted them

The conversion follows the conventions in manaka-common::card, which both engine families read through, so teacher data built from one corpus is loss-comparable across them.

mate threshold	|cp| ≥ 29,680 (30000 − 320)
value_q	tanh(cp / 1512.173); ±1 for mates
policy	softmax over candidate cp at a temperature of 100 cp
policy (mate positions)	one-hot on the move played

The 320 in the mate threshold is not a round number picked for looks. Mates are stored as ±(30000 − ply), and the generator substitutes the PV length when the search returns a score cp out of range. Measured mates reached ply 315, and 320 is the smallest round value covering that.

The 1512.173 in value_q is dlshogi's 756.0865 doubled. Theirs is calibrated for a [0, 1] sigmoid; putting the same win-rate curve through a tanh into [-1, 1] doubles the coefficient.

Mate positions skip the softmax. Where a mate has been resolved the best move sits tens of thousands of centipawns above the rest, and a softmax over that is not a distribution in any useful sense.

Schema

column	type	meaning
packed	fixed binary (96)	the position; side to move in the last byte
ply	uint16	move number; the lowest one this position was reached at
value_q	float32	search-value target, side-to-move view
weight	uint32	how many searches were folded into the row
candidates	list<struct<mv uint16, prob float32, cp int16>>	the policy

There is no legal-move list and no legality mask. A reader that needs either regenerates it from packed.

There is no outcome column

Earlier revisions of this dataset carried a value_z holding the result of the game each position came from. It has been removed, and the column is absent rather than emptied.

This is teacher data: positions with an evaluation attached. Nothing in that definition says a game was played through them. The fold below is the plain case — the key is the board alone, so one row here is every game that ever reached that board, and asking which of them it "came from" has no answer. A row's targets are the search's, and a search is handed a position, not a route.

Absence is the only spelling a reader cannot mistake for a measurement. 0 reads as a draw. NaN survives every arithmetic it touches, including the (1 − ratio)·z + ratio·q blend that is meant to switch the outcome off at ratio = 1. A column that is not there is read back as "not stated" — the reference trainers give None and Option::None — and the value target is value_q whole.

Nothing else changed. The rows, their order, their row groups and every other column are what the previous revision held; the earlier revision remains reachable by its commit if you want the column back. Self-play corpora, whose positions were played through, do carry an outcome.

What packed holds

96 bytes, manaka_core::pack. The position itself — neither engine's input layer: Manaka's accumulator and DLManaka's input planes are both built from it at load time.

byte
 0..81   the board, one byte per square, in square-index order
81..88   Black's hand, one count per piece kind
88..95   White's hand, same order
    95   side to move, 0 Black / 1 White

Square 0 is 9a and square 80 is 1i: square = (9 − file) × 9 + (rank − 1). A board byte carries the colour in bit 4 (0 Black / 1 White) and the piece kind in the low nibble; an empty square is 0xFF. Hands count pawn, lance, knight, silver, gold, bishop, rook, one byte each.

A candidate is a move, not a label

mv is a move16 — chisaki's move representation, verbatim.

 bit  15 │ 14 │ 13 ──────── 7 │ 6 ──────── 0
      ✗  │ pr │ from or 81+kind │     to

to in bits 0–6, the origin in bits 7–13, promotion in bit 14. A drop puts 81 + hand-index in the origin field, so the dropped kind is readable from the move itself.

Both the policy label and the moving piece derive from the bits alone, so no shogi library is needed to read the shards. This is what made the old layout's label_hash — a guard that the reader's move-generation order still matched the writer's — unnecessary.

The candidate count is the MultiPV width, and it is countable. A row lists the moves the search reported, so a reader that wants the width reads the list rather than trusting a number declared elsewhere. This is why there is no multipv key in the footer any more.

Folding

An identical position is one row. The fold key is the 96 packed bytes alone — not (packed, ply): whether the game reached the board in 40 moves or 48, a search is handed a board, not a route. Records that met the same board through transpositions or across games merge as:

• value_q — the mean over every folded record
• candidates — the union, matched by mv; cp is the mean over the records that listed the move
• ply — the minimum
• weight — the record count; 1 means the position occurred once

prob is computed once, after the fold: a softmax over the mean cp at a temperature of 100 centipawns. Rows containing a mate score (|cp| ≥ 29680) are one-hot on the leading candidate instead.

Key-value metadata

Every shard's parquet footer states the conventions the converter applied. Check them before reading.

key	value
pov	side_to_move
policy_source	softmax_cp
softmax_temp_cp	100
mate_scale	30000
eval_coef	1512.173
fv_scale	28
packed	mailbox position, side to move in the last byte
writer	manaka-pack 0.2.0

The mate threshold is ±(mate_scale − 320); value_q is the score through tanh at eval_coef.

policy_source is also what says there is no outcome column. softmax_cp means the targets came from a search run on a board; visits means a game was played and its result is the one thing it earned. The writer reads no separate flag for the column, so a corpus cannot be published claiming an outcome it does not have.

Every pair here is copied from the stream header or from the converter's own constants — none of it can be typed by hand. There is no flag for adding metadata, deliberately: a key an operator supplies is a key that can disagree with the rows underneath it, and only that operator's memory would ever catch it. Shards published before 2026-08-28 carry three such keys — engine, corpus and multipv — written by an earlier converter that accepted them, and one of the three was wrong. Provenance the stream header has no field for now lives in "How this was generated" above, in one place, in prose that can be read against the rest of the card.

fv_scale reads 0 in those older shards, meaning not stated rather than zero: nothing in this pipeline divides by it. It is carried so that a reader folding several corpora together can refuse a mixture of scales, which is a comparison it can only make when both sides state a number.

Row order

One uniform shuffle over the whole corpus. The fold itself has to be partitioned — it runs one of 32 hash buckets at a time, so that identical boards always meet — but a bucket is a property of the position bytes, and writing the buckets one after another would leave that property standing in the row order. So the folded rows are scattered back across 32 spools chosen uniformly at random, and each spool is loaded and permuted on its own before it is written. Where a row lands depends on nothing about the row.

The permutation is a Fisher–Yates with an unbiased draw, seeded from a constant, so the same streams reproduce the same shards. Deterministic, and still not an order.

No game order, phase or chronology survives. Measured on shard 0: the lag-1 autocorrelation of ply is +0.000376 and its correlation with the row index is −0.000321. Neighbouring rows are not neighbouring plies of a game.

Nor does any block structure. Cut shard 0 into blocks and compare the spread of their mean ply against what independent sampling of that block size would give; a ratio of 1 means nothing survived.

blocks	measured	random	ratio
24	0.03031	0.03627	0.836
250	0.11395	0.11705	0.974
2,500	0.37745	0.37013	1.020

The ratio is itself noisy — its standard deviation is about 1/√(2(blocks−1)), so ±0.15 at 24 blocks and ±0.014 at 2,500 — and every row here sits inside that. An earlier build of this dataset, which wrote the buckets straight out in order, read 2.97 at 24 blocks.

Across the twelve shards the mean ply runs 87.034 to 87.063 against an overall 87.052, on a standard deviation of 37.013. A shard mean has a standard error of 0.0074 at 25,000,000 rows, so that whole spread is sampling.

The trainer can read the shards as they come; no shuffle on the reading side is required.

No quiescence resolution

The positions are the games' positions, as reached — no quiescence search was applied to replace a position with a quiet one before recording. A row can sit in the middle of a capture sequence, and its cp values are the engine's MultiPV search scores of that position itself. A consumer that wants quiet-only positions has to resolve or filter them on its own side.

Train/val

There is no split column, and none is needed. Every row is a unique position — the fold key is the 96 packed bytes, so no position can appear on both sides of any cut — and the rows are uniformly shuffled, so slicing off any fraction is a valid random split at position granularity, the usual practice for NNUE training data. Take it from the tail, the head or the middle; the last shard's mean ply of 87.034 and mean weight of 1.0697 sit against corpus figures of 87.052 and 1.0692.

The corpus behind this

The USI-level corpus these shards were distilled from — positions as sfen strings, candidates as USI move strings — is an earlier revision of this same repository.

ds = load_dataset(
    "qleap/Knowledge_distilled_dataset_by_NAGISA_V3",
    split="train",
    revision="4d50c85ffa0c3b31a1f2c295692a8bf8ac55f11b",
)

That revision is the one before duplicate boards were folded, and it is the input these shards were built from: the fold has to see every record to count weight and to average cp, so the already-folded revision 6b83248f61474872f1ace7d1fea15b70990df116 cannot reproduce them.