experiments/data/create_hlp_validation.py

"""Derive a tile-disjoint HLP train/val/test version without rewriting source data."""
from concurrent.futures import ProcessPoolExecutor, as_completed
from pathlib import Path
import copy
import csv
import hashlib
import io
import json
import shutil
import sqlite3
import sys
import time
import numpy as np

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))
from eo_data import open_dataset
from eo_data.archive import ArchiveFrames
from eo_data import codec
from eo_data.core import canonical, sample_moments, empty_accumulator, accumulate, finish_stats, sha256_file

SEED = 20260914
FRACTION = 0.05
SOURCE = ROOT / 'processed_data/v1/prithvi'
DEST = ROOT / 'processed_data/hlp_split_v2_20260914/prithvi'
EVIDENCE = ROOT / 'data_inspection/hlp_split_20260914'
MODS = ('hls', 'lst_hr')

def write_json(path, value):
    path.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False)+'\n', encoding='utf-8')

def init_worker(storage):
    global archive
    archive = ArchiveFrames(ROOT, storage)

def moments_chunk(rows):
    accumulators = {m: empty_accumulator(6 if m == 'hls' else 1) for m in MODS}
    for rid, loc, digest, hls_count, lst_count in rows:
        parts = codec.decode(archive.read(json.loads(loc)), digest)
        fmask = np.load(io.BytesIO(parts[1]), allow_pickle=False)
        for mod, part, count in [('hls', 0, hls_count), ('lst_hr', 2, lst_count)]:
            raw = np.load(io.BytesIO(parts[part]), allow_pickle=False)
            image, mask = canonical(raw, mod, 'prithvi', fmask=fmask if mod == 'hls' else None)
            assert int(mask.sum()) == count, (rid, mod)
            accumulate(accumulators[mod], sample_moments(image, mask))
    return accumulators

def merge_accumulators(target, part):
    for mod in MODS:
        for field in ('samples', 'pixels'):
            target[mod][field] += part[mod][field]
        for field in ('sum_mean', 'sum_second'):
            target[mod][field] = (np.asarray(target[mod][field]) + part[mod][field]).tolist()

def main():
    started = time.time()
    EVIDENCE.mkdir(exist_ok=True)
    if DEST.exists():
        raise RuntimeError(f'Completed or partial destination already exists: {DEST}')
    db = sqlite3.connect((SOURCE/'index.sqlite').as_uri()+'?mode=ro&immutable=1', uri=True)
    original_bundle = json.loads((SOURCE/'bundle.json').read_text())
    protected = {p.name: sha256_file(p) for p in SOURCE.iterdir() if p.is_file() and p.suffix not in ('.wal', '.shm') and not p.name.endswith(('-wal','-shm'))}
    source_rows = db.execute('SELECT id,key,split,tile FROM records ORDER BY id').fetchall()
    assert len(source_rows) == 242416
    original_tiles = {split: {r[3] for r in source_rows if r[2] == split} for split in ('train','val')}
    assert len(original_tiles['train']) == 2943 and len(original_tiles['val']) == 151
    assert not original_tiles['train'] & original_tiles['val']
    ranked = sorted(original_tiles['train'], key=lambda t: (hashlib.sha256(f'{SEED}:{t}'.encode()).hexdigest(), t))
    val_tiles = set(ranked[:round(FRACTION*len(ranked))])
    assignments = {rid: ('test' if split == 'val' else 'val' if tile in val_tiles else 'train') for rid,key,split,tile in source_rows}
    split_ids = {s: {rid for rid,split in assignments.items() if split==s} for s in ('train','val','test')}
    split_tiles = {s: {tile for rid,key,old,tile in source_rows if assignments[rid]==s} for s in split_ids}
    for a,b in [('train','val'),('train','test'),('val','test')]:
        assert not split_ids[a]&split_ids[b]
        assert not split_tiles[a]&split_tiles[b]
    assert split_ids['test'] == {r[0] for r in source_rows if r[2]=='val'}
    assert split_ids['train'] | split_ids['val'] == {r[0] for r in source_rows if r[2]=='train'}
    counts = {s: {'records': len(split_ids[s]), 'tiles': len(split_tiles[s]), 'hls_samples': len(split_ids[s]), 'fine_lst_samples': len(split_ids[s])} for s in split_ids}
    print('Selected splits:', json.dumps(counts), flush=True)

    progress = json.loads(db.execute("SELECT value FROM settings WHERE key='progress'").fetchone()[0])
    old_stats = json.loads((SOURCE/'normalization.json').read_text())
    for mod in MODS:
        assert finish_stats(progress['train_accumulators'][mod], mod) == old_stats[mod]
    sample_counts = {(rid,mod):count for rid,mod,count in db.execute('SELECT record_id,modality,valid_pixels FROM samples')}
    validation_rows = [(rid,loc,digest,sample_counts[rid,'hls'],sample_counts[rid,'lst_hr'])
                       for rid,loc,digest in db.execute('SELECT id,loc,digest FROM records ORDER BY id') if rid in split_ids['val']]
    chunks = [validation_rows[i:i+256] for i in range(0,len(validation_rows),256)]
    cache = EVIDENCE/'moments'; cache.mkdir(exist_ok=True)
    storage = json.loads((SOURCE/'storage.json').read_text())
    results = {}
    with ProcessPoolExecutor(max_workers=6, initializer=init_worker, initargs=(storage,)) as pool:
        jobs = {}
        for i, chunk in enumerate(chunks):
            fingerprint = hashlib.sha256(json.dumps(chunk).encode()).hexdigest()
            path = cache/f'{i:04d}.json'
            if path.exists():
                part = json.loads(path.read_text()); assert part['source_sha256'] == fingerprint
                results[i] = part['accumulators']
            else:
                jobs[pool.submit(moments_chunk, chunk)] = (i, fingerprint, path)
        for job in as_completed(jobs):
            i,fingerprint,path = jobs[job]
            results[i] = job.result()
            write_json(path, {'source_sha256':fingerprint, 'records':len(chunks[i]), 'accumulators':results[i]})
            print(f'Validated held-out raw records: {len(results)}/{len(chunks)} batches', flush=True)
    heldout = {m:empty_accumulator(6 if m=='hls' else 1) for m in MODS}
    for i in range(len(chunks)):
        merge_accumulators(heldout, results[i])
    train_acc = copy.deepcopy(progress['train_accumulators'])
    for mod in MODS:
        for field in ('samples','pixels'):
            train_acc[mod][field] -= heldout[mod][field]
        for field in ('sum_mean','sum_second'):
            train_acc[mod][field] = (np.asarray(train_acc[mod][field])-heldout[mod][field]).tolist()
        assert train_acc[mod]['samples'] == counts['train']['records']
        expected_pixels = sum(sample_counts[rid,mod] for rid in split_ids['train'])
        assert train_acc[mod]['pixels'] == expected_pixels
    normalization = {m:finish_stats(train_acc[m],m) for m in MODS}
    write_json(EVIDENCE/'normalization_derivation.json', {
        'method':'Original train sufficient-statistic sums minus raw recomputed held-out sums; float64 arithmetic.',
        'validation_records_recomputed_and_digest_verified':len(validation_rows),
        'original_train':progress['train_accumulators'], 'heldout_validation':heldout,
        'remaining_train':train_acc,
        'test_contribution':0,
        'source_normalization_sha256':protected['normalization.json'],
        'note':'Same canonical masks and equal-sample weighting; no rounded published means used. Floating-point subtraction has normal roundoff.'})

    staging = DEST.with_name('prithvi.building')
    if staging.exists():
        raise RuntimeError(f'Inspect previous staging directory before rerunning: {staging}')
    (staging/'indices').mkdir(parents=True)
    target_db = sqlite3.connect(staging/'index.sqlite')
    db.backup(target_db)
    target_db.execute('CREATE TEMP TABLE new_split(id INTEGER PRIMARY KEY, split TEXT)')
    target_db.executemany('INSERT INTO new_split VALUES (?,?)', assignments.items())
    target_db.execute('UPDATE records SET split=(SELECT split FROM new_split WHERE id=records.id)')
    target_db.execute('UPDATE samples SET split=(SELECT split FROM new_split WHERE id=samples.record_id)')
    for rid,meta in target_db.execute('SELECT id,meta FROM records').fetchall():
        obj=json.loads(meta); obj['source_split']=obj['split']; obj['experiment_split']=assignments[rid]
        target_db.execute('UPDATE records SET meta=? WHERE id=?', (json.dumps(obj,separators=(',',':')),rid))
    samples = {}
    for split in split_ids:
        for mod in MODS:
            rows = target_db.execute('SELECT record_id,slot,valid_pixels FROM samples WHERE split=? AND modality=? ORDER BY record_id,slot',(split,mod)).fetchall()
            array = np.asarray(rows,dtype=np.int64)
            assert set(array[:,0]) == split_ids[split]
            file = staging/'indices'/f'{split}.{mod}.npy'; np.save(file,array,allow_pickle=False)
            samples[f'{split}/{mod}']={'samples':len(rows),'index':file.relative_to(staging).as_posix(),'sha256':sha256_file(file)}
    for mod in MODS:
        assert np.array_equal(np.load(SOURCE/f'indices/val.{mod}.npy'),np.load(staging/f'indices/test.{mod}.npy'))
    with (SOURCE/'source_index.jsonl').open(encoding='utf-8') as src, (staging/'source_index.jsonl').open('w',encoding='utf-8') as dst:
        for line in src:
            obj=json.loads(line); obj['source_split']=obj['split'];obj['split']=assignments[obj['id']]
            dst.write(json.dumps(obj,ensure_ascii=False,separators=(',',':'))+'\n')
    identity = copy.deepcopy(original_bundle['identity'])
    identity['source_index_sha256']=sha256_file(staging/'source_index.jsonl')
    identity['split_version']='hlp-tile-validation-v2-20260914'
    info = json.loads((SOURCE/'source_info.json').read_text())
    info['record_counts']={s:v['records'] for s,v in counts.items()}
    info['candidate_samples']={key:value['samples'] for key,value in samples.items()}
    info['index_sha256']=identity['source_index_sha256']
    info['source_split_semantics']={'train':'original training pool','val':'fixed test'}
    write_json(staging/'source_info.json',info)
    write_json(staging/'normalization.json',normalization)
    shutil.copyfile(SOURCE/'protocol.json',staging/'protocol.json')
    shutil.copyfile(SOURCE/'storage.json',staging/'storage.json')
    progress['train_accumulators']=train_acc
    progress['split_version']=identity['split_version']
    target_db.execute("UPDATE settings SET value=? WHERE key='progress'",(json.dumps(progress),))
    target_db.execute("UPDATE settings SET value=? WHERE key='identity'",(json.dumps(identity),))
    target_db.commit()
    assert target_db.execute('PRAGMA integrity_check').fetchone()[0]=='ok'
    assert not target_db.execute('SELECT tile FROM records GROUP BY tile HAVING COUNT(DISTINCT split)>1').fetchall()
    target_db.close(); db.close()
    manifest_files={}
    for split in split_ids:
        file=EVIDENCE/f'{split}_records.csv'
        with file.open('w',newline='',encoding='utf-8') as f:
            writer=csv.writer(f);writer.writerow(['record_id','record_key','mgrs_tile','source_split','experiment_split'])
            writer.writerows((rid,key,tile,old,split) for rid,key,old,tile in source_rows if assignments[rid]==split)
        tile_file=EVIDENCE/f'{split}_tiles.txt';tile_file.write_text('\n'.join(sorted(split_tiles[split]))+'\n',encoding='utf-8')
        manifest_files[file.name]=sha256_file(file);manifest_files[tile_file.name]=sha256_file(tile_file)
    bundle=copy.deepcopy(original_bundle)
    bundle['samples']=samples;bundle['identity']=identity
    bundle['artifacts']={name:sha256_file(staging/name) for name in original_bundle['artifacts']}
    bundle['derived_from']={'prepared':'processed_data/v1/prithvi','bundle_sha256':protected['bundle.json'],'split_version':identity['split_version']}
    write_json(staging/'bundle.json',bundle)
    write_json(staging/'progress.json',{'status':'complete','dataset':'prithvi','records':len(source_rows),'samples':{k:v['samples'] for k,v in samples.items()},'split_version':identity['split_version']})
    verification=[]
    # Reader expects a child named prithvi; publish locally before read checks.
    staging.rename(DEST)
    try:
        for split in split_ids:
            for mod in MODS:
                ds=open_dataset('prithvi',mod,split,prepared=DEST.parent)
                assert len(ds)==counts[split]['records']
                for i in (0,len(ds)//2,len(ds)-1):
                    sample=ds[i]
                    assert sample['tile_id'] in split_tiles[split]
                    assert sample['split']==split
                    assert np.isfinite(sample['image']).all()
                    assert ds.get_metadata(i)['experiment_split']==split
                verification.append({'split':split,'modality':mod,'samples':len(ds),'raw_read_checks':3})
                ds.close()
        for name,digest in protected.items():
            assert sha256_file(SOURCE/name)==digest, name
    except Exception:
        DEST.rename(staging)
        raise
    report={'status':'complete','version':identity['split_version'],'date':'2026-09-14','seed':SEED,
            'method':'Sort original-train MGRS tiles by (SHA256(seed:tile), tile); first round(0.05*N) become val.',
            'target_train_tile_fraction':FRACTION,'eligible_train_tiles':len(ranked),'selected_val_tiles':len(val_tiles),
            'counts':counts,'test_membership_and_index_arrays_unchanged':True,'old_train_equals_new_train_union_val':True,
            'pairwise_record_overlap':0,'pairwise_tile_id_overlap':0,'spatial_footprint_overlap_checked':False,
            'prepared_directory':DEST.parent.relative_to(ROOT).as_posix(),'reader_splits':{'train':'train','validation':'val','test':'test'},
            'normalization':'Remaining-train sufficient statistics; see normalization_derivation.json.',
            'old_checkpoints_independent_of_new_validation':False,
            'source_files_unchanged':protected,'membership_sha256':manifest_files,'read_verification':verification,
            'script_sha256':sha256_file(Path(__file__)),'elapsed_seconds':round(time.time()-started,2)}
    write_json(EVIDENCE/'split_summary.json',report)
    write_json(DEST/'verification.json',report)
    print(json.dumps(report,ensure_ascii=False,indent=2),flush=True)

if __name__ == '__main__':
    main()