| |
| """Export ONLY licensed simulation records from a prepared joint SFT snapshot. |
| |
| Original files are read-only. HMAC key/ID mapping stay in a separate private |
| work directory. Runtime account/API metadata and unknown-source media never |
| enter the public allowlist. This is not a full original-dataset anonymizer. |
| """ |
| import argparse,collections,concurrent.futures,hashlib,hmac,io,json,os,secrets,tarfile,zipfile |
| from pathlib import Path |
| import numpy as np |
| from PIL import Image |
| from schema import SOURCES,BODIES,TEXT_RISK,validate |
| BUDGET=1024**3 |
|
|
| def sha(path): |
| h=hashlib.sha256() |
| with Path(path).open('rb') as f: |
| for b in iter(lambda:f.read(8*1024*1024),b''):h.update(b) |
| return h.hexdigest() |
|
|
| def dump(path,data):path.write_text(json.dumps(data,ensure_ascii=False,indent=2)+'\n') |
|
|
| def frame_bundle(source): |
| path=Path(source['frames_root'])/source['npz'] |
| before=path.stat();buffer=io.BytesIO();images=[];encoded_hashes=[] |
| with np.load(path,allow_pickle=False) as arrays,zipfile.ZipFile(buffer,'w',compression=zipfile.ZIP_DEFLATED,compresslevel=6) as output: |
| if set(arrays.files)!={f'f{i}' for i in range(8)}:raise ValueError('Unknown source NPZ fields') |
| for i in range(8): |
| arr=arrays[f'f{i}'] |
| if arr.dtype!=np.uint8 or arr.ndim!=1 or not 100<=arr.size<=8*1024*1024:raise ValueError('Unexpected frame encoding') |
| encoded=arr.tobytes();image=Image.open(io.BytesIO(encoded)) |
| if image.format not in ('JPEG','PNG') or image.getexif():raise ValueError('Unreviewed frame metadata/EXIF') |
| if set(image.info)-{'jfif','jfif_version','jfif_unit','jfif_density','gamma','srgb'}:raise ValueError('Additional image metadata found') |
| image.load() |
| if list(reversed(image.size))!=source['hw']:raise ValueError('Source image dimensions differ') |
| |
| encoded_hashes.append(hashlib.sha256(encoded).hexdigest()) |
| if source.get('_make_preview'):images.append(image.convert('RGB').copy()) |
| npy=io.BytesIO();np.lib.format.write_array(npy,arr,allow_pickle=False) |
| info=zipfile.ZipInfo(f'f{i}.npy',date_time=(1980,1,1,0,0,0));info.compress_type=zipfile.ZIP_DEFLATED;info.external_attr=0o644<<16 |
| output.writestr(info,npy.getvalue()) |
| after=path.stat() |
| if (before.st_size,before.st_mtime_ns)!=(after.st_size,after.st_mtime_ns):raise ValueError('Source changed during read') |
| return buffer.getvalue(),encoded_hashes,images |
|
|
| class Sharder: |
| def __init__(self,root,split):self.root=root;self.split=split;self.index=-1;self.handle=None;self.rows=[];self.shards=[];self.size=0 |
| def close(self): |
| if self.handle is None:return |
| self.handle.close();temp=self.root/(self.name+'.partial');target=self.root/self.name |
| entries={r['media_member']:r for r in self.rows} |
| with tarfile.open(temp,'r:') as f: |
| for member in f: |
| if not member.isfile() or member.name not in entries:raise ValueError('Unexpected tar member') |
| data=f.extractfile(member).read() |
| if hashlib.sha256(data).hexdigest()!=entries.pop(member.name)['media_sha256']:raise ValueError('Tar member readback SHA256 differs') |
| if entries:raise ValueError('Missing tar member') |
| if target.exists():raise ValueError('Will not overwrite an existing archive') |
| temp.replace(target);self.shards.append({'path':'data/archives/'+self.name,'bytes':target.stat().st_size,'sha256':sha(target),'members':len(self.rows)}) |
| self.handle=None;self.rows=[] |
| def add(self,row,data): |
| padded=((len(data)+511)//512)*512+512 |
| if self.handle is not None and self.size+padded>BUDGET:self.close() |
| if self.handle is None: |
| self.index+=1;self.name=f'{self.split}-{self.index:05d}.tar';self.size=0 |
| self.handle=tarfile.open(self.root/(self.name+'.partial'),'w:') |
| row['media_archive']='data/archives/'+self.name |
| info=tarfile.TarInfo(row['media_member']);info.size=len(data);info.mtime=0;info.uid=info.gid=0;info.uname=info.gname='';info.mode=0o644 |
| self.handle.addfile(info,io.BytesIO(data));self.size+=padded;self.rows.append(dict(row)) |
|
|
|
|
| def main(): |
| p=argparse.ArgumentParser(description=__doc__);p.add_argument('--sft-root',required=True,type=Path);p.add_argument('--cot-run',required=True,type=Path);p.add_argument('--output',required=True,type=Path);p.add_argument('--privacy-work-root',required=True,type=Path);p.add_argument('--workers',type=int,default=4);a=p.parse_args() |
| out=a.output.resolve();private=a.privacy_work_root.resolve() |
| if private==out or out in private.parents:raise ValueError('Private mapping/key must be outside public payload') |
| if (out/'PUBLIC_RELEASE_MANIFEST.json').exists():raise ValueError('Completed output already exists; use validator instead of overwriting') |
| (out/'data/archives').mkdir(parents=True,exist_ok=True);(out/'previews').mkdir(exist_ok=True);private.mkdir(parents=True,exist_ok=True);private.chmod(0o700) |
| if list((out/'data/archives').iterdir()):raise ValueError('Will not overwrite previous archives') |
| key_path=private/'pseudonym_key' |
| if not key_path.exists():key_path.write_bytes(secrets.token_bytes(32));key_path.chmod(0o600) |
| key=key_path.read_bytes() |
| def pseudonym(value):return hmac.new(key,value.encode(),hashlib.sha256).hexdigest()[:32] |
| rows_by_split={};by_id={};groups={};excluded=collections.Counter();previews=set();source_counts={};media_rows=[];shards=[];seen=set() |
| for split in ('train','heldout'): |
| selected=[];group_set=set();counts=collections.Counter() |
| for line in (a.sft_root/(split+'.jsonl')).open(): |
| s=json.loads(line);body=s.get('source') |
| if body not in BODIES:excluded[str(body)]+=1;continue |
| if s['joint_id'] in by_id:raise ValueError('Repeated original source ID') |
| source='DexMimicGen' if body=='dmg' else 'RoboTwin2.0' |
| row={k:s[k] for k in ('task','coordinate_space','point_names','n_hist','n_fut','forecast_arm_count','history','anchor','future_delta','hw')} |
| row.update(sample_id=pseudonym('sample:'+s['joint_id']),group_id=pseudonym('group:'+body+':'+s['joint_episode_group']),split=split,source_dataset=source,license=SOURCES[source],robot_body=body,media_archive=f'data/archives/{split}-00000.tar',media_member='',media_sha256='0'*64) |
| row['media_member']=row['sample_id']+'.npz';validate(row) |
| if row['sample_id'] in seen:raise ValueError('Duplicate pseudonymous ID') |
| seen.add(row['sample_id']);group_set.add(row['group_id']);counts[body]+=1 |
| s['_make_preview']=split=='train' and body not in previews |
| if s['_make_preview']:previews.add(body) |
| selected.append((s,row));by_id[s['joint_id']]=row |
| rows_by_split[split]=selected;groups[split]=group_set;source_counts[split]=dict(counts) |
| if groups['train']&groups['heldout']:raise ValueError('Source episode groups leak across splits') |
| if (len(rows_by_split['train']),len(rows_by_split['heldout']))!=(14253,3168):raise ValueError('Unexpected reviewed simulation snapshot count') |
| mapping=private/'id_mapping.jsonl' |
| with mapping.open('w') as f: |
| for original,row in by_id.items():f.write(json.dumps({'original_id':original,'public_id':row['sample_id']})+'\n') |
| mapping.chmod(0o600) |
| preview_rows=[] |
| for split,selected in rows_by_split.items(): |
| sharder=Sharder(out/'data/archives',split) |
| with (out/'data'/(split+'.jsonl')).open('w') as labels,concurrent.futures.ThreadPoolExecutor(max_workers=a.workers) as pool: |
| for number,((source,row),(data,encoded_hashes,images)) in enumerate(zip(selected,pool.map(frame_bundle,(s for s,r in selected))),1): |
| row['media_sha256']=hashlib.sha256(data).hexdigest();sharder.add(row,data);validate(row) |
| labels.write(json.dumps(row,separators=(',',':'))+'\n') |
| media_rows.append({'sample_id':row['sample_id'],'media_archive':row['media_archive'],'media_member':row['media_member'],'bytes':len(data),'sha256':row['media_sha256'],'encoded_frame_SHA256':encoded_hashes}) |
| if images: |
| name=f'preview_{len(preview_rows)+1:02d}.gif';images[0].save(out/'previews'/name,save_all=True,append_images=images[1:],duration=180,loop=0) |
| preview_rows.append({'path':'previews/'+name,'sample_id':row['sample_id'],'source_dataset':row['source_dataset'],'robot_body':row['robot_body'],'task':row['task'],'kind':'observed_simulation_frames_not_predictions'}) |
| if number%1000==0:print(f'{split}: {number}/{len(selected)} observations packaged and image metadata checked',flush=True) |
| sharder.close();shards+=sharder.shards |
| dump(out/'SHARDS.json',{'shards':shards,'every_tar_member_independently_SHA256_verified':True}) |
| with (out/'MEDIA_MANIFEST.jsonl').open('w') as f: |
| for row in media_rows:f.write(json.dumps(row,separators=(',',':'))+'\n') |
| dump(out/'previews/manifest.json',preview_rows) |
| |
| reviews={} |
| for line in (a.cot_run/'quality_reviews.jsonl').open(): |
| r=json.loads(line);reviews[r['id']]=r |
| candidates={} |
| for line in (a.cot_run/'candidates.jsonl').open(): |
| c=json.loads(line);r=reviews.get(c['id']) |
| if c['id'] in by_id and r and hashlib.sha256(c['public_content'].encode()).hexdigest()==r['public_content_sha256']:candidates[c['id']]=c |
| rationale_counts=collections.Counter();text_withheld=0 |
| with (out/'data/public_rationales.jsonl').open('w') as f: |
| for original,c in candidates.items(): |
| text=c.get('reasoning') or '';row=by_id[original];review=reviews[original] |
| if c.get('future_GT_sent_to_generator') is not False or not text or len(text)>20000 or TEXT_RISK.search(text) or original in text: |
| text_withheld+=1;continue |
| status='eligible_weak_draft' if review.get('eligible_for_weak_supervision') and c.get('machine_format_role_check_pass') else 'held_for_review' |
| pub={'sample_id':row['sample_id'],'split':row['split'],'public_rationale':text,'status':status,'generation_source':'DeepSeek published API response','human_approved':False,'faithfulness_verified':False,'future_GT_sent_to_generator':False,'teacher_numeric_prediction_generated':False} |
| f.write(json.dumps(pub,separators=(',',':'))+'\n');rationale_counts[status]+=1 |
| report={'scope':'licensed RoboTwin2.0 and DexMimicGen prepared simulation observation/trajectory subset', |
| 'counts':{k:len(v) for k,v in rows_by_split.items()},'by_body':source_counts, |
| 'raw_media_records':len(media_rows),'public_rationales':sum(rationale_counts.values()),'rationale_quality_counts':dict(rationale_counts), |
| 'rationales_withheld_for_sensitive_or_unverified_text':text_withheld,'excluded_unknown_license_sources':dict(excluded), |
| 'source_observation_image_bytes_preserved':True,'all_image_frames_decoded_and_metadata_checked':True, |
| 'image_EXIF_and_nonallowlisted_metadata_present':False,'original_IDs_paths_timestamps_account_API_metadata_exported':False, |
| 'key_or_mapping_exported':False,'each_tar_and_member_readback_SHA256_verified':True, |
| 'source_episode_groups_separate':True,'source_files_modified':False,'teacher_API_calls':0,'GPU_used':False, |
| 'full_original_356GB_collection_published':False,'new_training_or_model_predictions':False} |
| dump(out/'SANITIZATION_REPORT.json',report) |
| print(json.dumps(report,ensure_ascii=False,indent=2),flush=True) |
| if __name__=='__main__':main() |
|
|
