add dense t-SNE scaling output generate_scaleup_tsne.py

visualizations/h100/tsne_scaling_20260728_final_dense/generate_scaleup_tsne.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+import argparse, json, os, random
+from pathlib import Path
+from collections import defaultdict
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, Subset
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from sklearn.manifold import TSNE
+from sklearn.preprocessing import StandardScaler
+
+from vitacdreamer.dataset_v2 import ViTacDreamerTemporalMaskedDataset
+from vitacdreamer.model_v2 import ViTacDreamerV2
+
+
+def list_hdf5(root: Path):
+    return sorted([p for p in root.iterdir() if p.suffix in ('.hdf5', '.h5')])
+
+def task_from_path(p: Path):
+    stem=p.stem
+    return stem.split('__episode_',1)[0] if '__episode_' in stem else p.parent.name
+
+def build_dataset(data_dir: Path, cfg: dict):
+    paths=list_hdf5(data_dir)
+    inferred=sorted({task_from_path(p) for p in paths})
+    cfg_tasks=cfg.get('task_names') or []
+    if cfg_tasks:
+        task_names=[t for t in cfg_tasks if t in inferred]
+        extra=[t for t in inferred if t not in task_names]
+        if extra:
+            raise ValueError(f'data contains tasks not in checkpoint config: {extra}; config tasks={cfg_tasks}')
+    else:
+        task_names=inferred
+    ds=ViTacDreamerTemporalMaskedDataset(
+        data_paths=paths,
+        history_len=int(cfg.get('history_len',5)),
+        image_size=int(cfg.get('visual_image_size',224)),
+        sample_stride=int(cfg.get('sample_stride',5)),
+        num_tail_frames=int(cfg.get('num_tail_frames',2)),
+        random_tail_mask=False,
+        augment=False,
+        task_names=task_names,
+        tactile_temporal_mode=cfg.get('tactile_temporal_mode','raw'),
+        tactile_flow_target_mode=cfg.get('tactile_flow_target_mode','depth_delta'),
+        tactile_flow_clip=float(cfg.get('tactile_flow_clip',0.25)),
+        marker_flow_clip=float(cfg.get('marker_flow_clip',1.0)),
+        depth_delta_clip=float(cfg.get('depth_delta_clip',0.5)),
+        tactile_delta_clip=float(cfg.get('tactile_delta_clip',0.25)),
+    )
+    return ds, task_names
+
+def choose_balanced_indices(ds, max_per_task:int, seed:int):
+    rng=random.Random(seed)
+    buckets=defaultdict(list)
+    for i,s in enumerate(ds.samples):
+        buckets[s['task_name']].append(i)
+    chosen=[]
+    for task in sorted(buckets):
+        arr=buckets[task]
+        rng.shuffle(arr)
+        chosen.extend(arr[:max_per_task])
+    rng.shuffle(chosen)
+    return chosen
+
+def load_model(cfg, ckpt_path, device, num_tasks):
+    model=ViTacDreamerV2(
+        visual_image_size=int(cfg.get('visual_image_size',224)),
+        tactile_image_size=int(cfg.get('tactile_image_size',224)),
+        action_dim=int(cfg.get('action_dim',7)),
+        latent_dim=int(cfg.get('latent_dim',512)),
+        history_len=int(cfg.get('history_len',5)),
+        pretrained_encoders=bool(cfg.get('pretrained_encoders',True)),
+        max_delta_t=int(cfg.get('max_delta_t',64)),
+        num_memory_layers=int(cfg.get('num_memory_layers',4)),
+        num_latent_layers=int(cfg.get('num_latent_layers',4)),
+        num_tail_frames=int(cfg.get('num_tail_frames',2)),
+        num_tasks=num_tasks,
+        reconstruct_tactile_flow=(cfg.get('tactile_flow_target_mode','none')!='none'),
+    ).to(device)
+    ckpt=torch.load(ckpt_path, map_location=device)
+    state=ckpt.get('model_state_dict', ckpt)
+    missing, unexpected = model.load_state_dict(state, strict=False)
+    print('load', ckpt_path, 'missing', len(missing), 'unexpected', len(unexpected), flush=True)
+    model.eval()
+    return model
+
+def collate(batch):
+    return torch.utils.data.default_collate(batch)
+
+def extract(args):
+    out_dir=Path(args.out_dir); out_dir.mkdir(parents=True, exist_ok=True)
+    cfg=json.load(open(args.config))
+    ds, task_names=build_dataset(Path(args.data_dir), cfg)
+    indices=choose_balanced_indices(ds, args.max_per_task, args.seed)
+    print('dataset samples', len(ds), 'selected', len(indices), 'tasks', task_names, flush=True)
+    subset=Subset(ds, indices)
+    loader=DataLoader(subset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, pin_memory=True)
+    device=torch.device(args.device)
+    model=load_model(cfg, args.ckpt, device, len(task_names))
+    feats=[]; labels=[]; files=[]; timesteps=[]
+    with torch.no_grad():
+        for bi,batch in enumerate(loader):
+            visual_seq=batch['visual_seq'].to(device, non_blocking=True)
+            tactile_seq=batch['tactile_seq'].to(device, non_blocking=True)
+            action_seq=batch['action_seq'].to(device, non_blocking=True) if 'action_seq' in batch else None
+            visual_mask=batch['visual_mask'].to(device, non_blocking=True)
+            delta_steps=batch['delta_steps'].to(device, non_blocking=True) if 'delta_steps' in batch else None
+            task_id=batch['task_id'].to(device, non_blocking=True) if 'task_id' in batch else None
+            out=model(visual_seq, tactile_seq, action_seq, visual_mask, delta_steps=delta_steps, task_id=task_id)
+            # memory_context: B x num_tail_frames? or B x 1 x D. Flatten mean is stable for comparison.
+            f=out['memory_context'].detach().float()
+            if f.ndim>2: f=f.mean(dim=1)
+            feats.append(f.cpu().numpy())
+            labels.extend([task_names[int(x)] for x in task_id.detach().cpu().tolist()])
+            # map subset local batch rows back to ds samples
+            start=bi*args.batch_size
+            for j in range(len(task_id)):
+                s=ds.samples[indices[start+j]]
+                files.append(str(s['file']))
+                timesteps.append(int(s['timestep']))
+            print('batch', bi+1, 'features', sum(x.shape[0] for x in feats), flush=True)
+    X=np.concatenate(feats, axis=0)
+    Xs=StandardScaler().fit_transform(X)
+    perplexity=min(args.perplexity, max(5, (len(Xs)-1)//3))
+    Y=TSNE(n_components=2, perplexity=perplexity, init='pca', learning_rate='auto', random_state=args.seed, metric='euclidean').fit_transform(Xs)
+    np.savez(out_dir/f'{args.name}_features_tsne.npz', features=X, tsne=Y, labels=np.array(labels), files=np.array(files), timesteps=np.array(timesteps), task_names=np.array(task_names))
+    with open(out_dir/f'{args.name}_tsne.csv','w') as f:
+        f.write('x,y,task,file,timestep\n')
+        for (x,y),lab,fp,t in zip(Y,labels,files,timesteps):
+            f.write(f'{x},{y},{lab},{fp},{t}\n')
+    plt.figure(figsize=(7.2,6.0), dpi=220)
+    cmap=plt.get_cmap('tab10')
+    for k,task in enumerate(task_names):
+        m=np.array([l==task for l in labels])
+        plt.scatter(Y[m,0], Y[m,1], s=args.point_size, alpha=0.70, color=cmap(k%10), label=task, linewidths=0)
+    plt.title(f'{args.name}: ViTacDreamer memory-context t-SNE')
+    plt.xlabel('t-SNE 1'); plt.ylabel('t-SNE 2')
+    plt.legend(markerscale=2, fontsize=7, frameon=True)
+    plt.tight_layout()
+    plt.savefig(out_dir/f'{args.name}_tsne.png')
+    print('SAVED', out_dir/f'{args.name}_tsne.png', flush=True)
+
+if __name__ == '__main__':
+    ap=argparse.ArgumentParser()
+    ap.add_argument('--name', required=True)
+    ap.add_argument('--data_dir', required=True)
+    ap.add_argument('--ckpt', required=True)
+    ap.add_argument('--config', required=True)
+    ap.add_argument('--out_dir', default='outputs/tsne_scaling_20260728')
+    ap.add_argument('--device', default='cuda:4')
+    ap.add_argument('--batch_size', type=int, default=32)
+    ap.add_argument('--num_workers', type=int, default=4)
+    ap.add_argument('--max_per_task', type=int, default=250)
+    ap.add_argument('--perplexity', type=int, default=35)
+    ap.add_argument('--point_size', type=float, default=10.0)
+    ap.add_argument('--seed', type=int, default=42)
+    extract(ap.parse_args())