| """Read-only efficiency audit of frozen vocabulary and source/work-balanced text samples.""" |
| import argparse |
| import collections |
| import hashlib |
| import json |
| import math |
| from pathlib import Path |
| import sqlite3 |
| import time |
| import unicodedata |
|
|
| from sentencepiece_unigram import Tokenizer |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DATA = ROOT / 'unified/training-tokens-v1/build-006' |
| MODEL = ROOT / 'runs/classical-smollm2-trunk/export/tokenizer.model' |
|
|
|
|
| def sha(path): |
| h = hashlib.sha256() |
| with open(path, 'rb') as f: |
| for b in iter(lambda: f.read(1 << 20), b''): |
| h.update(b) |
| return h.hexdigest() |
|
|
|
|
| def write(path, value): |
| Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + '\n') |
|
|
|
|
| def rank(value): |
| return hashlib.sha256(('efficiency-20261027:' + value).encode()).hexdigest() |
|
|
|
|
| def category(text): |
| if text.isspace(): |
| return 'whitespace' |
| if all(unicodedata.category(c)[0] in 'PS' for c in text): |
| return 'punctuation_symbols' |
| if all(('\u3400' <= c <= '\u9fff') or ('\U00020000' <= c <= '\U000323af') or ('\uf900' <= c <= '\ufaff') for c in text): |
| return 'kanji_only' |
| if all('\u3040' <= c <= '\u30ff' for c in text): |
| return 'kana_only' |
| if any('\u3040' <= c <= '\u30ff' for c in text): |
| return 'contains_kana_mixed' |
| return 'other' |
|
|
|
|
| class MinimumTokens: |
| """Exact shortest reversible token sequence with current regular/byte pieces. |
| |
| This is a compression bound, not the probability-optimal Unigram objective. |
| Whitespace uses the model's existing identity normalizer and U+2581 rule. |
| """ |
| def __init__(self, tokenizer): |
| self.tokenizer = tokenizer |
| self.trie = {} |
| sp = tokenizer.sp |
| self.byte_ids = [sp.piece_to_id(f'<0x{i:02X}>') for i in range(256)] |
| for i in range(sp.vocab_size()): |
| if sp.is_byte(i) or sp.is_control(i) or sp.is_unknown(i) or sp.is_unused(i): |
| continue |
| surface = sp.id_to_piece(i).replace('▁', ' ') |
| if not surface: |
| continue |
| node = self.trie |
| for c in surface: |
| node = node.setdefault(c, {}) |
| node[None] = i |
|
|
| def encode(self, text): |
| n = len(text) |
| costs = [10**9] * (n + 1) |
| previous = [None] * (n + 1) |
| costs[0] = 0 |
| for start in range(n): |
| |
| fallback = [self.byte_ids[b] for b in text[start].encode()] |
| if costs[start] + len(fallback) < costs[start + 1]: |
| costs[start + 1] = costs[start] + len(fallback) |
| previous[start + 1] = (start, fallback) |
| node = self.trie |
| end = start |
| while end < n and text[end] in node: |
| node = node[text[end]] |
| end += 1 |
| if None in node and costs[start] + 1 < costs[end]: |
| costs[end] = costs[start] + 1 |
| previous[end] = (start, [node[None]]) |
| parts, end = [], n |
| while end: |
| begin, ids = previous[end] |
| parts.append(ids) |
| end = begin |
| ids = [i for part in reversed(parts) for i in part] |
| if self.tokenizer.decode(ids) != text: |
| raise ValueError('Minimum-token path does not round-trip') |
| return ids |
|
|
|
|
| def select(): |
| groups = collections.defaultdict(list) |
| with (DATA / 'splits.jsonl').open() as f: |
| for line in f: |
| row = json.loads(line) |
| if row['split'] in ('train', 'validation'): |
| groups[row['source'], row['split'], row['group']].append(row) |
| by_partition = collections.defaultdict(list) |
| for (source, split, group), rows in groups.items(): |
| by_partition[source, split].append((group, min(rows, key=lambda r: rank(r['id'])))) |
| selected = [] |
| for partition in sorted(by_partition): |
| works = sorted(by_partition[partition], key=lambda p: rank(p[0]))[:128] |
| selected.extend(row for _, row in works) |
| return selected |
|
|
|
|
| def summarize(rows): |
| counts = collections.Counter() |
| for row in rows: |
| for key in ('characters', 'nonwhitespace_characters', 'tokens', 'regular_tokens', |
| 'one_character_regular_tokens', 'one_character_content_tokens', |
| 'content_regular_tokens', 'byte_tokens', 'newline_byte_tokens', 'unknown_tokens', |
| 'minimum_tokens', 'no_lf_tokens', 'newline_characters'): |
| counts[key] += row[key] |
| chars, tokens = counts['characters'], counts['tokens'] |
| cpt = sorted(r['characters']/r['tokens'] for r in rows) |
| return dict(samples=len(rows), works=len({r['group'] for r in rows}), **dict(counts), |
| characters_per_token=chars/tokens, tokens_per_100_characters=100*tokens/chars, |
| median_document_characters_per_token=cpt[len(cpt)//2], |
| p10_document_characters_per_token=cpt[int((len(cpt)-1)*.1)], |
| p90_document_characters_per_token=cpt[int((len(cpt)-1)*.9)], |
| one_character_regular_fraction=counts['one_character_regular_tokens']/max(1, counts['regular_tokens']), |
| one_character_content_fraction=counts['one_character_content_tokens']/max(1, counts['content_regular_tokens']), |
| byte_token_fraction=counts['byte_tokens']/tokens, |
| non_lf_byte_fraction=(counts['byte_tokens']-counts['newline_byte_tokens'])/tokens, |
| minimum_token_reduction_fraction=1-counts['minimum_tokens']/tokens, |
| no_lf_token_reduction_fraction=1-counts['no_lf_tokens']/tokens) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--output', default='runs/tokenization-efficiency-audit-002') |
| args = parser.parse_args() |
| output = ROOT / args.output |
| output.mkdir(exist_ok=False) |
| started = time.monotonic() |
| tok = Tokenizer(MODEL) |
| sp = tok.sp |
| manifest = json.loads((DATA / 'manifest.json').read_text()) |
| assert sha(MODEL) == manifest['tokenizer_sha256'] |
| optimal = MinimumTokens(tok) |
| selected = select() |
| rows = [] |
| usage = collections.defaultdict(collections.Counter) |
| examples = [] |
| db = sqlite3.connect('file:' + str(ROOT / 'unified/pretrain-v1/build-002/build.sqlite3') + '?mode=ro', uri=True) |
| newline_id = sp.piece_to_id('<0x0A>') |
| with (output / 'samples.jsonl').open('w') as f: |
| for index, r in enumerate(selected): |
| document = db.execute('SELECT text FROM units WHERE id=?', (r['id'],)).fetchone()[0] |
| assert hashlib.sha256(document.encode()).hexdigest() == r['text_sha256'] |
| start = max(0, (len(document)-2048)//2) |
| text = document[start:start+2048] |
| ids = tok.encode(text) |
| assert ids and tok.decode(ids) == text |
| shortest = optimal.encode(text) |
| assert len(shortest) <= len(ids) |
| no_lf = tok.encode(text.replace('\n', '')) |
| regular = [sp.id_to_piece(i).replace('▁', ' ') for i in ids if not sp.is_byte(i) and not sp.is_control(i) and not sp.is_unknown(i)] |
| content = [p for p in regular if category(p) not in ('whitespace', 'punctuation_symbols')] |
| row = dict(source=r['source'], split=r['split'], id=r['id'], group=r['group'], |
| title=r['title'], era=r['era'], text_sha256=r['text_sha256'], start=start, end=start+len(text), |
| characters=len(text), nonwhitespace_characters=sum(not c.isspace() for c in text), tokens=len(ids), |
| regular_tokens=len(regular), one_character_regular_tokens=sum(len(p)==1 for p in regular), |
| content_regular_tokens=len(content), one_character_content_tokens=sum(len(p)==1 for p in content), |
| byte_tokens=sum(sp.is_byte(i) for i in ids), newline_byte_tokens=ids.count(newline_id), |
| unknown_tokens=ids.count(0), minimum_tokens=len(shortest), no_lf_tokens=len(no_lf), |
| newline_characters=text.count('\n'), roundtrip_exact=True) |
| rows.append(row) |
| f.write(json.dumps(row, ensure_ascii=False) + '\n') |
| usage[r['source']].update(ids) |
| if r['source'] == 'wikisource': |
| examples.append(dict(id=r['id'], split=r['split'], title=r['title'], |
| original_tokens=len(ids), minimum_tokens=len(shortest), |
| gain=1-len(shortest)/len(ids), text=text[:256], |
| first_128_characters=text[:128], |
| current_pieces=[sp.id_to_piece(i) for i in tok.encode(text[:128])], |
| minimum_pieces=[sp.id_to_piece(i) for i in optimal.encode(text[:128])])) |
| if (index+1) % 100 == 0: |
| print(json.dumps(dict(samples=index+1, total=len(selected), seconds=time.monotonic()-started)), flush=True) |
| db.close() |
| report = {'by_source': {}, 'by_source_split': {}, 'wikisource_by_era': {}} |
| for source in sorted({r['source'] for r in rows}): |
| report['by_source'][source] = summarize([r for r in rows if r['source']==source]) |
| for split in ('train', 'validation'): |
| rs = [r for r in rows if r['source']==source and r['split']==split] |
| if rs: |
| report['by_source_split'][source+'/'+split] = summarize(rs) |
| for era in sorted({r['era'] for r in rows if r['source']=='wikisource'}): |
| report['wikisource_by_era'][era] = summarize([r for r in rows if r['source']=='wikisource' and r['era']==era]) |
| |
| styles = json.loads((ROOT / 'runs/pretrain-generation-comparison-001/cases.json').read_text()) |
| report['reviewed_styles'] = [] |
| for case in styles: |
| text = case['prompt'] + case['reference'] |
| ids = tok.encode(text) |
| shortest = optimal.encode(text) |
| report['reviewed_styles'].append(dict(id=case['id'], source=case['source'], title=case['title'], |
| style=case['style'], characters=len(text), tokens=len(ids), minimum_tokens=len(shortest), |
| characters_per_token=len(text)/len(ids), minimum_token_reduction_fraction=1-len(shortest)/len(ids))) |
| vocab = collections.Counter() |
| for i in range(sp.vocab_size()): |
| if sp.is_byte(i): |
| vocab['byte'] += 1 |
| elif sp.is_control(i) or sp.is_unknown(i): |
| vocab['special'] += 1 |
| else: |
| surface = sp.id_to_piece(i).replace('▁', ' ') |
| vocab[category(surface)] += 1 |
| vocab['single_character' if len(surface)==1 else 'multiple_characters'] += 1 |
| sampling = json.loads((ROOT / 'unified/tokenizer-v1/build-001/sampling.json').read_text()) |
| total = sum(r['sampled_characters'] for r in sampling['by_source'].values()) |
| report['tokenizer_training_sample_character_shares'] = {s:r['sampled_characters']/total for s,r in sampling['by_source'].items()} |
| report['vocabulary_categories_overlapping_length_counts'] = dict(vocab) |
| report['top_one_character_content_pieces'] = {} |
| for source, counts in usage.items(): |
| report['top_one_character_content_pieces'][source] = [dict(piece=sp.id_to_piece(i), id=i, count=n) |
| for i,n in counts.most_common() if not sp.is_byte(i) and len(sp.id_to_piece(i))==1 |
| and category(sp.id_to_piece(i)) not in ('whitespace', 'punctuation_symbols')][:30] |
| write(output / 'report.json', report) |
| write(output / 'wikisource-examples.json', sorted(examples, key=lambda e:e['gain'], reverse=True)) |
| write(output / 'manifest.json', dict(complete=True, source_splits=['train','validation'], test_read=False, |
| selection='128 groups per source/split by fixed SHA256 rank, one document per group, middle up to 2048 Unicode characters', |
| tokenizer_sha256=sha(MODEL), script_sha256=sha(__file__), splits_sha256=sha(DATA/'splits.jsonl'), |
| samples=len(rows), independent_global_groups=len({r['group'] for r in rows}), |
| roundtrip_matches=len(rows), unknown_tokens=sum(r['unknown_tokens'] for r in rows), |
| minimum_paths_verified=len(rows), elapsed_seconds=time.monotonic()-started, |
| caveat='Tokenizer predates LLM splitting; samples are not tokenizer-unseen. Compression bound does not optimize language-model quality.')) |
| lines = ['# トークナイズ分割効率の診断', '', |
| f'{len(rows)}出典内作品サンプル（独立global groupは{len({r["group"] for r in rows})}）から各1レコードの中央最大2,048文字を採用。train/validationのみ。tokenizerは作品分割より前に作成済みなので、tokenizer未知作品への評価ではない。', '', |
| '| 出典 | 作品数 | 文字/token ↑ | 100文字のtoken数 ↓ | 内容token中の1文字比 | byte比 | byte比（LF以外） | 同一語彙での最短化削減率 |', |
| '|---|---:|---:|---:|---:|---:|---:|---:|'] |
| for s,r in report['by_source'].items(): |
| lines.append(f"| {s} | {r['samples']} | {r['characters_per_token']:.3f} | {r['tokens_per_100_characters']:.1f} | {r['one_character_content_fraction']:.1%} | {r['byte_token_fraction']:.2%} | {r['non_lf_byte_fraction']:.2%} | {r['minimum_token_reduction_fraction']:.3%} |") |
| lines += ['', '文字/tokenはUnicode文字数（空白・改行を含む）÷本文token数。BOS/EOS/PADを除外。内容tokenは通常語彙のうち空白・句読点・記号だけのpieceを除いたもの。語の正しさを測る指標ではない。', '', |
| '最短化は現行32,000語彙の通常pieceとUTF-8 byte piecesだけで原文を完全復元する最少token列を動的計画法で計算した比較上限。全サンプルで復元一致を確認した。Unigramの確率を最大化する通常encodeとは目的が違い、最短分割を既存LLMへそのまま入力する提案ではない。', '', |
| '## train/validation別', '', '| 区分 | 作品数 | 文字/token | 同一語彙最短化削減率 |', '|---|---:|---:|---:|'] |
| for k,r in report['by_source_split'].items(): |
| lines.append(f"| {k} | {r['samples']} | {r['characters_per_token']:.3f} | {r['minimum_token_reduction_fraction']:.3%} |") |
| lines += ['', '## 固定文体例', '', '| 作品・文体 | 文字数 | token数 | 文字/token | 同一語彙最短化削減率 |', '|---|---:|---:|---:|---:|'] |
| for r in report['reviewed_styles']: |
| lines.append(f"| {r['title']}・{r['style']} | {r['characters']} | {r['tokens']} | {r['characters_per_token']:.3f} | {r['minimum_token_reduction_fraction']:.3%} |") |
| lines += ['', '## 改行の診断', '', '| 出典 | LF文字数 | LF削除によるtoken数削減率 |', '|---|---:|---:|'] |
| for s,r in report['by_source'].items(): |
| lines.append(f"| {s} | {r['newline_characters']} | {r['no_lf_token_reduction_fraction']:.1%} |") |
| lines += ['', 'LF削除はtoken負荷の感度診断だけであり、原文を変更する操作。語の結合による変化も含む。実データには適用せず、恣意的な改行の一律削除は提案しない。', '', |
| '## tokenizer学習時の出典配分（文字数）', ''] |
| for s,v in report['tokenizer_training_sample_character_shares'].items(): |
| lines.append(f'- {s}: {v:.2%}') |
| lines += ['', 'NDLは和文・漢文等を含むため、出典だけから言語比率とは見なさない。', '', |
| '## 語彙と使用例', '', '```json', json.dumps(dict(vocab), ensure_ascii=False, indent=2), '```', '', |
| '語彙の長さ別カウントは文字種別と重複する。文字種判定は簡易Unicode規則で、形態素や言語の厳密判定ではない。', '', |
| 'report.jsonに出典別頻出1文字piece、Wikisourceの時代別数値を保存。wikisource-examples.jsonには同一原文での通常分割と最短分割を保存。サンプルの作品・位置・原文hash・数値はsamples.jsonl。', '', |
| '## 解釈の限界', '', |
| '文字/tokenだけで他言語・異なるtokenizerの優劣やモデル品質は判断しない。同語彙最短化は語彙固定での圧縮余地を示すが、より良い語彙を再学習した場合の改善幅は未測定。既存モデル・tokenizer・学習用binは変更していない。', ''] |
| (output/'REPORT.md').write_text('\n'.join(lines)) |
| print(json.dumps(report['by_source'], ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
