Aak975/iclr-wm-backup

ICLR Watermark Benchmark — Full Backup & Restore Guide

Private backup of the ICLR watermark-benchmark project (iclr_dataset/), created 2026-07-29 from the Monash MASSIVE M3 cluster (/fs04/scratch2/rb56/paru0005/anubhav/iclr_dataset).

• Data here: ~454 GB — datasets, model checkpoints, all experiment runs, the curated benchmark, and the GPG-encrypted watermark keys.
• Code lives on GitHub: katariaak579/iclr-wm-benchmark (private). Code + this data together = the complete original project.
• ⚠️ Keep this repo PRIVATE at least until the paper is public (double-blind review + secret watermark keys).

Two-repo union (since 2026-08-01). This private repo hit its storage quota, so newer archives live in the PUBLIC companion repo Aak975/iclr-wm-backup-public with the exact same layout. Every file exists in exactly one of the two repos (the backup script checks both before uploading). A full restore reads both — restore_hf.sh does this by default. The public repo holds only shareable image data (no keys, no draft).

---

Repo layout

direct/            Small/live dirs stored AS-IS (browse them directly):
                     post_hoc/ in_generation/ attacks/ benchmark/ docs/
                     prompts/ iclr_draft/ ppt/ scripts/ interpol_website/
                     PerceptualSimilarity/
archives/          Big trees stored as COMPRESSED TAR STREAMS split into 4 GB parts:
                     <name>/part-0000, part-0001, ..., MANIFEST.json
                   MANIFEST.json = {"parts": N, "sha256": <whole-stream>, "total_bytes": M}
                   Rebuild any one of them with:  cat part-* | zstd -d | tar -x
     base_dataset/<entry>/          -> extracts into  base_dataset/
     benchmark_staging/<split>/     -> extracts into  benchmark/staging/
     runs/<run>/                    -> extracts into  runs/            (small runs)
     runs/<run>/out_img/<method>/   -> extracts into  runs/<run>/out_img/  (big runs)
     runs/README.md, runs/MIGRATION_LOG.md, ...   (loose files, stored as-is)
keys/              keys_private_YYYYMMDD.tar.gz.gpg — GPG-encrypted secret keys
restore.sh         The automated restore script (same as scripts/backup/restore_hf.sh in git)

---

Full automated restore (recommended)

Rebuilds the complete original directory structure — every file, verified.

0. Prerequisites on the target machine

• ~900 GB free disk (compressed downloads + extracted data during restore)
• python3, tar, zstd, gpg (all standard on Linux)
• Hugging Face CLI + login:

python3 -m pip install -U "huggingface_hub[cli]"
hf auth login        # paste a token from https://huggingface.co/settings/tokens
                     # (a "read" token is enough for restoring)

1. Clone the code from GitHub

git clone git@github.com:katariaak579/iclr-wm-benchmark.git iclr_dataset
cd iclr_dataset

2. Run the restore script INTO the clone

bash scripts/backup/restore_hf.sh "$PWD"   # restores BOTH repos (private + public) by default

(No GitHub access? Download the same script from this repo instead: hf download Aak975/iclr-wm-backup restore.sh --repo-type dataset --local-dir . then bash restore.sh /path/to/iclr_dataset.)

The script, in order:

1. downloads all of direct/ and copies it into the destination (as-is dirs);
2. lists every archives/*/MANIFEST.json, downloads that archive's part-* files, verifies the sha256 of the reassembled stream against the manifest, and only then extracts it to its correct original location (mapping table above);
3. copies the loose archives/runs/* files (README, migration log, old pilot archive);
4. prints CHECKSUM MISMATCH / DOWNLOAD FAILED / EXTRACT FAILED lines for anything that goes wrong — a clean run prints none of these.

Expect several hours for ~454 GB (network-bound). Run it inside tmux/screen so a dropped connection doesn't kill it. Re-running is safe — it overwrites with identical verified content (it does not skip already-restored archives, so a re-run repeats the whole download).

3. Decrypt the watermark keys

hf download Aak975/iclr-wm-backup keys/keys_private_20260729.tar.gz.gpg \
    --repo-type dataset --local-dir .
gpg -d keys/keys_private_20260729.tar.gz.gpg | tar xzf -   # asks for the passphrase
rm -r keys/

This recreates keys_private/. Without the passphrase the keys are unrecoverable.

4. Re-clone the third-party repos

The 17 nested clones (post_hoc/third_party/*, PRC-Watermark, T2SMark, …) are not in this backup as git repos — PINNED_REPOS.md in the code repo lists each one's URL + exact commit. Clone and check out each as needed. Their working trees (including local edits) ARE in direct/, so copy any locally modified files over the fresh clones (the pin table flags which have edits).

5. Recreate conda environments

Recipes for all 43 envs are in the code repo under envs/:

conda env create -f envs/<name>/environment.yml
# exact pip pins, if needed:  pip install -r envs/<name>/requirements.txt

6. Clean up

rm -rf .hf_restore     # the restore script's download staging dir

---

Restoring just ONE thing (manual)

Any single archive, without the script — e.g. one run's vine outputs:

P=archives/runs/2026-07-27_posthoc-mfv-real/out_img/vine
hf download Aak975/iclr-wm-backup --repo-type dataset --include "$P/**" --local-dir .
cat $P/part-* | sha256sum          # compare with "sha256" in $P/MANIFEST.json
cat $P/part-* | zstd -d | tar -x   # extracts the 'vine/' directory here

If the archive isn't in this repo, it's in the public companion — same commands with Aak975/iclr-wm-backup-public.

Anything under direct/ needs no unpacking — download and use:

hf download Aak975/iclr-wm-backup --repo-type dataset \
    --include "direct/post_hoc/**" --local-dir .

---

Integrity notes

• Every archive's MANIFEST.json holds the sha256 of the whole uncompressed-tar stream (i.e. of cat part-*), computed at backup time on the source machine.
• A restore test was performed 2026-07-30: one archive re-downloaded, checksum matched, extracted files compared diff -rq against the originals — identical.
• benchmark/staging/ was 106 GB of images hardlinked from runs/ on the source; after restore they are independent copies (the dedup is lost, content identical).