test_3am_simulations

Marvelous Designer cloth simulations for the physics-parameter ablation and the geometry baseline study. Produced with image2garment/md-automation.

The run is complete: 40 picks × 3 sequences = 678 simulations, distributed as 40 Parquet shards, one per pick.

Added 2026-10-11/12: rule_based_gpt56/ — the rule-based fabric estimate from the gpt56luna v4 per-generation predictions on ChatGarment geometry (40 picks × 3 = 120 sims) and on AIpparel geometry (26 picks × 3 = 78 sims), 198 sims in 40 shards; and rule_based_gpt6/ — the same with the gpt6sol v4 per-generation predictions (198 sims, 40 shards). See The rule-based arms below.

Replaced 2026-10-13: rule_based_gpt6_gt/ — the gpt6 rule-based fabric on ground-truth geometry, continued from the hub gt simulation's own frame-42 state (40 picks × 3 = 120 sims, 40 shards of 3 rows), so the rule-based method can join the physics-parameter ablation. Use jumping_jack and joyful_jump; treat hit_reaction as unreliable — see The rule-based arms. (The shards uploaded 2026-10-12 under this name were settled with the gpt6 fabric from frame 0 and are gone.)

Physics protocol change (2026-10-15): every arm uses its FULL 18-parameter prediction. The root-level shards (gt, tabpfn, MC) were simulated with only the 8 stiffnesses varied — thickness and weight held at the garment's ground truth, buckling 0 — while the rule-based arms bind all 18 of their own parameters. The two protocols are not comparable, so from now on every arm takes all 18 parameters (8 stiffnesses, 8 buckling, thickness, weight) from its own source CSV; friction 0.03 and internal damping 0.0001 stay the only shared constants. This applies to gt too: its CSV carries real buckling, so the gt__gt reference and every arm branched from it must be re-simulated. The existing root-level shards are the old protocol and are kept for the record. See Physics below for the source CSVs.

Superseded: rule_based/ (added 2026-10-10, cg 120 + ai 78 sims). The CSV it was simulated from carried an upstream bug; it is kept for the record, do not use it for new comparisons. Use rule_based_gpt56/ / rule_based_gpt6/.

The garment meshes, avatar motions, images and manifests that these were simulated from live in image2garment/test_3am. This repo holds the simulation output only, split out because 55 GB does not fit in that dataset's storage.

Layout

test_3am_simulations/
├── README.md
├── <pick_id>.parquet                    40 shards, ~55 GB  (gt/gp/cg/ai × gt/tabpfn/MC)
├── rule_based_gpt56/<pick_id>.parquet   40 shards, ~7.3 GB (cg and ai × rule_based_gpt56)
├── rule_based_gpt6/<pick_id>.parquet    40 shards, ~7.3 GB (cg and ai × rule_based_gpt6)
├── rule_based_gpt6_gt/<pick_id>.parquet 40 shards, ~4.3 GB (gt × rule_based_gpt6, from the gt run's frame 42)
└── rule_based/<pick_id>.parquet         40 shards, ~7.1 GB (cg and ai × rule_based) — SUPERSEDED

Example: row_006_m06__sample_03.parquet

One shard holds one pick across all three sequences — a complete garment run, self-contained. There is no per-sequence folder: the sequence is a column.

Reading a shard

The .abc bytes are lzma-compressed inside a blob column. The Parquet codec is NONE, so nothing is compressed twice — decompress the blob yourself:

import pyarrow.parquet as pq, lzma
t = pq.read_table("row_006_m06__sample_03.parquet")
for r in t.to_pylist():
    open(r["filename"], "wb").write(lzma.decompress(r["data"]))

To fetch one shard without cloning the repo:

from huggingface_hub import hf_hub_download
p = hf_hub_download("image2garment/test_3am_simulations",
                    "row_006_m06__sample_03.parquet", repo_type="dataset")

read_table pulls the whole shard (0.7–2.2 GB) into memory. To take one arm instead, filter before touching data:

t = pq.read_table(p, filters=[("sequence", "=", "hit_reaction"),
                              ("source", "=", "gt")])

Schema

column	type
sequence	string	jumping_jack | joyful_jump | hit_reaction
pick_id	string	row_XXX_mYY__sample_ZZ, the key used in chosen.json
garment_id	string	the garment this pick is a sample of
source	string	gt, gp (GarmentParticles), cg (ChatGarment), ai (AIpparel)
material	string	gt, tabpfn, MC; rule_based_gpt56 / rule_based_gpt6 / rule_based in the folders of the same name only (rule_based_gpt6 also in rule_based_gpt6_gt/)
filename	string	original .abc name, <pick_id>__<source>__<material>.abc
raw_bytes	int64	size of the .abc after decompression
sha256	string	checksum of the raw .abc, to verify a round trip
codec	string	always xz
data	binary	the lzma-compressed .abc

Why a blob and not columns. Parquet is used here as a container, not as a smarter encoding: the vertex arrays are not turned into columns. What it buys is commit count — 678 files became 40 objects, and it was the per-file commit rate, not bandwidth, that rate-limited the hub. Measured on this data lzma reaches ~41% of raw where the zstd/gzip Parquet codecs manage ~76%: the .abc payload is raw float32 vertex positions with no internal compression, and MD's OBJ round trip unwelds the mesh (see below), so every vertex is duplicated several times — that is the redundancy lzma finds and zlib does not. 134 GB of Alembic ships as 55 GB.

Sequences

sequence	window	fps	warp	files
jumping_jack	0-42-174	24	1.0	226
joyful_jump	0-42-133	30	1.0	226
hit_reaction	0-42-120	30	1.0	226

Contents: 40 garment runs

Each pick is complete in all three sequences, so the set is balanced — 226 per sequence, no sequence better represented than another. Picks are in chosen.json order.

AIpparel = no means AIpparel has no mesh for that pick, so it has 15 files instead of 18 (5 arms × 3 sequences rather than 6).

#	pick_id	garment_id	material	AIpparel	files
1	row_006_m06__sample_03	0ZMJK5D8GF	m06	yes	18
2	row_020_m20__sample_01	47GX4AL9CW	m20	no	15
3	row_026_m06__sample_03	5UQT5D3GWQ	m06	no	15
4	row_027_m07__sample_01	5XUIW0BVER	m07	no	15
5	row_027_m07__sample_04	5XUIW0BVER	m07	no	15
6	row_033_m13__sample_03	7UHW3P9FDA	m13	yes	18
7	row_038_m18__sample_01	9CK9801YTS	m18	no	15
8	row_040_m20__sample_03	9LQR1ELV5V	m20	yes	18
9	row_053_m13__sample_01	CGMSPNB6ZB	m13	no	15
10	row_054_m14__sample_02	CLZ2L25QH8	m14	yes	18
11	row_056_m16__sample_01	DCDK2TTQPC	m16	yes	18
12	row_058_m18__sample_04	DUNXPF4ZQM	m18	no	15
13	row_060_m20__sample_02	EDEAY9A5AF	m20	yes	18
14	row_068_m08__sample_04	GGF1UUIB8M	m08	yes	18
15	row_069_m09__sample_03	GJ00AR2CVT	m09	yes	18
16	row_069_m09__sample_04	GJ00AR2CVT	m09	yes	18
17	row_070_m10__sample_05	GRVZM5PTQF	m10	yes	18
18	row_073_m13__sample_03	H4ADIVTACP	m13	yes	18
19	row_074_m14__sample_04	H6508EJEBO	m14	yes	18
20	row_075_m15__sample_02	I401ZB4ZDO	m15	yes	18
21	row_078_m18__sample_05	IQIEWFB5NQ	m18	yes	18
22	row_080_m20__sample_01	IYRPB6LZSM	m20	no	15
23	row_088_m08__sample_03	MBXA8UUSWK	m08	yes	18
24	row_089_m09__sample_02	MK9JDQNUUA	m09	yes	18
25	row_094_m14__sample_04	NFJLWW62UQ	m14	no	15
26	row_096_m16__sample_01	O2XZTKHKKO	m16	yes	18
27	row_098_m18__sample_05	OCSFYACZ4Z	m18	no	15
28	row_109_m09__sample_02	Q5MQYT7LZC	m09	no	15
29	row_110_m10__sample_04	Q7I16U76OA	m10	no	15
30	row_114_m14__sample_04	QMN5SJ0ILQ	m14	yes	18
31	row_116_m16__sample_02	QY4SXMMD9K	m16	yes	18
32	row_120_m20__sample_01	RFIBG05E6X	m20	yes	18
33	row_120_m20__sample_04	RFIBG05E6X	m20	yes	18
34	row_126_m06__sample_02	RVSNNS79DM	m06	yes	18
35	row_134_m14__sample_01	TUUWXCGV5K	m14	yes	18
36	row_138_m18__sample_01	U3IRY3HS45	m18	yes	18
37	row_150_m10__sample_04	WGA5YPU2LQ	m10	yes	18
38	row_154_m14__sample_04	XLP1M3L6YM	m14	yes	18
39	row_162_m02__sample_03	ZEV9PV0KM1	m02	no	15
40	row_162_m02__sample_05	ZEV9PV0KM1	m02	no	15

Things to know before treating these as 40 independent samples:

• Four garments appear twice — 5XUIW0BVER (#4, #5), GJ00AR2CVT (#15, #16), RFIBG05E6X (#32, #33), ZEV9PV0KM1 (#39, #40). Each pair is two geometry samples of the same garment, not two garments. The 40 picks cover 36 unique garments.
• Material classes are not uniform: m14 and m20 have 6 picks each and m09 has 4, while m15 has 1 and m02/m07/m08 have 2. Aggregating by material class is unbalanced.
• 14 of the 40 have no AIpparel arm, so any AIpparel comparison runs on 26.

What a garment run contains

One garment run = one pick simulated in all three sequences. Per pick per sequence, up to six simulations:

Physics ablation — geometry fixed (gt), material varied:

source	material
gt	gt	ground-truth physics
gt	tabpfn	TabPFN prediction
gt	MC	MC baseline

These three share one scene: the anchor records frames 0→END with the gt material; the other two scrub back to frame 42, are verified against the anchor's frame-42 mesh, swap fabric, and re-record 42→END. So frames 0-42 are identical across the three by construction, and any difference after frame 42 is the material alone.

Baseline study — material fixed, geometry varied:

source	material	geometry
gp	tabpfn	GarmentParticles
cg	MC	ChatGarment
ai	MC	AIpparel

Each is its own scene with its own anchor, since the geometry differs.

The two studies are very unevenly sized: the physics ablation is 48.4 GB (the gt meshes are full resolution) against 6.7 GB for the whole baseline study. Filter on source before pulling data if you only need one of them.

ai is missing for 14 of the 40 picks — AIpparel's sewing pattern either did not generate or did not drape on mean_all. Those picks have five arms per sequence, not six. This is a property of the source data, not a filter applied here.

pick_id	garment_id	material	tier
row_020_m20__sample_01	47GX4AL9CW	m20	SFM
row_026_m06__sample_03	5UQT5D3GWQ	m06	SF
row_027_m07__sample_01	5XUIW0BVER	m07	SF
row_027_m07__sample_04	5XUIW0BVER	m07	SF
row_038_m18__sample_01	9CK9801YTS	m18	SF
row_053_m13__sample_01	CGMSPNB6ZB	m13	SF
row_058_m18__sample_04	DUNXPF4ZQM	m18	SF
row_080_m20__sample_01	IYRPB6LZSM	m20	SFM
row_094_m14__sample_04	NFJLWW62UQ	m14	SF
row_098_m18__sample_05	OCSFYACZ4Z	m18	SF
row_109_m09__sample_02	Q5MQYT7LZC	m09	SF
row_110_m10__sample_04	Q7I16U76OA	m10	SF
row_162_m02__sample_03	ZEV9PV0KM1	m02	SFM
row_162_m02__sample_05	ZEV9PV0KM1	m02	SFM

Two garments lose both their picks (5XUIW0BVER, ZEV9PV0KM1), so they have no AIpparel representation at all. Material classes m18 (4 picks) and m20 (3 picks) are the worst hit — worth checking before reading anything into an AIpparel-vs-other comparison aggregated by material class.

The rule-based arms (rule_based_gpt56/, rule_based_gpt6/; rule_based/ superseded)

rule_based_gpt56/ — added 2026-10-11

ChatGarment and AIpparel geometry, mean_all, source = cg or ai, material = rule_based_gpt56, filename = <pick_id>__<source>__rule_based_gpt56.abc. Physics per pick from physics_predictions_chatgarment_rb_gpt56luna_v4_per_generation.csv (sha256 8d3f29ba3576ea4d…), keyed on the pick id. Same definition as the arm below: all 18 estimated parameters from the CSV (8 stiffness, 8 buckling, thickness, weight), no ground-truth value anywhere, friction 0.03 and internal damping 0.0001 fixed. Same 40 picks, bases, fps / warp / window / Fitting quality as the rest of the dataset. 6 rows per shard (cg + ai × 3 sequences) for the 26 picks AIpparel has a mesh for, 3 rows (cg only) for the other 14 — the same 14 as everywhere else in this dataset. cg: 120 of 120 completed, no run fell. ai: 78 of 78 completed, one flagged fall, kept per the study rule: row_089_m09__sample_02__ai__rule_based_gpt56 (joyful_jump) from frame 96 — the same pick that fell under rule_based/. Every bind read back on 18 keys at rtol 1e-4, every Alembic read back in Blender (one mesh, source face count, 97 / 175 / 107 samples). MD crashed once during the cg batch (after the row_088 joyful_jump export); that pick was re-simulated on a fresh MD, nothing else was affected. 36 of the 40 picks have physics that differ from rule_based/; row_027 (×2) and row_162 (×2) are identical to it.

rule_based_gpt6/ — gpt6sol v4 per-generation predictions

Same as above with material = rule_based_gpt6 and physics_predictions_chatgarment_rb_gpt6sol_v4_per_generation.csv (sha256 779a81c4d17d44d5…), cg and ai, 6 / 3 rows per shard as above. cg: 120 of 120 completed, no run fell. ai: 78 of 78 completed (MD crashed once mid-batch, after the row_096 jumping_jack export; that pick was re-simulated on a fresh MD), one flagged fall, kept: row_089_m09__sample_02__ai__rule_based_gpt6 (joyful_jump) from frame 60 — the same pick falls under all three rule-based arms. Same verification as above (18-key bind read-back, Blender read-back of every file). 35 of the 40 picks have physics that differ from rule_based/; gpt56 and gpt6 differ from each other on 18 picks.

rule_based_gpt6_gt/ — gpt6 physics on GT geometry, from the gt run's frame 42 (2026-10-13)

source = gt, material = rule_based_gpt6, filename = <pick_id>__gt__rule_based_gpt6.abc, 3 rows per shard (one per sequence), all 40 picks. The fabric for each pick is byte-identical to the one its rule_based_gpt6/ cg and ai runs used (all 18 parameters from the gpt6sol CSV, friction 0.03, internal damping 0.0001; read back out of MD at rtol 1e-4).

How each run was made — the gt garment is NOT re-simulated.

1. The root-level <pick>__gt__gt.abc of this repo is read and the garment at MD frame 42 is extracted. MD writes Alembic on a 24 fps clock, so MD frame 42 is sample 42 for jumping_jack (24 fps) and sample 33.6 for hit_reaction / joyful_jump (30 fps; samples 33 and 34 blended 0.4 / 0.6). Checked on one pick per sequence: the root-level tabpfn arm equals gt at that sample (≤ 0.0001 mm) and departs after it, i.e. this is the arms' shared branch state.
2. The mesh is written as the source garment_sim.obj with only its vertex positions replaced — UVs, normals, faces and vertex order kept verbatim (the Alembic's UVs match the source to 1e-7; matched vertex by vertex through them).
3. In MD: base scene → frame 42 → import that OBJ as the garment → bind the gpt6 fabric → no settle → record 42 → END at Fitting quality → export.

Frame window. Score from MD frame 42 on: Alembic frame ≥ 42 for jumping_jack, ≥ 34 for the others. Before that the file holds the imported frame-42 shape, static. jumping_jack / joyful_jump files start at frame 1 (not 0); frame 42 is still frame 42 (checked: 0.00 mm against the gt run).

Restart control — read before using hit_reaction. The same restart with the GT fabric (one pick, row_162_m02__sample_05) measures what restarting from an OBJ costs on its own (no carried velocity; the frame-42 shape becomes the rest shape). Mean nearest-point distance to the root-level gt run, mm:

sequence	restart, GT fabric (control)	restart, gpt6 (this arm)	root tabpfn branch
jumping_jack, end	30.4	53.2	26.0
joyful_jump, end	15.4	19.9	17.5
hit_reaction, end	50.2	54.5	13.5
hit_reaction, 2 samples after the branch	45.3	48.1	1.8

In jumping_jack and joyful_jump the control tracks the gt run as closely as the tabpfn branch does, so the restart is clean and the gap to gt is the material. In hit_reaction the restart itself blows up: even with the GT fabric the cloth moves 70–150 mm per sample right after the restart (the gt run moves ~6 mm). Not the avatar (matches the gt scene's to 0.0 mm), not the branch frame (restarting at 44 does the same), not the strain at frame 42 (no larger than jumping_jack's). Cause unresolved; the hit_reaction rows are kept but do not measure the material.

120 of 120 completed (one MD crash mid-batch, after an export; that pick was redone on a fresh MD). One flagged fall, kept: row_069_m09__sample_03 hit_reaction from frame 66. Every Alembic read back in Blender (one mesh, source face count). Raw 5.35 GB → 4.27 GB.

rule_based/ — added 2026-10-10, SUPERSEDED

Simulated from chatgarment_rule_based_physics_parameters.csv (sha256 41091df96bef02cc…), which was later found to carry an upstream bug. Kept for the record only. The description below is as written at upload time.

ChatGarment and AIpparel geometry, mean_all, simulated with the rule-based fabric estimate instead of the MC baseline: source = cg or ai, material = rule_based, filename = <pick_id>__<source>__rule_based.abc. Same 40 picks, same three sequences, same bases, same fps / warp / window / Fitting quality as the rest of this dataset (re-measured on the same base files before the run). One shard per pick, identical schema and codec to the root shards: 6 rows (cg + ai × 3 sequences) for the 26 picks AIpparel has a mesh for, 3 rows (cg only) for the 14 it does not — the same 14 listed above, so ai coverage is 26 picks here too:

p = hf_hub_download("image2garment/test_3am_simulations",
                    "rule_based/row_006_m06__sample_03.parquet", repo_type="dataset")

Its physics is defined differently from the other three materials, on purpose. gt, tabpfn and MC hold thickness and weight at the garment's ground-truth class values with buckling 0.0 and vary only the eight stiffnesses. rule_based takes every estimated parameter from chatgarment_rule_based_physics_parameters.csv (keyed on the pick id): the eight stiffnesses, the eight buckling values (ratio and stiffness in four directions), thickness and weight. No ground-truth value is used. Only friction (0.03) and internal damping (0.0001) are the shared constants. So rule_based is a full predicted-fabric arm, not a stiffness-only ablation, and a cg × MC vs cg × rule_based comparison measures the whole fabric estimate.

Produced with the same pipeline (md_cgrb.py / run_cgrb.py, adapted from md_s20.py), single recorded pass 0 → END per run (one material needs no branch). Guards as above, plus garment identity by face count against the source mesh. Every bind was read back from MD on all 18 keys at rtol 1e-4. 198 of 198 runs completed, none failed. Two ai joyful_jump runs are flagged as fallen (reached floor level during the action, kept per the study rule): row_033_m13__sample_03__ai__rule_based from frame 108 and row_089_m09__sample_02__ai__rule_based from frame 60. Unlike the gt meshes, these came back from MD's OBJ round trip still welded (vertex count == source), which is also why lzma only reaches ~81% of raw on them. Per-run records, fps probe and Alembic read-back are in the run folder's logs/.

The bodies

The avatar motions these garments were simulated against are not in this repo — they are in image2garment/test_3am under human_sequences/, as uncompressed Alembic:

human_sequences/
├── hit_reaction/reaction_hit_smpl.abc                 27 MB
├── joyful_jump/joyful_jump_mean_all_smpl.abc          29 MB
├── jumping_jack/JumpingJack_smpl.abc                 100 MB
├── jumping_jack/JumpingJack_smpl._30fps.abc          100 MB
└── northern_spin/northern_spin_mean_all_smpl.abc      48 MB

All are mean_all bodies and all are the full mesh — no hand removal.

Read this before pairing a body with a garment sim. The bases do not all use the full-vertex avatar. 23752 verts is the full mesh; 21001 and 19631 are two different hands-removed exports:

sequence	avatar in the base	same as the file above?
hit_reaction	23752, full	yes
northern_spin	23752, full	yes (not simulated in this study)
jumping_jack	21001, hands removed	no
joyful_jump	19631, hands removed	no

So for jumping jack and joyful jump the published body has more vertices than the one the cloth actually collided with. Same motion, same body shape, different hand geometry — fine for visualisation and for body-relative framing, but not exact for contact or penetration metrics on those two sequences.

northern_spin is included there for completeness; it was dropped from this study, so there are no garment simulations for it.

Physics

Use the full 18-parameter predictions (protocol from 2026-10-15). Each arm binds all 18 parameters from its own CSV — 8 stiffnesses, 8 buckling values (ratio and stiffness, four directions), thickness and weight. No ground-truth value is substituted into a predicted arm. Friction 0.03 and internal damping 0.0001 are the only shared constants.

arm	source CSV (all 18 parameters)
gt	image2garment/SMS_realistic_eval :: v2/farthest_ftag_picks.csv (by material class)
tabpfn	image2garment/test_3am :: FabricAttributeEstimationGPT_Images/qwen35_9b/physics_predictions_tabpfn_per_generation.csv (by pick id)
MC	image2garment/test_3am :: FabricAttributeEstimationGPT_Images/qwen35_9b/MC_baseline_18.csv (one row, constant across garments)
rule_based_gpt6	image2garment/test_3am :: FabricAttributeEstimationGPT_Images/qwen35_9b/physics_predictions_chatgarment_rb_gpt6sol_v4_per_generation.csv (by pick id)

MC_baseline_18.csv is the complete FabriPhys row of the most-common-material fabric (itemId 18b3b8d15cbda18da6a1627495ce1b48, Canvas Tartan CO/PL 167gsm, copied verbatim from PhysParamEstimation/full_data_retrain/splits/full_union.csv). Its 8 stiffnesses are identical to the older 8-column MC_baseline.csv.

What the existing root-level shards used (old protocol, kept for the record). Only the 8 stiffnesses varied between materials. Thickness and weight were the garment's ground-truth values for every material, and buckling was 0.0 throughout -- the 8-column MC baseline carried no buckling, so giving GT real buckling would have confounded that comparison. Sources: gt from farthest_ftag_picks.csv by material class; tabpfn from physics_predictions_tabpfn_per_generation.csv joined on the pick id (stiffness columns only); MC from the 8-column MC_baseline.csv (constant across garments). Every bind is read back out of MD and compared at rtol 1e-4 before the recording starts. Do not compare these root-level arms directly with the rule-based arms, which bind all 18 parameters.

Units and geometry

• Alembics are exported in metres (MD works in mm; export scale 0.001).
• Input meshes are metres: gt is garment_sim.obj, gp/cg/ai are sim_scale.obj (not sim.obj, which is centimetres).
• The meshes are unwelded. MD's OBJ round trip splits vertices: a 31176-vertex mesh comes back as 156252 vertices with the same 61690 faces, same bbox, same drape. The factor varies per mesh (4.8x-5.0x observed). Face topology is preserved, so identity and correspondence are recoverable through the face table; per-vertex correspondence with the source .obj is not. Chamfer distance is unaffected (duplicate vertices are coincident).

Guards that ran on every simulation

Avatar vertex count against the expected body (halt) · garment identity by face count against the source mesh (halt) · physics read back at rtol 1e-4 (halt) · vertex diff against the anchor's frame-42 cache before every material swap, expecting 0.0 mm (halt above 5 mm) · a fall during the settle (halt) · recording verified by wall time + a track covering the requested window + the playhead landing at the end (halt) · every export stat'd (halt on a stub).

A garment that falls during the action is recorded and kept, not discarded — some drapes are legitimately thrown off by the motion.

Not included

.zprj project files are kept locally, not uploaded. They exist because MD exposes no stress/strain export through any API, and ticking Strain/Stress in the Export Alembic dialog was measured to change nothing in the output — likely because these are mesh garments with GetPatternCount() == 0. Strain is therefore best derived from the geometry: per-triangle Green strain between the rest mesh and each frame, using the preserved face table.