# 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:

```yaml
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.yaml` still 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.py` and the `robot`/`droid` data_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_path` already 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_path` to the old
  Delta path `/work/nvme/bgit/zwang96/datasets/genome/region_descriptions.json` and also
  loads `VG_100K/` images from the json's parent. Override `--json_path` if you run it.
- To move: minimum is `region_descriptions.json`; add `VG_100K*` if you also run the
  metaquery variant. The two `images*.zip` archives 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`, `reasonaff` use **relative** paths → moving the dirs is enough.
- ⚠️ **`hova500k` stores ABSOLUTE paths** inside `mask_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-line `sed`), or the
  loader will `FileNotFoundError`.

**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 `SegMultiSourceDataModule` as Stage 2 (§3, all four datasets), and
- **robot** — `src.data.RobotDataset.RobotDataset`.

The robot root is **overridden** in this config to `robot_final_filtered`:

```yaml
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.gz` also lists a **`vitra`** source (2 432 rows) but there is **no `vitra/`
  directory** in `final_dataset_filtered` — those rows are stale and skipped at runtime.
- The default `robot` root (`process_result_debug_2`) is a scratch/working dir and is
  **NOT** used by P0.84 — do not migrate it. Likewise the many sibling `final_dataset*`
  variants (`_new`, `_archive`, `_opd`, `_large`, `_test`, plain `final_dataset`) are **not**
  used — only `final_dataset_filtered`.
- The in-config comment "use all sources (droid, rh20t_human)" is stale; `subset: null`
  admits 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

1. **Copy the three sources** (rsync/Globus), preserving internal structure:
   - `…/AffU/dataset/genome/`  (or just `region_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`
2. **Add** `configs/cluster/<newname>.yaml` with the new `workspace` and `datasets` roots
   (copy `turbo.yaml` and edit the two roots; `data_roots` interpolate automatically).
3. **Flip** `configs/paths.yaml` → `cluster: <newname>`.
4. **Fix** `aligning_ckpt.qwen3_vl_8b` and each stage's `train.ckpt_path` to point at the
   moved checkpoint(s).
5. 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`, HOVA `test` rows + `epic-100/`, robot `test`/`val` rows) 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

```bash
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 `.pkl`s**; 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-100` 283G).
- **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)

```bash
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 · HOVA `mask_annotation/` 69G · `qwen_projector_step_260000.pt` 3.5G  → **required**
- `instruct_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)
```bash
# 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
```bash
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 transfer` between 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 modify `affu3-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 `df` space 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 `.sha256` into
> `AffU_datasets/relocation_tars/`. Submit + finalize + upload + restore steps are in
> `scripts/relocation/README.md`.

### Primary: private HuggingFace dataset repo  *(you're already logged in as `Zhaoningw`)*
```bash
# --- 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.
```bash
# 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-folder` present, 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.