| """Create corpus/token derivatives excluding the audited unknown-era Kanripo IDs.""" |
| import argparse |
| from collections import Counter |
| import hashlib |
| import json |
| from pathlib import Path |
| import shutil |
|
|
| import numpy as np |
|
|
| from sentencepiece_unigram import now, read_json, sha, write_json |
|
|
|
|
| def excluded(row): |
| return row['source']=='kanripo' and row['date_evidence'].get('dynasty')=='時代不明' |
|
|
|
|
| def main(): |
| p=argparse.ArgumentParser(description=__doc__) |
| p.add_argument('--input',type=Path,default=Path('unified/pretrain-v1/build-002')) |
| p.add_argument('--tokens',type=Path,default=Path('unified/tokens-v1/build-001')) |
| p.add_argument('--audit',type=Path,default=Path('kanripo/unknown-era-audit/run-001')) |
| p.add_argument('--output',type=Path,default=Path('unified/pretrain-v1/build-003')) |
| p.add_argument('--token-output',type=Path,default=Path('unified/tokens-v1/build-002')) |
| a=p.parse_args() |
| cm,tm,am=(read_json(a.input/'manifest.json'),read_json(a.tokens/'manifest.json'),read_json(a.audit/'report.json')) |
| if not all(m['complete'] for m in (cm,tm,am)): |
| raise ValueError('Incomplete inputs') |
| src=a.input/'pretrain.jsonl' |
| if sha(src)!=cm['output_sha256'][src.name] or tm['input_sha256']!=cm['output_sha256'][src.name] or am['input_sha256']!=tm['input_sha256']: |
| raise ValueError('Input identity mismatch') |
| for name,expected in tm['files'].items(): |
| if sha(a.tokens/name)!=expected: |
| raise ValueError('Token input hash mismatch: '+name) |
| with (a.audit/'documents.jsonl').open() as f: |
| audit_ids={json.loads(l)['id'] for l in f} |
| if len(audit_ids)!=6674: |
| raise ValueError('Expected exactly 6674 audited exclusion IDs') |
| a.output.mkdir(parents=True,exist_ok=False) |
| a.token_output.mkdir(parents=True,exist_ok=False) |
| manifest=dict(complete=False,started=now(),input=str(a.input.resolve()), |
| input_manifest_sha256=sha(a.input/'manifest.json'), |
| input_sha256=tm['input_sha256'],audit_report_sha256=sha(a.audit/'report.json'), |
| policy='Exclude exactly audited Kanripo files with unknown catalog dynasty; preserve all other rows verbatim', |
| script_sha256=sha(__file__)) |
| write_json(a.output/'manifest.json',manifest) |
| token_manifest=dict(complete=False,started=now(),parent=str(a.tokens.resolve()), |
| parent_manifest_sha256=sha(a.tokens/'manifest.json'), |
| tokenizer_sha256=tm['tokenizer_sha256'],vocab_size=tm['vocab_size'],dtype=tm['dtype'], |
| script_sha256=sha(__file__),encoding=tm['encoding'], |
| policy='Copy retained document token slices exactly; no re-encoding') |
| write_json(a.token_output/'manifest.json',token_manifest) |
| original=np.memmap(a.tokens/'tokens.bin',dtype='<u4',mode='r') |
| kept,removed,token_counts,chars=Counter(),Counter(),Counter(),Counter() |
| removed_ids,removed_works=set(),set() |
| offset=0 |
| parent_offset=0 |
| with src.open('rb') as source, (a.tokens/'documents.jsonl').open() as metadata, \ |
| (a.output/'pretrain.jsonl').open('wb') as corpus, \ |
| (a.output/'excluded.jsonl').open('w') as exclusions, \ |
| (a.token_output/'documents.jsonl').open('w') as documents, \ |
| (a.token_output/'tokens.bin').open('wb') as tokens: |
| for raw in source: |
| r,m=json.loads(raw),json.loads(next(metadata)) |
| if r['id']!=m['id'] or r['text_sha256']!=m['text_sha256'] or m['offset']!=parent_offset: |
| raise ValueError('Source/token metadata alignment failed') |
| parent_offset+=m['tokens'] |
| if excluded(r)!=(r['id'] in audit_ids): |
| raise ValueError('Exclusion policy does not match audited IDs') |
| if excluded(r): |
| removed[r['source']]+=1 |
| removed_ids.add(r['id']);removed_works.add(r['source_document_id']) |
| exclusions.write(json.dumps(dict(id=r['id'],source=r['source'],title=r['title'], |
| source_document_id=r['source_document_id'],text_sha256=r['text_sha256'], |
| tokens=m['tokens'],reason='user_excluded_kanripo_unknown_dynasty'),ensure_ascii=False)+'\n') |
| continue |
| if hashlib.sha256(r['text'].encode()).hexdigest()!=r['text_sha256']: |
| raise ValueError('Source document hash mismatch') |
| corpus.write(raw) |
| ids=original[m['offset']:m['offset']+m['tokens']] |
| if len(ids)!=m['tokens'] or ids[0]!=1 or ids[-1]!=2: |
| raise ValueError('Invalid retained tokens') |
| tokens.write(ids.tobytes()) |
| m['offset']=offset |
| documents.write(json.dumps(m,ensure_ascii=False)+'\n') |
| kept[r['source']]+=1;token_counts[r['source']]+=m['tokens'];chars[r['source']]+=len(r['text']) |
| offset+=m['tokens'] |
| if next(metadata,None) is not None or parent_offset!=len(original): |
| raise ValueError('Incomplete source coverage') |
| if removed_ids!=audit_ids or len(removed_works)!=1881: |
| raise ValueError('Excluded IDs/work count mismatch') |
| if sum(kept.values())!=tm['documents']-6674: |
| raise ValueError('Kept count mismatch') |
| for name in ('tokenizer.model','tokenizer_wrapper.py'): |
| shutil.copyfile(a.tokens/name,a.token_output/name) |
| |
| copied=np.memmap(a.token_output/'tokens.bin',dtype='<u4',mode='r') |
| verified=0 |
| with (a.tokens/'documents.jsonl').open() as old, (a.token_output/'documents.jsonl').open() as new: |
| for line in old: |
| before=json.loads(line) |
| if before['id'] in audit_ids: |
| continue |
| after=json.loads(next(new)) |
| old_offset,new_offset=before.pop('offset'),after.pop('offset') |
| if before!=after: |
| raise ValueError('Retained token metadata changed') |
| length=before['tokens'] |
| if not np.array_equal(original[old_offset:old_offset+length],copied[new_offset:new_offset+length]): |
| raise ValueError('Retained token IDs changed') |
| verified+=1 |
| if next(new,None) is not None: |
| raise ValueError('Unexpected retained rows') |
| |
| with src.open('rb') as old, (a.output/'pretrain.jsonl').open('rb') as new: |
| for line in old: |
| if json.loads(line)['id'] not in audit_ids and line!=next(new): |
| raise ValueError('Retained corpus bytes changed') |
| if next(new,None) is not None: |
| raise ValueError('Unexpected corpus rows') |
| verification=dict(complete=True,excluded_files=len(removed_ids),excluded_works=len(removed_works), |
| kept_files=verified,kept_tokens=offset,all_retained_text_bytes_identical=True, |
| all_retained_token_ids_identical=True,excluded_id_overlap=0) |
| write_json(a.output/'verification.json',verification) |
| write_json(a.token_output/'verification.json',verification) |
| report=dict(kept_units=sum(kept.values()),kept_characters=sum(chars.values()),tokens=offset, |
| excluded_files=len(removed_ids),excluded_works=len(removed_works), |
| removed_tokens=tm['tokens']-offset, |
| counts={s:dict(kept_units=n,kept_chars=chars[s],tokens=token_counts[s]) for s,n in kept.items()}) |
| write_json(a.output/'report.json',report) |
| corpus_sha=sha(a.output/'pretrain.jsonl') |
| manifest.update(complete=True,finished=now(),output_sha256={p.name:sha(p) for p in a.output.iterdir() if p.name!='manifest.json'}) |
| write_json(a.output/'manifest.json',manifest) |
| token_manifest.update(complete=True,finished=now(),input=str((a.output/'pretrain.jsonl').resolve()), |
| input_sha256=corpus_sha,documents=verified,tokens=offset,by_source=dict(token_counts), |
| files={p.name:sha(p) for p in a.token_output.iterdir() if p.name!='manifest.json'}) |
| write_json(a.token_output/'manifest.json',token_manifest) |
| print(json.dumps(report,ensure_ascii=False,indent=2),flush=True) |
|
|
|
|
| if __name__=='__main__': |
| main() |
|
|
