| """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=[] |
| |
| 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() |
|
|
