Stage scaling-v1 verified data; training defaults unchanged

scaling_v1/loader/tools/input_sequences.py

@@ -0,0 +1,71 @@
+"""Source-evidenced input semantics; container type is not temporal semantics.
+
+Frame groups refer to the rendered RGB image list (mask assets are not frames).
+Never invent fps/timestamps. Unknown multi-image provenance stays unknown.
+"""
+from __future__ import annotations
+
+
+def spacevista_sequence_contract(raw, media):
+    paths = [m["path"] for m in sorted(media, key=lambda m: m["order"]) if m["media_type"] == "image"]
+    if len(paths) != len(set(paths)):
+        raise ValueError("Canonical RGB media paths must be unique for SpaceVista")
+    lookup = {path: i for i, path in enumerate(paths)}
+    groups = []
+    for sequence in raw.get("videos") or []:
+        if not sequence:
+            continue
+        try:
+            groups.append([lookup[str(path)] for path in sequence])
+        except KeyError as error:
+            raise ValueError("Source frame missing from canonical media") from error
+    # SpaceVista's imported single-/multi-view examples also use `videos`.
+    # Only verified capture-path families are promoted to video frame sequences.
+    temporal_groups = []
+    for group in groups:
+        selected = [paths[i] for i in group]
+        certified = all(path.startswith(("uco3d_frames/", "wildrgbd_frames/", "DL3DV_frames/",
+                                         "SpaceR_frames/")) or "/video_color/" in path for path in selected)
+        if len(group) > 1 and certified:
+            temporal_groups.append(group)
+    if temporal_groups and len(temporal_groups) == len(groups):
+        semantic = "video_frame_sequence" if len(groups) == 1 else "multiple_video_frame_sequences"
+        evidence = "original_videos_groups_and_capture_path_family"
+    elif len(paths) == 1:
+        semantic, evidence = "single_image", "one_rgb_input"
+    else:
+        semantic, evidence = "multi_image_unresolved", "source_groups_preserved_temporal_provenance_unverified"
+    return {"semantic_modality": semantic, "frame_groups": groups,
+            "video_frame_groups": temporal_groups, "modality_evidence": evidence,
+            "timing_available": False, "source_sequence_count": len(groups),
+            "original_frame_occurrences": sum(map(len, groups))}
+
+
+def input_contract(row, spacevista_contract=None):
+    media = sorted(row["media"], key=lambda m: m["order"])
+    images = [m for m in media if m["media_type"] == "image"]
+    if any(m["media_type"] == "video" for m in media):
+        return {"semantic_modality": "video_file", "frame_groups": [], "video_frame_groups": [],
+                "modality_evidence": "video_container", "timing_available": True}
+    if row["source"] == "spacevista":
+        if spacevista_contract is None:
+            raise ValueError("SpaceVista requires its original sequence contract")
+        return dict(spacevista_contract)
+    if row["source"] == "cavqa" and len(images) > 1:
+        group = list(range(len(images)))
+        return {"semantic_modality": "video_frame_sequence", "frame_groups": [group],
+                "video_frame_groups": [group], "modality_evidence": "cavqa_support_frames_reference_last",
+                "timing_available": False, "reference_image_index": len(images) - 1}
+    return {"semantic_modality": "single_image" if len(images) == 1 else "multi_image_unresolved",
+            "frame_groups": [list(range(len(images)))], "video_frame_groups": [],
+            "modality_evidence": "one_rgb_input" if len(images) == 1 else "no_temporal_provenance",
+            "timing_available": False}
+
+
+def grouped_video_frames(images, contract):
+    result = []
+    for group in contract["video_frame_groups"]:
+        if any(not isinstance(i, int) or i < 0 or i >= len(images) for i in group):
+            raise ValueError("Frame group index outside rendered images")
+        result.append([images[i] for i in group])
+    return result

scaling_v1/loader/tools/load_stage3_data.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""Load Stage-3 Small locally or from HF, preserving visual grounding.
+
+Example:
+  python load_stage3_small.py --split train --limit 8 --cache /scratch/my-small
+Requires huggingface_hub, pyarrow, requests, pillow, numpy; av for video smoke.
+Place small_training.py and input_sequences.py beside this script when using
+the HF tools directory. Video frame sequences preserve source order without
+inventing timestamps; consume visual_inputs rather than duplicating images.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import os
+import time
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import pyarrow.parquet as pq
+import requests
+from huggingface_hub import HfApi, hf_hub_download, hf_hub_url
+try:
+    from stage3_measurement.small_training import render_images
+    from stage3_measurement.input_sequences import input_contract, grouped_video_frames
+except ImportError:
+    from small_training import render_images
+    from input_sequences import input_contract, grouped_video_frames
+
+
+class SmallDataset:
+    def __init__(self, cache, revision=None, release_dir=None, local_media_root=None,
+                 max_cache_gib=80, repo='AnchorSR/TrainingData_Stage3', config='small', metadata_prefix=''):
+        if config not in ('small','large'):
+            raise ValueError('config must be small or large')
+        self.config=config
+        self.metadata_prefix=metadata_prefix.strip('/')+'/' if metadata_prefix else ''
+        self.repo=repo
+        self.cache=Path(cache)
+        self.cache.mkdir(parents=True,exist_ok=True)
+        self.release_dir=Path(release_dir) if release_dir else None
+        self.local_media_root=Path(local_media_root) if local_media_root else None
+        self.revision=revision or (None if release_dir else HfApi().dataset_info(repo).sha)
+        self.max_cache_bytes=int(max_cache_gib*1024**3)
+        self.sessions=threading.local()
+        self.account_lock=threading.Lock()
+        manifest=json.loads(self.file(f'{self.metadata_prefix}{config}/media-manifest.json').read_text())
+        self.sequence_contracts={}
+        self.sequence_contract_required=manifest.get('sequence_contract_required',False)
+        if manifest.get('sequence_contract_path'):
+            for batch in pq.ParquetFile(self.file(manifest['sequence_contract_path'])).iter_batches():
+                for item in batch.to_pylist():
+                    self.sequence_contracts[item['source_record_id']]=json.loads(item['sequence_contract_json'])
+        self.split_paths=manifest.get('split_paths',{s:f'{config}/{s}/' for s in ('train','validation','test')})
+        self.media_revision=manifest['input_revision']
+        self.index={}
+        for batch in pq.ParquetFile(self.file(f'{self.metadata_prefix}{config}/asset-index.parquet')).iter_batches():
+            for row in batch.to_pylist():
+                self.index[(row['source'],row['media_path'])]=row
+        self.assets_dir=self.cache/'assets'
+        self.assets_dir.mkdir(exist_ok=True)
+        self.cache_bytes=sum(p.stat().st_size for p in self.assets_dir.iterdir() if p.is_file())
+
+    def file(self,relative):
+        if self.release_dir:
+            return self.release_dir/relative
+        return Path(hf_hub_download(self.repo,relative,repo_type='dataset',revision=self.revision,
+                                   local_dir=self.cache/'metadata'))
+
+    def rows(self,split='train'):
+        prefix=self.split_paths[split]
+        if self.release_dir:
+            paths=sorted(str(p.relative_to(self.release_dir)) for p in (self.release_dir/prefix).glob('*.parquet'))
+        else:
+            paths=sorted(p for p in HfApi().list_repo_files(self.repo,repo_type='dataset',revision=self.revision)
+                         if p.startswith(prefix) and p.endswith('.parquet'))
+        for path in paths:
+            for batch in pq.ParquetFile(self.file(path)).iter_batches(batch_size=256):
+                yield from batch.to_pylist()
+
+    def _evict(self,required):
+        if required>self.max_cache_bytes:
+            raise ValueError('Single asset exceeds configured cache size')
+        if self.cache_bytes+required<=self.max_cache_bytes:
+            return
+        files=sorted((p for p in self.assets_dir.iterdir() if p.is_file() and not p.name.endswith('.tmp')),
+                     key=lambda p:p.stat().st_mtime)
+        for p in files:
+            size=p.stat().st_size
+            p.unlink();self.cache_bytes-=size
+            if self.cache_bytes+required<=self.max_cache_bytes:
+                return
+
+    def asset_path(self,source,path):
+        if not hasattr(self.sessions,'http'):
+            self.sessions.http=requests.Session()
+        asset=self.index[(source,path)]
+        name=hashlib.sha256((self.media_revision+source+path).encode()).hexdigest()+Path(path).suffix
+        target=self.assets_dir/name
+        if target.exists() and target.stat().st_size==asset['size']:
+            os.utime(target,None)
+            return target
+        self._evict(asset['size'])
+        tmp=target.with_suffix(target.suffix+'.tmp')
+        start=asset['offset'];end=start+asset['size']-1
+        local=self.local_media_root/asset['tar_path'] if self.local_media_root else None
+        for attempt in range(5):
+            try:
+                digest=hashlib.sha256()
+                with tmp.open('wb') as out:
+                    if local and local.exists():
+                        with local.open('rb') as handle:
+                            handle.seek(start);remaining=asset['size']
+                            while remaining:
+                                chunk=handle.read(min(4*1024**2,remaining))
+                                if not chunk: raise IOError('Short local TAR read')
+                                out.write(chunk);digest.update(chunk);remaining-=len(chunk)
+                    else:
+                        url=hf_hub_url(self.repo,asset['tar_path'],repo_type='dataset',revision=self.media_revision)
+                        with self.sessions.http.get(url,headers={'Range':f'bytes={start}-{end}'},stream=True,timeout=(30,120)) as response:
+                            response.raise_for_status()
+                            if response.status_code!=206 or not response.headers.get('Content-Range','').startswith(f'bytes {start}-{end}/'):
+                                raise IOError('Server did not honor exact byte range; refusing full TAR download')
+                            for chunk in response.iter_content(4*1024**2):
+                                out.write(chunk);digest.update(chunk)
+                if tmp.stat().st_size!=asset['size']:
+                    raise IOError('Asset length mismatch')
+                if asset.get('sha256') and digest.hexdigest()!=asset['sha256']:
+                    raise IOError('Asset checksum mismatch')
+                tmp.replace(target)
+                with self.account_lock:self.cache_bytes+=asset['size']
+                return target
+            except Exception:
+                tmp.unlink(missing_ok=True)
+                if attempt==4: raise
+                time.sleep(2**attempt)
+
+    def read_asset(self,source,path):
+        return self.asset_path(source,path).read_bytes()
+
+    def prefetch(self,row,workers=4):
+        # One row at a time; reserve enough free cache before parallel downloads.
+        # A separate HTTP session is maintained per worker thread.
+        keys=list(dict.fromkeys((row['source'],m['path']) for m in row['media']))
+        required=sum(self.index[k]['size'] for k in keys)
+        if required>self.max_cache_bytes:
+            raise ValueError('This sample exceeds the media cache budget; increase max_cache_gib')
+        missing=[]
+        for source,path in keys:
+            name=hashlib.sha256((self.media_revision+source+path).encode()).hexdigest()+Path(path).suffix
+            target=self.assets_dir/name
+            if target.exists() and target.stat().st_size==self.index[(source,path)]['size']:
+                os.utime(target,None)
+            else:missing.append((source,path))
+        self._evict(sum(self.index[k]['size'] for k in missing))
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            list(pool.map(lambda k:self.asset_path(*k),missing))
+
+    def sample(self,row):
+        self.prefetch(row)
+        images=render_images(row,self.read_asset)
+        videos=[str(self.asset_path(row['source'],m['path'])) for m in row['media'] if m['media_type']=='video']
+        contract=self.sequence_contracts.get(row.get('source_record_id')) if row['source']=='spacevista' else None
+        if row['source']=='spacevista' and contract is None and not self.sequence_contract_required:
+            # Old release has no source grouping index. Do not infer a video
+            # solely from several image files; legacy images remain usable.
+            contract={'semantic_modality':'single_image' if len(images)==1 else 'multi_image_unresolved',
+                      'frame_groups':[list(range(len(images)))], 'video_frame_groups':[],
+                      'modality_evidence':'legacy_release_without_sequence_index','timing_available':False}
+        contract=input_contract(row,contract)
+        groups=grouped_video_frames(images,contract)
+        grouped_indices={i for group in contract['video_frame_groups'] for i in group}
+        # A processor adapter should consume visual_inputs, OR the legacy
+        # images/videos pair, never both (otherwise frames are duplicated).
+        visual_inputs={'images':[im for i,im in enumerate(images) if i not in grouped_indices],
+                       'video_frame_sequences':groups,'video_files':videos,
+                       'sequence_timestamps_sec':None}
+        return {'sample_id':row['sample_id'],'question':row['training_question'],
+                'answer':row['training_answer'],'images':images,'videos':videos,
+                'task_type':row['task_type'],'source':row['source'],
+                'input_contract':contract,'visual_inputs':visual_inputs}
+
+
+Stage3Dataset=SmallDataset
+
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--cache',required=True)
+    p.add_argument('--revision')
+    p.add_argument('--release-dir')
+    p.add_argument('--local-media-root')
+    p.add_argument('--metadata-prefix',default='',help='Release-candidate metadata path; leave empty for published Small/Large')
+    p.add_argument('--split',choices=['train','validation','test','video_validation','video_test'],default='train')
+    p.add_argument('--config',choices=['small','large'],default='small')
+    p.add_argument('--limit',type=int,default=8)
+    p.add_argument('--max-cache-gib',type=float,default=80)
+    args=p.parse_args()
+    ds=SmallDataset(args.cache,args.revision,args.release_dir,args.local_media_root,args.max_cache_gib,config=args.config,metadata_prefix=args.metadata_prefix)
+    for i,row in enumerate(ds.rows(args.split)):
+        if i>=args.limit: break
+        sample=ds.sample(row)
+        print(json.dumps({k:v for k,v in sample.items() if k not in ('images','visual_inputs')},ensure_ascii=False))
+        print('image sizes:',[im.size for im in sample['images']])
+
+
+if __name__=='__main__':
+    main()

scaling_v1/loader/tools/small_training.py

@@ -0,0 +1,120 @@
+"""Standalone helpers for Stage-3 Small: answer targets and visual grounding.
+
+No model-generated labels are used. Images stay at their original resolution;
+the training model's own processor is responsible for resize/token budgets.
+"""
+from __future__ import annotations
+
+import io
+import json
+import math
+import re
+
+
+def prepare_record(row):
+    row = dict(row)
+    question = re.sub(r'<(?:image|video)>\s*', '', row['question']).strip()
+    original_target = row['target_answer']
+    row['upstream_target_answer'] = original_target
+    row['upstream_original_unit'] = row['original_unit']
+    corrections = []
+    scalar = row.get('original_value')
+    unit = row.get('original_unit')
+    dimension = row['measurement_dimension']
+    if dimension == 'angle' and scalar is not None:
+        # The released angular task families in these sources use degrees.
+        if unit != 'deg':
+            corrections.append('angular_unit_restored_to_degrees')
+        unit = row['original_unit'] = 'deg'
+        row['canonical_unit'] = 'rad'
+        row['canonical_value_si'] = float(scalar) * math.pi / 180
+        if not re.search(r'degrees?|radians?|°',question,re.I):
+            question += '\nReport the angle in degrees.'
+    if scalar is not None and dimension != 'compound':
+        if not math.isfinite(scalar) or not unit:
+            raise ValueError(f"Invalid scalar target: {row['sample_id']}")
+        number_only = re.search(r'(?i)(?:single|one|a) number only|only (?:a |one )?number|without units?|no units|only (?:the )?numerical value',question)
+        answer = f'{scalar:.10g}' if number_only else f'{scalar:.10g} {unit}'
+    else:
+        answer = row['raw_answer'].strip()
+    if re.search(r'<answer>\s*</answer>|between the <answer>|between <answer>',question,re.I):
+        answer = '<answer>' + answer + '</answer>'
+    annotations = json.loads(row['spatial_annotations']) if row.get('spatial_annotations') else {}
+    if annotations.get('2dbox') and 'red' not in question.lower():
+        question += '\nThe red bounding box identifies the target object.'
+    if answer != original_target:
+        corrections.append('answer_target_normalized')
+    row['training_question'] = question
+    row['training_answer'] = answer
+    row['target_answer'] = answer
+    row['small_corrections'] = corrections
+    return row
+
+
+def render_images(row, read_asset):
+    """Read RGB frames in source order and draw released boxes/points/masks.
+
+    read_asset(source, logical_path) must return file bytes. A video container
+    is returned separately by the loader, and decoded by the model processor.
+    """
+    import numpy as np
+    from PIL import Image, ImageDraw
+    source = row['source']
+    items = sorted((m for m in row['media'] if m['media_type']=='image'),key=lambda m:m['order'])
+    images = [Image.open(io.BytesIO(read_asset(source,m['path']))).convert('RGB') for m in items]
+    a = json.loads(row['spatial_annotations']) if row.get('spatial_annotations') else {}
+    palette=[(255,0,0),(0,128,255),(0,255,0),(255,215,0)]
+    def point_coords(coords, image):
+        if a.get('coord_type') == 'normalized_1000':
+            return [v*(image.width if i%2==0 else image.height)/1000 for i,v in enumerate(coords)]
+        if a.get('coord_type') in ('normalized','relative','norm'):
+            return [v*(image.width if i%2==0 else image.height) for i,v in enumerate(coords)]
+        return coords
+    boxes = list(a.get('bboxes') or [])
+    if a.get('2dbox'):
+        boxes.append({'image_index':0,'coords':a['2dbox'],'color':'red'})
+    dual = a.get('dual_bbox')
+    if dual:
+        if isinstance(dual,list):
+            boxes.extend(dual)
+        else:
+            raise ValueError('Unsupported dual_bbox format; refuse ungrounded input')
+    for ordinal,b in enumerate(boxes):
+        index = int(b.get('image_index',0))
+        image = images[index]
+        xy = point_coords(b['coords'],image)
+        if len(xy)!=4:
+            raise ValueError('Invalid bbox')
+        xy=[min(xy[0],xy[2]),min(xy[1],xy[3]),max(xy[0],xy[2]),max(xy[1],xy[3])]
+        ImageDraw.Draw(image).rectangle(xy,outline=b.get('color') or palette[ordinal%4],width=max(2,round(max(image.size)/300)))
+    for ordinal,p in enumerate(a.get('points') or []):
+        image=images[int(p.get('image_index',0))]
+        coords=p['coords']
+        if len(coords)==1:coords=coords[0]
+        # SpaceVista's pinned official renderer explicitly interprets points
+        # as [y,x], despite the abbreviated README schema saying [x,y].
+        if source=='spacevista':coords=[coords[1],coords[0]]
+        x,y=point_coords(coords,image)
+        radius=max(3,round(max(image.size)/150))
+        ImageDraw.Draw(image).ellipse((x-radius,y-radius,x+radius,y+radius),fill=p.get('color') or palette[ordinal%4])
+    mask_ordinal=0
+    for mask in a.get('masks') or []:
+        index=next(i for i,m in enumerate(items) if m['path']==mask['image_path'])
+        labels=np.load(io.BytesIO(read_asset(source,mask['mask_path'])),allow_pickle=False)
+        labels=np.squeeze(labels)
+        if labels.ndim not in (2,3):
+            raise ValueError(f'Unsupported mask shape {labels.shape}')
+        ids=mask.get('object_ids')
+        if labels.ndim==3 and labels.shape[0]<16 and labels.shape[0]!=labels.shape[1]:
+            labels=np.moveaxis(labels,0,2)
+        if ids is None:ids=[None]
+        for object_id in ids:
+            if labels.ndim==2:
+                selected=labels!=0 if object_id is None or labels.dtype==bool else labels==int(object_id)
+            else:
+                selected=(labels!=0).any(axis=2) if object_id is None else labels[:,:,int(object_id)]!=0
+            alpha=Image.fromarray((selected.astype('uint8')*100),mode='L').resize(images[index].size,Image.Resampling.NEAREST)
+            tint=Image.new('RGB',images[index].size,palette[mask_ordinal%4])
+            images[index]=Image.composite(tint,images[index],alpha)
+            mask_ordinal+=1
+    return images