AffU Training Data — Inventory for Cluster Relocation
Purpose: catalog every dataset (and the bridging checkpoint) consumed by the three AffU training stages, with current filesystem locations and sizes, so the data can be moved to another cluster and the configs re-pointed with one edit.
Generated 2026-07-24 on the turbo cluster.
0. TL;DR — what has to move
There are two dataset source trees plus one bridge checkpoint:
| # | What | Current path | Size | Needed by |
|---|---|---|---|---|
| A | Visual Genome (alignment corpus) | /nfs/turbo/coe-jungaocv/wzn/workspace/AffU/dataset/genome/ |
66G total (MLP needs only the 712M region_descriptions.json) |
Stage 1 |
| B | AffU dataset root (seg + robot) | /nfs/turbo/coe-jungaocv-turbo2/wzn/datasets/AffU_datasets/ |
≈ 2,276 GiB (~2.3 TB) across the 5 used dirs — see §3, §4, §7 | Stage 2 & 3 |
| C | Alignment projector checkpoint | /nfs/turbo/coe-jungaocv-turbo2/wzn/AFUN_ckpt/outputs/qwen_projector_step_260000.pt |
3.5G | Stage 2 & 3 (as aligning_ckpt) |
Note the turbo1 vs turbo2 split: Stage-1 data lives in the workspace on turbo1
(coe-jungaocv), while Stage-2/3 data and all checkpoints live on turbo2
(coe-jungaocv-turbo2). A relocation must carry both.
1. How paths are resolved (the file to edit after moving)
The experiment configs do not hardcode dataset paths. They pull everything from a
single cluster file via Hydra interpolation (${paths.data_roots.*},
${paths.datasets}, ${paths.output}, ${paths.aligning_ckpt.*}).
configs/paths.yaml # defaults: [ cluster: turbo ] <-- selects the cluster
configs/cluster/turbo.yaml # the ACTIVE path map (turbo1 + turbo2) <-- source of truth
configs/cluster/delta.yaml # old NCSA/Delta path map (inactive)
configs/cluster/turbo.yaml currently defines:
paths:
workspace: /nfs/turbo/coe-jungaocv/wzn/workspace/AffU
datasets: /nfs/turbo/coe-jungaocv-turbo2/wzn/datasets/AffU_datasets
output: ${paths.workspace}/outputs
data_roots:
instruct_part: ${paths.datasets}/instruct_part
ragnet: ${paths.datasets}/RAGNet/data/data
hova500k: ${paths.datasets}/HOVA-500K
reasonaff: ${paths.datasets}/reasonaff/reasonaff
robot_final_filtered: ${paths.datasets}/final_dataset_filtered
# ... (affgrasp, agd20k, umd, robot, robot_open, robot_final, droid also defined but
# NOT used by the three stages below)
aligning_ckpt:
qwen3_vl_8b: ${paths.output}/qwen_projector_step_260000.pt
To move to a new cluster: add configs/cluster/<name>.yaml with the new
workspace / datasets roots, then change the one line in configs/paths.yaml
(cluster: <name>). Nothing else needs editing.
⚠️ Stale/ignored files — do not trust these:
configs/data/default/data_dir.yamlstill lists old Delta paths (/work/nvme/bgit/zwang96/...). It is not read by these configs — the${paths.*}interpolation wins. Ignore it (or delete it) during relocation.- The Stage-1
train_qwen_align_metaquery.pyand therobot/droiddata_roots still default to Delta paths; see the per-stage notes.
2. Stage 1 — Alignment (train_qwen_align_mlp.py)
Trains a small MLP projector that maps Qwen3-VL-8B text hidden states → SAM3 text-encoder embedding space. Only the projector is trained; Qwen and SAM3 are frozen.
| Script | src/models/llm/qwen_align/train_qwen_align_mlp.py |
| Dataset | Visual Genome — region_descriptions.json (region phrases only; no images used by the MLP variant) |
| Loader | RegionPhraseDataset (reads --json_path, extracts regions[].phrase) |
| Current path | /nfs/turbo/coe-jungaocv/wzn/workspace/AffU/dataset/genome/ (turbo1 workspace) |
| Output | qwen_projector_step_*.pt → the run that feeds Stages 2 & 3 is qwen_projector_step_260000.pt (3.5G) |
Contents of dataset/genome/ relevant to the stage:
| File / dir | Size | Role |
|---|---|---|
region_descriptions.json |
712M | phrase source (the only thing the MLP script reads) |
region_descriptions.json.zip |
127M | compressed copy (optional) |
VG_100K/, VG_100K_2/ |
(images) | only used by the train_qwen_align_metaquery.py variant |
images.zip, images2.zip |
9.7G + 5.5G | raw VG image archives (VG_100K dirs are already extracted; archives optional to move) |
Notes
- The MLP script's default
--json_pathalready points to the correct turbo location. - The alternate
train_qwen_align_metaquery.py(a Qwen-2B experiment; not the run that produced the consumed 260k checkpoint) still defaults--json_pathto the old Delta path/work/nvme/bgit/zwang96/datasets/genome/region_descriptions.jsonand also loadsVG_100K/images from the json's parent. Override--json_pathif you run it. - To move: minimum is
region_descriptions.json; addVG_100K*if you also run the metaquery variant. The twoimages*.ziparchives are redundant once VG_100K is present.
Re-download instead of copying (Visual Genome v1.2 — source URLs). The download URL was
never recorded in the repo (genome.ipynb only post-processes the JSON; dataset/download.py
is for the unrelated affogato dataset). The local files came from the official Visual Genome
v1.2 release — verified live, byte-for-byte identical to what's on disk:
| Local file | Size | Source URL |
|---|---|---|
region_descriptions.json.zip → region_descriptions.json |
127M zip / 712M json | https://homes.cs.washington.edu/~ranjay/visualgenome/data/dataset/region_descriptions.json.zip |
images.zip → VG_100K/ |
9.73G | https://cs.stanford.edu/people/rak248/VG_100K_2/images.zip |
images2.zip → VG_100K_2/ |
5.47G | https://cs.stanford.edu/people/rak248/VG_100K_2/images2.zip |
Download page: https://homes.cs.washington.edu/~ranjay/visualgenome/api.html.
Mirror (if the above are slow off-campus): HF dataset ranjaykrishna/visual_genome.
For Stage-1 MLP alignment you only need region_descriptions.json.zip (127M) — the image
zips are for the metaquery variant only.
3. Stage 2 — P0.71 (configs/p0.71-multi_source.yaml)
Segmentation-only stage. data: multi_source →
src.data.seg_multi_source.SegMultiSourceDataModule, which builds a dataloader for each
of four image datasets and interleaves them per step.
Datasets composed (configs/data/multi_source.yaml): instruct_part, ragnet,
hova500k, reasonaff (agibot and affgrasp are commented out).
…/AffU_datasets below = /nfs/turbo/coe-jungaocv-turbo2/wzn/datasets/AffU_datasets.
Only 4 of the ~88 entries in that folder are touched by this stage (see §7 for the
full used-vs-trash list). What each loader actually reads for its train split:
| Config key | Loader | Top-level dir used | What the train split reads inside it | Size |
|---|---|---|---|---|
instruct_part |
InstructPartDataset (split: train1800) |
instruct_part/ |
only train1800/{images, masks, data_train.json} (not test/, all/) |
14G |
ragnet |
RAGNetDataset (split: train, reasoning: [easy,hard]) |
RAGNet/data/data/ |
*_train.pkl for graspnet, egoobjects, openx, rlbench + handal_hard_reasoning_train.pkl + egoobjects_{easy,hard}_reasoning_train.pkl, and image dirs graspnet/ egoobjects/ openx/ rlbench/ HANDAL/. 3doi/ = eval-only (no train pkl). |
768G |
hova500k |
HOVA500KDataset (split: train) |
HOVA-500K/ |
subdirs 3doi/ Ego4D/ HANDAL/ + mask_annotation/ (index mask_annotation/dataset_index.json, 87 227 train / 419 test rows). epic-100/ and annotations/ are unused. |
844G |
reasonaff |
ReasonAFFDataset (split: train) |
reasonaff/reasonaff/ |
HuggingFace arrow dataset, train split (images embedded in the arrow shards) |
2.9G |
Path self-containment (matters for the move):
instruct_part,ragnet,reasonaffuse relative paths → moving the dirs is enough.- ⚠️
hova500kstores ABSOLUTE paths insidemask_annotation/dataset_index.json(e.g./nfs/turbo/coe-jungaocv-turbo2/wzn/datasets/AffU_datasets/HOVA-500K/3doi/images/…). After relocation the root prefix in that JSON must be rewritten (a one-linesed), or the loader willFileNotFoundError.
Weighting note (all four dirs are still required): the config sets only
weights: {hova500k: 50000}; any dataset without an explicit weight defaults to its own
sample count (seg_multi_source.py:71). So HOVA-500K dominates sampling, but loaders for
all four datasets are constructed at startup — every path above must exist after the move.
Also consumes: the Stage-1 projector via aligning_ckpt.qwen3_vl_8b (item C above).
4. Stage 3 — P0.84 (configs/p0.84-robot-sonata-geo-combined-v2.yaml)
Combined segmentation + robot-motion stage. data: combined →
src.data.combined.CombinedDataModule, which alternates each step between:
- segmentation — the same
SegMultiSourceDataModuleas Stage 2 (§3, all four datasets), and - robot —
src.data.RobotDataset.RobotDataset.
The robot root is overridden in this config to robot_final_filtered:
data:
robot:
data_dir: ${paths.data_roots.robot_final_filtered} # -> …/AffU_datasets/final_dataset_filtered
subset: null # use ALL sources present
| Component | Loader | Top-level dir used | Size |
|---|---|---|---|
| segmentation | SegMultiSourceDataModule |
same 4 dirs as Stage 2 (§3) | see §3 |
| robot | RobotDataset (subset: null, split: train) |
final_dataset_filtered/ only |
647G |
final_dataset_filtered/ is a self-contained, curated bundle. RobotDataset loads the
cached index meta.jsonl.gz (59 543 rows), whose file paths are relative and prepended
with data_dir at load (RobotDataset.py:587) → moving the dir is enough, no rewriting.
split: train keeps every row not in test ∪ val (RobotDataset.py:949).
Sources actually present as directories and trained on (per meta.jsonl.gz, after removing
121 test + 9 610 scenefun3d val rows):
| Source subdir | ~train rows |
|---|---|
scenefun3d/ |
~39 800 (49 382 − 9 610 val) |
robomind/ |
~4 440 |
droid/ |
~1 640 |
rh20t_human/ |
~630 |
agibot/ |
~610 |
rh20t/ |
186 |
calvin/ |
~105 |
rlbench/ |
12 |
Plus the bookkeeping files meta.jsonl.gz, splits.json, mllm_verify_output.json (all
required / used by the loader). The interval_*/metadata.json, sam_mask.png,
obs_frame.png, obs_frame_depth.npy, trajectory.json inside each episode are the actual
per-sample data.
Notes
meta.jsonl.gzalso lists avitrasource (2 432 rows) but there is novitra/directory infinal_dataset_filtered— those rows are stale and skipped at runtime.- The default
robotroot (process_result_debug_2) is a scratch/working dir and is NOT used by P0.84 — do not migrate it. Likewise the many siblingfinal_dataset*variants (_new,_archive,_opd,_large,_test, plainfinal_dataset) are not used — onlyfinal_dataset_filtered. - The in-config comment "use all sources (droid, rh20t_human)" is stale;
subset: nulladmits every source subdir listed above. - Also consumes: the Stage-1 projector via
aligning_ckpt.qwen3_vl_8b(item C).
5. The bridge checkpoint (item C) — path mismatch to fix
Stages 2 & 3 both load aligning_ckpt.qwen3_vl_8b, which resolves to
${paths.output}/qwen_projector_step_260000.pt =
/nfs/turbo/coe-jungaocv/wzn/workspace/AffU/outputs/qwen_projector_step_260000.pt.
⚠️ That outputs/ directory on turbo1 is currently empty — all checkpoints were moved
to turbo2 on 2026-06-03 (see …/AFUN_ckpt/MOVE_MANIFEST.txt). The actual file is:
/nfs/turbo/coe-jungaocv-turbo2/wzn/AFUN_ckpt/outputs/qwen_projector_step_260000.pt (3.5G)
Before/after relocation, either copy this file to wherever the new ${paths.output}
points, or update aligning_ckpt.qwen3_vl_8b (and the train.ckpt_path resume paths in
each config) to the checkpoint's real location.
6. Relocation checklist
- Copy the three sources (rsync/Globus), preserving internal structure:
…/AffU/dataset/genome/(or justregion_descriptions.json[+VG_100K*]) → new Stage-1 location…/AffU_datasets/(subset needed:instruct_part,RAGNet,HOVA-500K,reasonaff,final_dataset_filtered)…/AFUN_ckpt/outputs/qwen_projector_step_260000.pt
- Add
configs/cluster/<newname>.yamlwith the newworkspaceanddatasetsroots (copyturbo.yamland edit the two roots;data_rootsinterpolate automatically). - Flip
configs/paths.yaml→cluster: <newname>. - Fix
aligning_ckpt.qwen3_vl_8band each stage'strain.ckpt_pathto point at the moved checkpoint(s). - Sanity-check that every path in §2–§4 exists on the new cluster before launching.
7. Copy manifest for AffU_datasets/ — used vs. trash
The folder /nfs/turbo/coe-jungaocv-turbo2/wzn/datasets/AffU_datasets/ holds ~88
entries, but training Stages 2 & 3 touch only 5 of them. Everything else is raw source
data, abandoned experiments, archives, or scripts and does not need to move.
✅ COPY these 5 (all that Stage 2 & 3 read)
| Entry | Used by | Notes |
|---|---|---|
instruct_part/ |
Stage 2 & 3 | training only needs the train1800/ subdir |
RAGNet/ (→ RAGNet/data/data/) |
Stage 2 & 3 | relative paths; 3doi/ inside is eval-only |
HOVA-500K/ |
Stage 2 & 3 | ⚠️ rewrite absolute paths in mask_annotation/dataset_index.json; epic-100/ + annotations/ unused |
reasonaff/ (→ reasonaff/reasonaff/) |
Stage 2 & 3 | self-contained HF dataset |
final_dataset_filtered/ |
Stage 3 only | self-contained, relative paths; 8 robot source subdirs |
Total footprint of these 5 = ≈ 2,276 GiB (~2.3 TB):
HOVA-500K 844G · RAGNet 768G · robot final_dataset_filtered 647G · instruct_part 14G ·
reasonaff 2.9G. (+ Stage-1 genome: 66G, of which only 712M is read by the MLP aligner.)
❌ DO NOT need to copy (not read by Stage 2 or 3)
- Other robot-dataset experiments / scratch:
final_dataset/,final_dataset_filtered_new/,final_dataset_filtered_archive/,final_dataset_filtered_opd/,final_dataset_large/,final_dataset_test/,process_result_debug_2/,process_result_vitra_ego4d_noannot/,process_result_vitra_epic/,all_process_result/,droid_result/,droid_result_patch/,droid_task_filter/,robomind2/,RoboMIND2/ - Raw robot sources (the originals that were pre-processed into
final_dataset_filtered; not needed at train time):RH20T/,RLBench/,RLBench_512/,RoboMIND/,Calvin/,HOI4D/,HOI4D_data_downloads/,HOI4D_processed/,OakInk2/,HOCAP/,HOCap_toolkit/,FMB/,TACO/,VITRA-1M/,InternData-A1/,Egoscale/,JianZhangAI__A0-Dataset/,RAM/,roboset/,robocoin/,agibot/(empty),droid/,scenefun3d_val_test/ - Image datasets not in the current mix:
AffGrasp/,AGD20K/,UMD/ - Archives & loose files:
reasonaff.zip,calvin_debug_dataset.zip, and every*.py,*.ipynb,*.txt,*.sh,*.md,*.png, plus__pycache__/,.cursor/,.vscode/,vis/,README.md,requirements.txt
Trimming further inside the 5 used dirs is optional. The eval-only pieces (RAGNet
3doi/+*_val.pkl, HOVAtestrows +epic-100/, robottest/valrows) live in the same trees; keep them if you also run evaluation on the new cluster, drop them if you only need to train.
One-liner to copy just the used set
SRC=/nfs/turbo/coe-jungaocv-turbo2/wzn/datasets/AffU_datasets
DST=<new_cluster>/AffU_datasets
for d in instruct_part RAGNet HOVA-500K reasonaff final_dataset_filtered; do
rsync -a --info=progress2 "$SRC/$d" "$DST/"
done
# then, on the new cluster, fix HOVA's absolute paths:
# sed -i 's#/nfs/turbo/coe-jungaocv-turbo2/wzn/datasets/AffU_datasets#<new_root>#g' \
# "$DST/HOVA-500K/mask_annotation/dataset_index.json"
§7 above is the "copy everything" path. §8 below cuts the manual transfer by ~2/3 by re-downloading the public datasets and moving only what you actually produced.
8. Re-download from the internet vs. transfer manually
Most of the ~2.3 TB is public data you can re-download on the new cluster. You only need to hand-carry the files you generated (robot bundle, HOVA masks, the alignment ckpt).
🌐 Re-downloadable (public releases — nothing custom the loader needs)
| Dataset | Size | Where to get it |
|---|---|---|
| Visual Genome (Stage 1) | 66G | VG v1.2 URLs in §2 (verified byte-identical) |
| RAGNet | 768G | Public, but multi-source & non-trivial to re-assemble. HF dataset Dongming97/RAGNet (~37.7G) ships the affordance masks + reasoning .pkls; the large images (GraspNet‑1Billion, Open‑X, HANDAL, EgoObjects) come from their own sources per GitHub wudongming97/AffordanceNet → docs/dataset.md. Reproducing the loader's exact RAGNet/data/data/<src>/{images,masks} layout by hand is fiddly — if in doubt, move the assembled 768G tree instead (see §8 note). |
| HOVA-500K source images | ~494G used (of 777G) | HF JiaaZ/HOVA-500K — ships Ego4D/(247G) HANDAL/(238G) epic-100/(283G) 3doi(8.5G) annotations(58M). The download_RAGNet.py script in the folder already pulls this (misnamed). Only 3doi+Ego4D+HANDAL (~494G) are referenced by the index — epic-100 (283G) is unused, skip it. |
| InstructPart | 14G | project page zifuwan.github.io/InstructPart — train1800 = the paper's official 1,800-image train split. (Small; moving it is equally fine — see below.) |
| ReasonAFF | 2.9G | HF hqking/affordance-R1 (or the Google Drive link in the Affordance-R1 README). (Small; moving it is equally fine.) |
📦 Must transfer manually (you created / re-annotated these)
| Item | Size | Why it can't be re-downloaded |
|---|---|---|
robot final_dataset_filtered/ |
647G | Built by your data pipeline (SAM masks, trajectories, meta.jsonl, splits) |
HOVA-500K mask_annotation/ |
69G | Your SAM3-generated masks + dataset_index.json + query_gen_manifest.json, produced by data_process_afun_clean/mainprocess/02_sam3_mask_annotation.py. Not in the HF release. The loader reads mask_annotation/dataset_index.json for every HOVA sample. |
qwen_projector_step_260000.pt |
3.5G | Your Stage-1 alignment output |
Recommended: also just move the two small ones (instruct_part 14G + reasonaff 2.9G)
rather than re-download — they're tiny, and moving guarantees the exact folder/JSON layout
the loaders expect (train1800/data_train.json; the load_from_disk arrow dump) without
re-deriving splits.
Net effect
- Best case (re-download RAGNet + HOVA images + VG): manual ≈ 737 GB
(robot 647 + HOVA masks 69 + ckpt 3.5 + instruct_part 14 + reasonaff 2.9);
re-download ≈ RAGNet 768 + HOVA images ~494 + VG 66 ≈ 1.3 TB (skip HOVA
epic-100283G). - Pragmatic (also move RAGNet, since re-assembly is fiddly): manual ≈ 1.5 TB (add RAGNet 768); re-download shrinks to HOVA images ~494 + VG 66 ≈ 560 GB.
- Either way the only truly irreplaceable bytes are robot 647G + HOVA
mask_annotation/69G + ckpt 3.5G. RAGNet & the small seg sets are public; moving them is a convenience/robustness call.
⚠️ After both, on the new cluster rewrite the absolute paths in
HOVA-500K/mask_annotation/dataset_index.json to the new root (one sed, see §7) — the
re-downloaded images and the moved masks must resolve under the same new prefix.
Download commands (run on the new cluster)
ROOT=<new_datasets_root> # e.g. .../AffU_datasets
# export HF_TOKEN=... # if any HF repo is gated
# --- Visual Genome (Stage 1) ---
mkdir -p "$ROOT/../genome" && cd "$ROOT/../genome"
wget https://homes.cs.washington.edu/~ranjay/visualgenome/data/dataset/region_descriptions.json.zip
unzip region_descriptions.json.zip # <- all Stage-1 MLP needs
# images (only for the metaquery variant):
# wget https://cs.stanford.edu/people/rak248/VG_100K_2/images.zip && unzip images.zip
# wget https://cs.stanford.edu/people/rak248/VG_100K_2/images2.zip && unzip images2.zip
# --- HOVA-500K images (Stage 2&3) --- ~597G on HF; skip epic-100 (unused)
huggingface-cli download JiaaZ/HOVA-500K --repo-type dataset --local-dir "$ROOT/HOVA-500K" \
--include "3doi.tar.gz" "annotations.tar.gz" "Ego4D/*" "HANDAL/*"
cd "$ROOT/HOVA-500K"
tar xzf 3doi.tar.gz
# Ego4D/ and HANDAL/ ship as split archives (part_aa, part_ab, …). Reassemble + extract —
# CHECK the exact part names in the repo file list first (no official README):
cat Ego4D/part_* > Ego4D.tar.gz && tar xzf Ego4D.tar.gz
cat HANDAL/part_* > HANDAL.tar.gz && tar xzf HANDAL.tar.gz
# then MOVE your mask_annotation/ back in (see §9) and sed-fix dataset_index.json (see §7)
# --- RAGNet (Stage 2&3) --- annotations/masks from HF; images per official docs
huggingface-cli download Dongming97/RAGNet --repo-type dataset --local-dir "$ROOT/RAGNet_hf"
# images (GraspNet-1B / Open-X / HANDAL / EgoObjects): follow
# https://github.com/wudongming97/AffordanceNet -> docs/dataset.md
# NOTE: reproducing the loader's RAGNet/data/data/<src>/{images,masks} layout is multi-step.
# If that's not worth it, just MOVE the assembled 768G RAGNet/ (see §9) — guaranteed to work.
# --- InstructPart (14G) & ReasonAFF (2.9G): recommended to MOVE (see §9), or ---
# InstructPart: https://zifuwan.github.io/InstructPart/ (train1800 = official train split)
# ReasonAFF: HF `hqking/affordance-R1` (loader uses load_from_disk; moving avoids format drift)
9. Moving the data to a company S3 bucket
This cluster has rclone (~/miniconda3/bin/rclone), globus, hf/huggingface-cli
and pigz — but no aws CLI, and per policy we don't install into affu3-cu130.
So use rclone as the S3 client (or Globus if the bucket is a Globus S3 collection).
What actually needs to go to S3
S3 is both the backup and the transfer vehicle to the next cluster. Put in it only the self-made / hard-to-reassemble data (≈ 737 GB, or ≈ 1.5 TB if you also park RAGNet there):
final_dataset_filtered/647G · HOVAmask_annotation/69G ·qwen_projector_step_260000.pt3.5G → requiredinstruct_part/14G ·reasonaff/2.9G → recommended (tiny; avoids re-deriving layouts)RAGNet/768G → optional (only if you'd rather not re-assemble from upstream)- Public data (VG, HOVA images) → don't store unless you want a link-rot-proof company copy.
The one rule that matters: tar the small-file trees first
final_dataset_filtered/ and mask_annotation/ are hundreds of thousands of tiny files.
Uploading them as individual objects = millions of PUTs (slow, per-request cost, painful to
verify/restore). Bundle each tree into a few large objects — the loaders read relative paths,
so a tar that extracts back to the same folder restores the layout exactly. (Use plain tar, not
gzip: the payload is mostly already-compressed PNGs.)
Recommended flow (rclone)
# 1) one-time: configure the remote with company IAM keys (never commit them)
rclone config # n) new; name=company; type=s3; provider=AWS; region=<bucket-region>; keys from IT
BKT=company:<bucket>/affu
RC="rclone rcat --s3-chunk-size 256M --s3-upload-concurrency 8" # tune for throughput
# 2) stream each small-file tree straight to S3 (no local staging — turbo is space-tight)
for s in agibot calvin droid rh20t rh20t_human rlbench robomind scenefun3d; do
tar -C final_dataset_filtered -cf - "$s" | $RC "$BKT/datasets/final_dataset_filtered/$s.tar"
done
rclone copy final_dataset_filtered/meta.jsonl.gz "$BKT/datasets/final_dataset_filtered/"
rclone copy final_dataset_filtered/splits.json "$BKT/datasets/final_dataset_filtered/"
rclone copy final_dataset_filtered/mllm_verify_output.json "$BKT/datasets/final_dataset_filtered/" 2>/dev/null || true
tar -C HOVA-500K -cf - mask_annotation | $RC "$BKT/datasets/HOVA-500K/mask_annotation.tar"
tar -C . -cf - instruct_part | $RC "$BKT/datasets/instruct_part.tar"
tar -C reasonaff -cf - reasonaff | $RC "$BKT/datasets/reasonaff.tar"
# 3) large single files copy directly (rclone does multipart) + docs + checksums
rclone copy qwen_projector_step_260000.pt "$BKT/checkpoints/"
rclone copy docs/dataset_relocation.md "$BKT/docs/"
# build a sha256 manifest of the tars/ckpt and upload it for verification
(If you have scratch space, writing each .tar to disk then rclone copy is more resumable than
rcat; rcat holds only chunk_size × concurrency in RAM, so 256M×8 ≈ 2 GB.)
Suggested S3 layout
s3://<bucket>/affu/
datasets/final_dataset_filtered/{agibot.tar,…,scenefun3d.tar, meta.jsonl.gz, splits.json, mllm_verify_output.json}
datasets/HOVA-500K/mask_annotation.tar
datasets/instruct_part.tar
datasets/reasonaff.tar
datasets/RAGNet.tar # optional
checkpoints/qwen_projector_step_260000.pt
docs/dataset_relocation.md
MANIFEST.sha256
Restore on the new cluster
rclone copy company:<bucket>/affu/datasets/final_dataset_filtered "$ROOT/final_dataset_filtered"
cd "$ROOT/final_dataset_filtered" && for f in *.tar; do tar -xf "$f" && rm "$f"; done
# HOVA: re-download images (§8), then drop the moved masks back on top:
rclone copy company:<bucket>/affu/datasets/HOVA-500K/mask_annotation.tar "$ROOT/HOVA-500K/"
cd "$ROOT/HOVA-500K" && tar -xf mask_annotation.tar && rm mask_annotation.tar
sed -i 's#<old_root>#<new_root>#g' mask_annotation/dataset_index.json # §7
# verify: sha256sum -c MANIFEST.sha256
Alternatives & caveats
- Globus (most robust, hands-off): if the company bucket is exposed as a Globus S3 collection,
globus transferbetween the UMich turbo endpoint and the bucket auto-retries + checksums — ideal for the 0.7–1.5 TB haul without babysitting. Still tar the small-file trees first. - aws CLI also works (
tar … | aws s3 cp - s3://… --expected-size <bytes>), but it isn't installed here and we won't modifyaffu3-cu130; rclone needs no install. - Multipart ETags are not plain MD5 → verify with the sha256
MANIFEST, not the S3 ETag. - Deleting the source from turbo after upload won't free
dfspace for ~7 days (NetApp snapshots) — don't count on immediate reclaim. - Put the bucket in a region near the target compute; use S3 Standard-IA / Glacier-IR if it's cold backup.
If the two clusters can't reach each other or the company S3 (isolated networks), skip rclone→S3/Globus and use a public relay both clusters reach independently — see §10.
10. Isolated systems: relay through a public host (HuggingFace / Google Drive)
When there's no direct route between the two clusters (and S3/Globus aren't reachable), push the data to a public host from the source and pull it on the target. Both clusters already reach the internet (we pulled from Stanford/HF earlier — test with one small file first to be sure).
Only relay the self-made data (~0.7 TB). The public datasets (VG, HOVA images, RAGNet) should
be re-downloaded directly on the target from their sources (§8) — don't waste relay bandwidth/
quota on them. So the relay carries: robot final_dataset_filtered/ 647G + HOVA mask_annotation/
69G + ckpt 3.5G (+ optional instruct_part 14G, reasonaff 2.9G; + RAGNet 768G only if you won't
re-assemble it).
Same rule as S3, and now mandatory: tar + split the small-file trees. HF and Drive both
dislike huge file counts, and HF caps single files (~50 GB). Bundle each tree into a tar, split
into ≤40 GB shards.
Ready-to-run:
scripts/relocation/tar_relocation.slurm(Great Lakes SLURM array) produces exactly these 40 GB shards + per-unit.sha256intoAffU_datasets/relocation_tars/. Submit + finalize + upload + restore steps are inscripts/relocation/README.md.
Primary: private HuggingFace dataset repo (you're already logged in as Zhaoningw)
# --- SOURCE cluster ---
hf repo create Zhaoningw/affu-relocation --repo-type dataset --private # PRIVATE: robot data is proprietary
STAGE=/scratch/with/space/affu_relay; mkdir -p "$STAGE" # needs room for the tars
for s in agibot calvin droid rh20t rh20t_human rlbench robomind scenefun3d; do
tar -C final_dataset_filtered -cf - "$s" | split -b 40G -d -a3 - "$STAGE/robot_$s.tar."
done
cp final_dataset_filtered/{meta.jsonl.gz,splits.json,mllm_verify_output.json} "$STAGE/" 2>/dev/null || true
tar -C HOVA-500K -cf - mask_annotation | split -b 40G -d -a3 - "$STAGE/hova_mask_annotation.tar."
tar -C . -cf - instruct_part | split -b 40G -d -a3 - "$STAGE/instruct_part.tar."
tar -C reasonaff -cf - reasonaff > "$STAGE/reasonaff.tar"
cp qwen_projector_step_260000.pt "$STAGE/"
( cd "$STAGE" && sha256sum * > MANIFEST.sha256 )
hf upload-large-folder Zhaoningw/affu-relocation "$STAGE" --repo-type dataset --private # resumable; run in tmux
# --- TARGET cluster (hf auth login with the same token first) ---
hf download Zhaoningw/affu-relocation --repo-type dataset --local-dir "$STAGE"
cd "$STAGE" && sha256sum -c MANIFEST.sha256
for s in agibot calvin droid rh20t rh20t_human rlbench robomind scenefun3d; do
cat robot_$s.tar.* | tar -C "$ROOT/final_dataset_filtered" -xf -
done
cp meta.jsonl.gz splits.json mllm_verify_output.json "$ROOT/final_dataset_filtered/" 2>/dev/null || true
cat hova_mask_annotation.tar.* | tar -C "$ROOT/HOVA-500K" -xf -
cat instruct_part.tar.* | tar -C "$ROOT" -xf -
tar -C "$ROOT/reasonaff" -xf reasonaff.tar
# then re-download the public sets (§8) and sed-fix HOVA's dataset_index.json (§7)
hf repo delete Zhaoningw/affu-relocation --repo-type dataset # remove proprietary data from HF when done
⚠️ HF storage quota is the catch: private storage counts against your plan and ~0.7–1.5 TB
private likely needs HF Pro/Enterprise or an org storage grant — check before pushing.
Keep the repo private (robot data is proprietary) and delete it after the target has the
data. upload-large-folder keeps a local .cache so interrupted uploads resume.
Alternative: Google Drive (company Workspace shared drive) via rclone
Good if your Workspace shared drive has more room than your HF plan. Same tar+split first.
# one-time auth (headless cluster has no browser):
# run `rclone authorize "drive"` on a laptop, paste the token into `rclone config`;
# OR (best for headless/automation) have a Workspace admin make a service account + share a Shared Drive.
GD=gdrive:affu_relocation
for f in "$STAGE"/*; do rclone copy "$f" "$GD/"; done # or stream: tar … | rclone rcat "$GD/<name>.tar"
# target: rclone copy "$GD" "$STAGE" then reassemble/extract as above.
⚠️ Google Drive has a ~750 GB/day per-account upload cap → ~1 day for 0.7 TB, ~2 for 1.5 TB. Single-file limit is 5 TB (tars fine). rclone auto-retries; run in tmux.
Which to use
- HuggingFace — least setup (already authed,
upload-large-folderpresent, ML-native, resumable). Blocker is only private-storage quota. - Google Drive — better if Workspace storage is roomier than your HF plan; costs you the OAuth/ service-account setup and the 750 GB/day cap.
- Either way: relay only the ~0.7 TB self-made data, verify with the sha256
MANIFEST, and re-download the public sets on the target.