SLAT loader: pooled-anchor conditioning (white-bg cond + RecGen images; anchor source decides all aux views), RecGen camera QC, recgen/<id>/ tar join; ON in train_slatflow_prod.yaml. Verified: 2500 real draws, 0 mixed-source samples.

.gitattributes

@@ -36,3 +36,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 migrator/checkpoints/hub/facebookresearch_dinov2_main/docs/Cell-DINO.png filter=lfs diff=lfs merge=lfs -text
 migrator/checkpoints/hub/facebookresearch_dinov2_main/docs/ChannelAdaptiveDINO.png filter=lfs diff=lfs merge=lfs -text
 migrator/code/mv-sam3d-for-6d-v2/mvsam3d/data/__pycache__/adapters.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+migrator/code/mv-sam3d-for-6d-v2-ssflow/mvsam3d/data/__pycache__/adapters.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+migrator/code/mv-sam3d-for-6d-v2-ssflow/mvsam3d/data/__pycache__/slatflow_dataset.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

migrator/code/mv-sam3d-for-6d-v2-ssflow/configs/train_slatflow.yaml.bak_predatveiw

@@ -0,0 +1,169 @@
+# Training config for the multi-view SLAT flow (SlatFlowModel, SLAT_GEN_PLAN).
+# ALL training hyperparameters live here; train_slat_flow.py reads them and
+# nothing training-related is hardcoded in Python. Launch:
+#   SPARSE_ATTN_BACKEND=sdpa PYTHONPATH=. \
+#   python mvsam3d/train/train_slat_flow.py --config configs/train_slatflow.yaml
+#   (multi-GPU: torchrun --nproc_per_node=N ...)
+# Per-key overrides: --set key.subkey=value (repeatable).
+
+# --------------------------------------------------------------------------- #
+# data -> TrellisSlatFlowDataset (DATA_FORMAT.md layout + per-view RGB assets).
+# Smoke: toys4k200 objects with the toys4k1k inputs/renders fallback for
+# RGB+bbox (V=4 views: front/side/oside/back — camera-verified identical to the
+# stored views.npz). Production roots get views/rgb + views/bbox.npy +
+# slat/slat_sam3d.npz per SLAT_GEN_PLAN §8 (precompute jobs pending).
+# --------------------------------------------------------------------------- #
+data:
+  roots:
+    - /lp-dev/jonghoon/mv-sam3d-6d-code/smoke_data/toys4k200
+  # Explicit validation roots (same policy as train_ssflow.yaml): non-empty ->
+  # val = ALL objects under val_roots, train = roots minus those ids.
+  # NOTE: val_omni3d has no toys4k1k RGB fallback assets yet, so the smoke val
+  # set is toys4k-only until the production rgb/bbox precompute lands.
+  val_roots:
+    - /lp-dev/jonghoon/mv-sam3d-6d-code/smoke_data/val_toys4k100
+  # --- view-subset augmentation (the ONLY train-time stochasticity besides
+  #     the fresh invisible-row noise in x0) ---
+  # smoke data has 4 views/object; production renders 24 (paper §3.1.1).
+  # TRELLIS-style per-object voxel FILTER (structured_latent.py
+  # filter_metadata): objects with more active 64^3 voxels are DROPPED at
+  # index-build time (never downsampled). 20000 = the single-object SLAT
+  # OOM-safe bound (PLAN/BATCH_SIZE_BENCH.md; drops ~4.8% of trellis500k).
+  # 0 disables the filter.
+  max_num_voxels: 20000
+  min_views: 1               # |S| ~ Uniform{min_views..max_views} per sample
+  max_views: 4               # clamped per object to its available view count
+  val_num_views: 2           # deterministic view count for validation samples
+  aug_seed: 0                # seeds the per-(epoch,idx) view-subset RNG
+  # --- legacy hash split (used only when val_roots is empty) ---
+  val_fraction: 0.05
+  split_seed: 0
+
+# --------------------------------------------------------------------------- #
+# model -> SlatFlowModel. The generator stack (FlowMatching -> CFG ->
+# SLatFlowModelTdfyWrapper) is hydra-built from the vendored slat_generator.yaml
+# with the pipeline's effective inference config (steps=25, cfg_strength=1,
+# cfg_interval=[0,500], rescale_t=1) baked in by build_slat_generator.
+# --------------------------------------------------------------------------- #
+model:
+  # Warm-start from the deployed SLAT generator (526/526 tensors, verified).
+  pretrained_ckpt: ${MIGRATOR_CHECKPOINTS}/hf/slat_generator.ckpt
+  # Local soft-mask cross-attention bias (§4c). Parity gating (§10 step 4)
+  # PASSED 2026-09-01 (wrapped/zero-bias bit-identical to the pristine stack on
+  # 3 toys4k objects), so the bias is ENABLED for training. Set false to
+  # reproduce the gating configuration.
+  enable_soft_mask: true    # local -10 soft-mask in cross-attention
+  enable_plucker: true      # Plücker ray embedding on non-anchor views
+  bias_value: -10.0          # fixed, fp16-safe; NEVER -inf (§4c / risk #7)
+  # Backbone param dtype: false = lossless fp16->fp32 upcast for training
+  # (optimizer-friendly); true = yaml-verbatim fp16 torso (the parity config).
+  fp16_torso: false
+  # Gradient checkpointing on the 24 backbone DiT cross blocks (per-block
+  # .use_checkpoint flip, same toggle the batch-size bench used): recompute
+  # activations in backward -> big memory cut, ~modest step-time cost.
+  # false = current behavior (no checkpointing).
+  use_checkpoint: false
+  # Train the pretrained EmbedderFuser projections + slot embeddings (the DINO
+  # towers inside are always frozen). false freezes the whole fuser so only
+  # the backbone + Plücker FC train.
+  train_condition_embedder: true
+
+# --------------------------------------------------------------------------- #
+# optim + train loop
+# --------------------------------------------------------------------------- #
+optim:
+  lr: 3.0e-5
+  weight_decay: 0.0          # AdamW
+  grad_clip: 1.0             # max grad norm
+
+# --------------------------------------------------------------------------- #
+# ema — exponential moving average of the TRAINABLE weights (fp32 shadow,
+# updated after every optimizer step; frozen DINO towers excluded).
+# Disabled by default = existing behavior unchanged. State is saved as a
+# per-checkpoint sidecar (step_XXXX_ema.pt, next to the _optimizer.pt sidecar)
+# and restored automatically on resume_from.
+# --------------------------------------------------------------------------- #
+ema:
+  enable: true
+  rate: 0.999               # ema = rate*ema + (1-rate)*param
+  eval_with_ema: true        # swap EMA weights in for the in-loop validation
+
+train:
+  # Effective batch = batch_objects x grad_accum_steps x world_size objects
+  # per optimizer step.
+  #   batch_objects = 1 (default): loader bs=1 + collate_single, one object per
+  #     backbone forward (batching purely via grad_accum_steps).
+  #   batch_objects > 1: TRUE multi-object batching (collate_batched +
+  #     SlatFlowModel.flow_step_batched) — B objects concatenated into ONE
+  #     sparse coord set with the batch-index column, ONE backbone forward,
+  #     independent t per object. Requires grad_accum_steps == 1.
+  steps: 20000
+  num_workers: 16            # CPU work: crops + projections + Plücker per view
+  batch_objects: 1           # objects per GPU per forward (true batching if >1)
+  grad_accum_steps: 8
+  # --- LR schedule (reused fork build_scheduler: warmup -> cosine -> min_lr) ---
+  scheduler: cosine          # cosine | constant
+  warmup_steps: 500
+  min_lr: 1.0e-6
+  # --- resume ---
+  resume_from: ""            # checkpoint path to resume (empty = fresh start)
+  log_every: 20
+  ckpt_every: 5000
+  ckpt_dir: ${MIGRATOR_CACHE}/ckpt_slatflow
+  amp: true
+  amp_dtype: bf16            # bf16 | fp16 (fp16 enables GradScaler)
+  seed: 0
+  # --- distributed (DDP via torchrun; world_size=1 transparently skips it) ---
+  backend: ddp               # ddp | deepspeed
+  deepspeed_config: ""
+  # --- validation: held-out flow v-MSE only (fixed RNG). Decode +
+  #     faithfulness eval = the TrainTest phase (frozen-pipeline decode). ---
+  val_every: 5000            # optimizer steps between validation passes (0 = never)
+  val_max_batches: 8         # val objects per rank per pass
+
+# --------------------------------------------------------------------------- #
+# wandb — rank-0 experiment logging (train/loss|lr|grad_norm per log_every step,
+# val/* per validation pass).  enabled: false makes every wandb call a no-op.
+# Extra metric dicts can be pushed from anywhere via
+#   from mvsam3d.train.train_slat_flow import log_metrics
+#   log_metrics({"val/chamfer": ..., "val/psnr": ...}, step)
+# --------------------------------------------------------------------------- #
+wandb:
+  enabled: true
+  project: "mvsam3d-slatflow"
+  entity: "alphabet1"
+  name: null                 # null -> W&B autogenerates the run name
+  dir: "/lp-dev/jonghoon/mv-mesh/wandb"
+
+# --------------------------------------------------------------------------- #
+# val_appforce — APPEARANCE-FORCING validation (mvsam3d/train/val_appforce.py):
+# the trained flow through the exact reported protocol (batch_appforce_sam3d
+# sam3d_geom_dino 2v -> evaluate_appforce.py) on toys4k-100 (textured) +
+# OmniObject3D-117, every `every` optimizer steps (+ step 0 baseline), EMA
+# weights, ALL ranks sample their shard then run the reference-env decode +
+# eval on their own GPU; rank 0 merges and logs val_af/<ds>/<schedule>/<metric>.
+# Stage-1 (frozen z1fwd geometry forcing) is cached ONCE by
+#   tools/val_stage1_ref.py --mode stage1 --exp <exp> --views 2 --out
+#   <stage1_cache>/<name>/2v
+# --------------------------------------------------------------------------- #
+val_appforce:
+  enabled: true
+  every: 5000
+  at_step0: true
+  views: 2
+  schedules: [seed, reinject]   # seed = the training x0 construction; reinject = the reported schedule
+  seed: 42
+  limit: 0                      # debug: cap objects per dataset
+  batch_size: 6                 # objects per BATCHED 25-step ODE solve (1 = old single path)
+  single: false                 # A/B: force the one-object-per-solve path
+  decode_procs: 2               # concurrent reference-env decode shards per rank
+  ref_threads: 8                # OMP/MKL cap for every reference-env subprocess
+  stage1_cache: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/stage1
+  out_root: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/runs
+  ref_python: /lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/bin/python
+  eval_dataset_flag: toys4k     # evaluate_appforce --dataset (both sets use the toys4k path, as reported)
+  datasets:
+    - name: toys4k100_tex
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/toys4k100_tex
+    - name: omni3d
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/omni3d

migrator/code/mv-sam3d-for-6d-v2-ssflow/configs/train_slatflow_prod.yaml

@@ -63,20 +63,20 @@ data:
   #     Non-empty -> TarSlatFlowDataset reads latents/cond/cameras straight from
   #     the .tar shards (GL->CV flip + alpha-bbox crop); `roots` is ignored. ---
   tar_roots: []
-  # --- condition variants for the .tar path (2026-09-24; all default OFF) ---
+  # --- condition sources for the .tar path (2026-09-24) — ON for production ---
   #   use_recgen_images: index recgen/<id>/{cameras.json,NN.jpg,NN_mask.png}
-  #     (RecGen's own background image + mask + rigid cube cameras) from any tar
-  #     under tar_roots, joined to latents/<id>.npz by id; latent-only slats WITH
-  #     RecGen images become trainable (else they are skipped).
-  #   p_recgen_image: P(RecGen image instead of the white cond render) when an
-  #     object has both; single-source objects always use what they have.
+  #     (RecGen's own background image + visible mask + rigid cube cameras) from
+  #     ANY tar under tar_roots, joined to latents/<id>.npz by the same id string.
+  #     ONE POOL: an object with both sources draws its anchor from the union of
+  #     its white cond views and RecGen views; the anchor's source decides ALL aux
+  #     views (never mixed). RecGen anchors go through the same deployed
+  #     preprocess_slat_image recipe into item["image"] (background kept, alpha =
+  #     mask). Latent-only RecGen slats become trainable; white-only objects are
+  #     drawn exactly as before.
   #   cond_cameras_fallback: white-cond objects without cameras/<id>/cond_cameras.json
   #     (24-view slat5/slat5rs batches, 22,755 objs) read cond/<id>/transforms.json.
-  # For the Hub flat layout (slat_train_flat/) the intended setting is
-  #   use_recgen_images: true, p_recgen_image: 0.5, cond_cameras_fallback: true
-  use_recgen_images: false
-  p_recgen_image: 0.0
-  cond_cameras_fallback: false
+  use_recgen_images: true
+  cond_cameras_fallback: true
 
 # --------------------------------------------------------------------------- #
 # model -> SlatFlowModel. The generator stack (FlowMatching -> CFG ->

migrator/code/mv-sam3d-for-6d-v2-ssflow/configs/train_slatflow_prod.yaml.bak_predatveiw

@@ -0,0 +1,177 @@
+# Training config for the multi-view SLAT flow (SlatFlowModel, SLAT_GEN_PLAN).
+# ALL training hyperparameters live here; train_slat_flow.py reads them and
+# nothing training-related is hardcoded in Python. Launch:
+#   SPARSE_ATTN_BACKEND=sdpa PYTHONPATH=. \
+#   python mvsam3d/train/train_slat_flow.py --config configs/train_slatflow.yaml
+#   (multi-GPU: torchrun --nproc_per_node=N ...)
+# Per-key overrides: --set key.subkey=value (repeatable).
+
+# --------------------------------------------------------------------------- #
+# data -> TrellisSlatFlowDataset (DATA_FORMAT.md layout + per-view RGB assets).
+# Smoke: toys4k200 objects with the toys4k1k inputs/renders fallback for
+# RGB+bbox (V=4 views: front/side/oside/back — camera-verified identical to the
+# stored views.npz). Production roots get views/rgb + views/bbox.npy +
+# slat/slat_sam3d.npz per SLAT_GEN_PLAN §8 (precompute jobs pending).
+# --------------------------------------------------------------------------- #
+data:
+  roots:                      # merged production set (remote 29.4k + local, DATA_FORMAT via tools/adapt_slat50k.py)
+    - /data/mv_mesh_data/slat_train/dataset
+  # Explicit validation roots (same policy as train_ssflow.yaml): non-empty ->
+  # val = ALL objects under val_roots, train = roots minus those ids.
+  # NOTE: val_omni3d has no toys4k1k RGB fallback assets yet, so the smoke val
+  # set is toys4k-only until the production rgb/bbox precompute lands.
+  val_roots: []              # smoke val set has NO official x1 -> flow-loss val would crash; use a hash split of the production roots instead
+  # --- view-subset augmentation (the ONLY train-time stochasticity besides
+  #     the fresh invisible-row noise in x0) ---
+  # smoke data has 4 views/object; production renders 24 (paper §3.1.1).
+  # TRELLIS-style per-object voxel FILTER (structured_latent.py
+  # filter_metadata): objects with more active 64^3 voxels are DROPPED at
+  # index-build time (never downsampled). 20000 = the single-object SLAT
+  # OOM-safe bound (PLAN/BATCH_SIZE_BENCH.md; drops ~4.8% of trellis500k).
+  # 0 disables the filter.
+  max_num_voxels: 20000
+  min_views: 1               # |S| ~ Uniform{min_views..max_views} per sample
+  max_views: 4               # clamped per object to its available view count
+  val_num_views: 2           # deterministic view count for validation samples
+  aug_seed: 0                # seeds the per-(epoch,idx) view-subset RNG
+  # --- legacy hash split (used only when val_roots is empty) ---
+  val_fraction: 0.005        # ~185 held-out production objects for the flow-loss val
+  split_seed: 0
+  # --- SS-stage seed MIXTURE (unified none/single/multi ratio) ---
+  # p_seed_none   = P(EMPTY appearance seed -> x0 all-noise, no forcing)
+  # p_seed_single = P(single-view seed -> n_sub == 1); remainder = multi.
+  # BOTH 0.0 (default) -> LEGACY n_sub ~ U{min_views..max_views}, unchanged.
+  p_seed_none: 0.0
+  p_seed_single: 0.0
+  # --- RecGen loader (additive / opt-in): dirs of released-SLAT objects
+  #     (slat_coords.npy + slat_feats.npy + cond_image_*/cond_mask_* + camera
+  #     metadata), fed to SLAT via matting.  Empty = disabled.  CAVEAT: run a
+  #     GPU decode-compat test before training on RecGen's RELEASED latents. ---
+  recgen_roots: []
+  # encoded_store recgen root with canonical cube cameras (pose_cube.npz /
+  #   views.npz) looked up by sha; needed for CORRECT recgen voxel
+  #   visibility (raw view_metadata alone is geometrically approximate).
+  recgen_pose_store: null
+
+# --------------------------------------------------------------------------- #
+# model -> SlatFlowModel. The generator stack (FlowMatching -> CFG ->
+# SLatFlowModelTdfyWrapper) is hydra-built from the vendored slat_generator.yaml
+# with the pipeline's effective inference config (steps=25, cfg_strength=1,
+# cfg_interval=[0,500], rescale_t=1) baked in by build_slat_generator.
+# --------------------------------------------------------------------------- #
+model:
+  # Warm-start from the deployed SLAT generator (526/526 tensors, verified).
+  pretrained_ckpt: ${MIGRATOR_CHECKPOINTS}/hf/slat_generator.ckpt
+  # Local soft-mask cross-attention bias (§4c). Parity gating (§10 step 4)
+  # PASSED 2026-09-01 (wrapped/zero-bias bit-identical to the pristine stack on
+  # 3 toys4k objects), so the bias is ENABLED for training. Set false to
+  # reproduce the gating configuration.
+  enable_soft_mask: true    # local -10 soft-mask in cross-attention
+  enable_plucker: true      # Plücker ray embedding on non-anchor views
+  bias_value: -10.0          # fixed, fp16-safe; NEVER -inf (§4c / risk #7)
+  # Backbone param dtype: false = lossless fp16->fp32 upcast for training
+  # (optimizer-friendly); true = yaml-verbatim fp16 torso (the parity config).
+  fp16_torso: false
+  # Gradient checkpointing on the 24 backbone DiT cross blocks (per-block
+  # .use_checkpoint flip, same toggle the batch-size bench used): recompute
+  # activations in backward -> big memory cut, ~modest step-time cost.
+  # false = current behavior (no checkpointing).
+  use_checkpoint: false      # user choice 2026-09-03: +20% speed; worst case (3x20k-voxel objects) peaks ~69 GB, watchdog resumes on OOM
+  # Train the pretrained EmbedderFuser projections + slot embeddings (the DINO
+  # towers inside are always frozen). false freezes the whole fuser so only
+  # the backbone + Plücker FC train.
+  train_condition_embedder: true
+
+# --------------------------------------------------------------------------- #
+# optim + train loop
+# --------------------------------------------------------------------------- #
+optim:
+  lr: 3.0e-5
+  weight_decay: 0.0          # AdamW
+  grad_clip: 1.0             # max grad norm
+
+# --------------------------------------------------------------------------- #
+# ema — exponential moving average of the TRAINABLE weights (fp32 shadow,
+# updated after every optimizer step; frozen DINO towers excluded).
+# Disabled by default = existing behavior unchanged. State is saved as a
+# per-checkpoint sidecar (step_XXXX_ema.pt, next to the _optimizer.pt sidecar)
+# and restored automatically on resume_from.
+# --------------------------------------------------------------------------- #
+ema:
+  enable: true
+  rate: 0.999               # ema = rate*ema + (1-rate)*param
+  eval_with_ema: true        # swap EMA weights in for the in-loop validation
+
+train:
+  # Loader batch size is PINNED to 1 (per-object coord sets, collate_single);
+  # the effective batch is grad_accum_steps x world_size objects per step.
+  steps: 100000             # ~32 epochs of 37k objects at 12 objects/step
+  num_workers: 16            # CPU work: crops + projections + Plücker per view
+  grad_accum_steps: 1        # NO accumulation: effective batch = batch_objects x world_size = 12
+  batch_objects: 3           # objects per GPU per optimizer step (true batched flow step)
+  # --- LR schedule (reused fork build_scheduler: warmup -> cosine -> min_lr) ---
+  scheduler: cosine          # cosine | constant
+  warmup_steps: 500
+  min_lr: 1.0e-6
+  # --- resume ---
+  resume_from: ""            # checkpoint path to resume (empty = fresh start)
+  log_every: 20
+  ckpt_every: 2500
+  ckpt_dir: /data/mv_mesh_data/ckpt/slatflow_prod_20260902   # /data (1.1T free); 40 ckpts x 5 GB model+ema, optimizer sidecars pruned to the last 2
+  amp: true
+  amp_dtype: bf16            # bf16 | fp16 (fp16 enables GradScaler)
+  seed: 0
+  # --- distributed (DDP via torchrun; world_size=1 transparently skips it) ---
+  backend: ddp               # ddp | deepspeed
+  deepspeed_config: ""
+  # --- validation: held-out flow v-MSE only (fixed RNG). Decode +
+  #     faithfulness eval = the TrainTest phase (frozen-pipeline decode). ---
+  val_every: 5000            # optimizer steps between validation passes (0 = never)
+  val_max_batches: 8         # val objects per rank per pass
+
+# --------------------------------------------------------------------------- #
+# wandb — rank-0 experiment logging (train/loss|lr|grad_norm per log_every step,
+# val/* per validation pass).  enabled: false makes every wandb call a no-op.
+# Extra metric dicts can be pushed from anywhere via
+#   from mvsam3d.train.train_slat_flow import log_metrics
+#   log_metrics({"val/chamfer": ..., "val/psnr": ...}, step)
+# --------------------------------------------------------------------------- #
+wandb:
+  enabled: true
+  project: "mvsam3d-slatflow"
+  entity: "alphabet1"
+  name: "slatflow_prod_bs12_lr3e-5_ema0.999_100k"
+  dir: "/lp-dev/jonghoon/mv-mesh/wandb"
+
+# --------------------------------------------------------------------------- #
+# val_appforce — APPEARANCE-FORCING validation (mvsam3d/train/val_appforce.py):
+# the trained flow through the exact reported protocol (batch_appforce_sam3d
+# sam3d_geom_dino 2v -> evaluate_appforce.py) on toys4k-100 (textured) +
+# OmniObject3D-117, every `every` optimizer steps (+ step 0 baseline), EMA
+# weights, ALL ranks sample their shard then run the reference-env decode +
+# eval on their own GPU; rank 0 merges and logs val_af/<ds>/<schedule>/<metric>.
+# Stage-1 (frozen z1fwd geometry forcing) is cached ONCE by
+#   tools/val_stage1_ref.py --mode stage1 --exp <exp> --views 2 --out
+#   <stage1_cache>/<name>/2v
+# --------------------------------------------------------------------------- #
+val_appforce:
+  enabled: false               # in-loop val OFF: tools/val_daemon.py validates every 5k ckpt on GPUs 2-3 (training never pauses)
+  every: 5000
+  at_step0: false               # first appearance-forcing val at 5000 (step-0 baseline = the parity run)
+  views: 2
+  schedules: [seed, reinject]   # seed = the training x0 construction; reinject = the reported schedule
+  seed: 42
+  limit: 0                      # debug: cap objects per dataset
+  batch_size: 6                 # objects per BATCHED 25-step ODE solve (1 = old single path)
+  single: true                 # batched B=6 measured 0.8x slower than single; parity verified but no gain
+  decode_procs: 1              # 2 procs x 23 GB OOMed rank 3 at the 10k val
+  ref_threads: 8                # OMP/MKL cap for every reference-env subprocess
+  stage1_cache: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/stage1
+  out_root: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/runs
+  ref_python: /lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/bin/python
+  eval_dataset_flag: toys4k     # evaluate_appforce --dataset (both sets use the toys4k path, as reported)
+  datasets:
+    - name: toys4k100_tex
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/toys4k100_tex
+    - name: omni3d
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/omni3d

migrator/code/mv-sam3d-for-6d-v2-ssflow/configs/train_slatflow_resume20k_2gpu.yaml.bak_predatveiw

@@ -0,0 +1,177 @@
+# Training config for the multi-view SLAT flow (SlatFlowModel, SLAT_GEN_PLAN).
+# ALL training hyperparameters live here; train_slat_flow.py reads them and
+# nothing training-related is hardcoded in Python. Launch:
+#   SPARSE_ATTN_BACKEND=sdpa PYTHONPATH=. \
+#   python mvsam3d/train/train_slat_flow.py --config configs/train_slatflow.yaml
+#   (multi-GPU: torchrun --nproc_per_node=N ...)
+# Per-key overrides: --set key.subkey=value (repeatable).
+
+# --------------------------------------------------------------------------- #
+# data -> TrellisSlatFlowDataset (DATA_FORMAT.md layout + per-view RGB assets).
+# Smoke: toys4k200 objects with the toys4k1k inputs/renders fallback for
+# RGB+bbox (V=4 views: front/side/oside/back — camera-verified identical to the
+# stored views.npz). Production roots get views/rgb + views/bbox.npy +
+# slat/slat_sam3d.npz per SLAT_GEN_PLAN §8 (precompute jobs pending).
+# --------------------------------------------------------------------------- #
+data:
+  roots:                      # POOL for the 20k->30k resume (user 2026-09-07): objects present at the 20k stop + 5,000 randomly sampled NEW slats (local+HF); lists in .debug/slat_prod/pool_{base,new5k}_shas.txt
+    - /data/mv_mesh_data/slat_train/dataset_pool_20k_plus5k
+  # Explicit validation roots (same policy as train_ssflow.yaml): non-empty ->
+  # val = ALL objects under val_roots, train = roots minus those ids.
+  # NOTE: val_omni3d has no toys4k1k RGB fallback assets yet, so the smoke val
+  # set is toys4k-only until the production rgb/bbox precompute lands.
+  val_roots: []              # smoke val set has NO official x1 -> flow-loss val would crash; use a hash split of the production roots instead
+  # --- view-subset augmentation (the ONLY train-time stochasticity besides
+  #     the fresh invisible-row noise in x0) ---
+  # smoke data has 4 views/object; production renders 24 (paper §3.1.1).
+  # TRELLIS-style per-object voxel FILTER (structured_latent.py
+  # filter_metadata): objects with more active 64^3 voxels are DROPPED at
+  # index-build time (never downsampled). 20000 = the single-object SLAT
+  # OOM-safe bound (PLAN/BATCH_SIZE_BENCH.md; drops ~4.8% of trellis500k).
+  # 0 disables the filter.
+  max_num_voxels: 20000
+  min_views: 1               # |S| ~ Uniform{min_views..max_views} per sample
+  max_views: 4               # clamped per object to its available view count
+  val_num_views: 2           # deterministic view count for validation samples
+  aug_seed: 0                # seeds the per-(epoch,idx) view-subset RNG
+  # --- legacy hash split (used only when val_roots is empty) ---
+  val_fraction: 0.005        # ~185 held-out production objects for the flow-loss val
+  split_seed: 0
+  # --- SS-stage seed MIXTURE (unified none/single/multi ratio) ---
+  # p_seed_none   = P(EMPTY appearance seed -> x0 all-noise, no forcing)
+  # p_seed_single = P(single-view seed -> n_sub == 1); remainder = multi.
+  # BOTH 0.0 (default) -> LEGACY n_sub ~ U{min_views..max_views}, unchanged.
+  p_seed_none: 0.0
+  p_seed_single: 0.0
+  # --- RecGen loader (additive / opt-in): dirs of released-SLAT objects
+  #     (slat_coords.npy + slat_feats.npy + cond_image_*/cond_mask_* + camera
+  #     metadata), fed to SLAT via matting.  Empty = disabled.  CAVEAT: run a
+  #     GPU decode-compat test before training on RecGen's RELEASED latents. ---
+  recgen_roots: []
+  # encoded_store recgen root with canonical cube cameras (pose_cube.npz /
+  #   views.npz) looked up by sha; needed for CORRECT recgen voxel
+  #   visibility (raw view_metadata alone is geometrically approximate).
+  recgen_pose_store: null
+
+# --------------------------------------------------------------------------- #
+# model -> SlatFlowModel. The generator stack (FlowMatching -> CFG ->
+# SLatFlowModelTdfyWrapper) is hydra-built from the vendored slat_generator.yaml
+# with the pipeline's effective inference config (steps=25, cfg_strength=1,
+# cfg_interval=[0,500], rescale_t=1) baked in by build_slat_generator.
+# --------------------------------------------------------------------------- #
+model:
+  # Warm-start from the deployed SLAT generator (526/526 tensors, verified).
+  pretrained_ckpt: ${MIGRATOR_CHECKPOINTS}/hf/slat_generator.ckpt
+  # Local soft-mask cross-attention bias (§4c). Parity gating (§10 step 4)
+  # PASSED 2026-09-01 (wrapped/zero-bias bit-identical to the pristine stack on
+  # 3 toys4k objects), so the bias is ENABLED for training. Set false to
+  # reproduce the gating configuration.
+  enable_soft_mask: true    # local -10 soft-mask in cross-attention
+  enable_plucker: true      # Plücker ray embedding on non-anchor views
+  bias_value: -10.0          # fixed, fp16-safe; NEVER -inf (§4c / risk #7)
+  # Backbone param dtype: false = lossless fp16->fp32 upcast for training
+  # (optimizer-friendly); true = yaml-verbatim fp16 torso (the parity config).
+  fp16_torso: false
+  # Gradient checkpointing on the 24 backbone DiT cross blocks (per-block
+  # .use_checkpoint flip, same toggle the batch-size bench used): recompute
+  # activations in backward -> big memory cut, ~modest step-time cost.
+  # false = current behavior (no checkpointing).
+  use_checkpoint: true       # 2-GPU resume run (user 2026-09-07): 6 objects/GPU needs activation checkpointing
+  # Train the pretrained EmbedderFuser projections + slot embeddings (the DINO
+  # towers inside are always frozen). false freezes the whole fuser so only
+  # the backbone + Plücker FC train.
+  train_condition_embedder: true
+
+# --------------------------------------------------------------------------- #
+# optim + train loop
+# --------------------------------------------------------------------------- #
+optim:
+  lr: 3.0e-5
+  weight_decay: 0.0          # AdamW
+  grad_clip: 1.0             # max grad norm
+
+# --------------------------------------------------------------------------- #
+# ema — exponential moving average of the TRAINABLE weights (fp32 shadow,
+# updated after every optimizer step; frozen DINO towers excluded).
+# Disabled by default = existing behavior unchanged. State is saved as a
+# per-checkpoint sidecar (step_XXXX_ema.pt, next to the _optimizer.pt sidecar)
+# and restored automatically on resume_from.
+# --------------------------------------------------------------------------- #
+ema:
+  enable: true
+  rate: 0.999               # ema = rate*ema + (1-rate)*param
+  eval_with_ema: true        # swap EMA weights in for the in-loop validation
+
+train:
+  # Loader batch size is PINNED to 1 (per-object coord sets, collate_single);
+  # the effective batch is grad_accum_steps x world_size objects per step.
+  steps: 100000             # ~32 epochs of 37k objects at 12 objects/step
+  num_workers: 16            # CPU work: crops + projections + Plücker per view
+  grad_accum_steps: 1        # NO accumulation: effective batch = batch_objects x world_size = 12
+  batch_objects: 6           # 6 objects/GPU x 2 GPUs = effective batch 12 (same as the 4-GPU run)
+  # --- LR schedule (reused fork build_scheduler: warmup -> cosine -> min_lr) ---
+  scheduler: cosine          # cosine | constant
+  warmup_steps: 500
+  min_lr: 1.0e-6
+  # --- resume ---
+  resume_from: "/data/mv_mesh_data/ckpt/slatflow_prod_20260902/step_0020000.pt"   # resume the 20k prod ckpt (+ema/optimizer sidecars)
+  log_every: 20
+  ckpt_every: 2500
+  ckpt_dir: /data/mv_mesh_data/ckpt/slatflow_resume20k_2gpu
+  amp: true
+  amp_dtype: bf16            # bf16 | fp16 (fp16 enables GradScaler)
+  seed: 0
+  # --- distributed (DDP via torchrun; world_size=1 transparently skips it) ---
+  backend: ddp               # ddp | deepspeed
+  deepspeed_config: ""
+  # --- validation: held-out flow v-MSE only (fixed RNG). Decode +
+  #     faithfulness eval = the TrainTest phase (frozen-pipeline decode). ---
+  val_every: 5000            # optimizer steps between validation passes (0 = never)
+  val_max_batches: 8         # val objects per rank per pass
+
+# --------------------------------------------------------------------------- #
+# wandb — rank-0 experiment logging (train/loss|lr|grad_norm per log_every step,
+# val/* per validation pass).  enabled: false makes every wandb call a no-op.
+# Extra metric dicts can be pushed from anywhere via
+#   from mvsam3d.train.train_slat_flow import log_metrics
+#   log_metrics({"val/chamfer": ..., "val/psnr": ...}, step)
+# --------------------------------------------------------------------------- #
+wandb:
+  enabled: true
+  project: "mvsam3d-slatflow"
+  entity: "alphabet1"
+  name: "slatflow_resume20k_2gpu_bs12_pool55k"
+  dir: "/lp-dev/jonghoon/mv-mesh/wandb"
+
+# --------------------------------------------------------------------------- #
+# val_appforce — APPEARANCE-FORCING validation (mvsam3d/train/val_appforce.py):
+# the trained flow through the exact reported protocol (batch_appforce_sam3d
+# sam3d_geom_dino 2v -> evaluate_appforce.py) on toys4k-100 (textured) +
+# OmniObject3D-117, every `every` optimizer steps (+ step 0 baseline), EMA
+# weights, ALL ranks sample their shard then run the reference-env decode +
+# eval on their own GPU; rank 0 merges and logs val_af/<ds>/<schedule>/<metric>.
+# Stage-1 (frozen z1fwd geometry forcing) is cached ONCE by
+#   tools/val_stage1_ref.py --mode stage1 --exp <exp> --views 2 --out
+#   <stage1_cache>/<name>/2v
+# --------------------------------------------------------------------------- #
+val_appforce:
+  enabled: false               # in-loop val OFF: tools/val_daemon.py validates every 5k ckpt on GPUs 2-3 (training never pauses)
+  every: 5000
+  at_step0: false               # first appearance-forcing val at 5000 (step-0 baseline = the parity run)
+  views: 2
+  schedules: [seed, reinject]   # seed = the training x0 construction; reinject = the reported schedule
+  seed: 42
+  limit: 0                      # debug: cap objects per dataset
+  batch_size: 6                 # objects per BATCHED 25-step ODE solve (1 = old single path)
+  single: true                 # batched B=6 measured 0.8x slower than single; parity verified but no gain
+  decode_procs: 1              # 2 procs x 23 GB OOMed rank 3 at the 10k val
+  ref_threads: 8                # OMP/MKL cap for every reference-env subprocess
+  stage1_cache: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/stage1
+  out_root: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/runs
+  ref_python: /lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/bin/python
+  eval_dataset_flag: toys4k     # evaluate_appforce --dataset (both sets use the toys4k path, as reported)
+  datasets:
+    - name: toys4k100_tex
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/toys4k100_tex
+    - name: omni3d
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/omni3d

migrator/code/mv-sam3d-for-6d-v2-ssflow/configs/train_slatflow_resume20k_pslaug_2gpu.yaml.bak_predatveiw

@@ -0,0 +1,186 @@
+# Training config for the multi-view SLAT flow (SlatFlowModel, SLAT_GEN_PLAN).
+# ALL training hyperparameters live here; train_slat_flow.py reads them and
+# nothing training-related is hardcoded in Python. Launch:
+#   SPARSE_ATTN_BACKEND=sdpa PYTHONPATH=. \
+#   python mvsam3d/train/train_slat_flow.py --config configs/train_slatflow.yaml
+#   (multi-GPU: torchrun --nproc_per_node=N ...)
+# Per-key overrides: --set key.subkey=value (repeatable).
+
+# --------------------------------------------------------------------------- #
+# data -> TrellisSlatFlowDataset (DATA_FORMAT.md layout + per-view RGB assets).
+# Smoke: toys4k200 objects with the toys4k1k inputs/renders fallback for
+# RGB+bbox (V=4 views: front/side/oside/back — camera-verified identical to the
+# stored views.npz). Production roots get views/rgb + views/bbox.npy +
+# slat/slat_sam3d.npz per SLAT_GEN_PLAN §8 (precompute jobs pending).
+# --------------------------------------------------------------------------- #
+data:
+  roots:                      # POOL for the 20k->30k PSL-AUG resume (user 2026-09-07):
+                              #   (a) the 50,621 base-pool objects present at the 20k stop
+                              #       (.debug/slat_prod/pool_base_shas.txt), and
+                              #   (b) ALL new PSL-augmentation objects from
+                              #       /data/mv_mesh_data/psl_aug/objects (psl_aug_shas.txt).
+                              # The pool root is symlink-only, built by
+                              # /lp-dev/jonghoon/mv-sam3d-6d-code/build_pool_base_pslaug.sh
+                              # as <root>/{remote,local,pslaug}/objects/<sha[:2]>/<sha>.
+                              # psl_aug objects carry NO special weighting: scan_objects
+                              # flattens all three sources into one uniformly-sampled index.
+    - /data/mv_mesh_data/slat_train/dataset_pool_base_pslaug
+  # Explicit validation roots (same policy as train_ssflow.yaml): non-empty ->
+  # val = ALL objects under val_roots, train = roots minus those ids.
+  # NOTE: val_omni3d has no toys4k1k RGB fallback assets yet, so the smoke val
+  # set is toys4k-only until the production rgb/bbox precompute lands.
+  val_roots: []              # smoke val set has NO official x1 -> flow-loss val would crash; use a hash split of the production roots instead
+  # --- view-subset augmentation (the ONLY train-time stochasticity besides
+  #     the fresh invisible-row noise in x0) ---
+  # smoke data has 4 views/object; production renders 24 (paper §3.1.1).
+  # TRELLIS-style per-object voxel FILTER (structured_latent.py
+  # filter_metadata): objects with more active 64^3 voxels are DROPPED at
+  # index-build time (never downsampled). 20000 = the single-object SLAT
+  # OOM-safe bound (PLAN/BATCH_SIZE_BENCH.md; drops ~4.8% of trellis500k).
+  # 0 disables the filter.
+  max_num_voxels: 20000
+  min_views: 1               # |S| ~ Uniform{min_views..max_views} per sample
+  max_views: 4               # clamped per object to its available view count
+  val_num_views: 2           # deterministic view count for validation samples
+  aug_seed: 0                # seeds the per-(epoch,idx) view-subset RNG
+  # --- legacy hash split (used only when val_roots is empty) ---
+  val_fraction: 0.005        # ~185 held-out production objects for the flow-loss val
+  split_seed: 0
+  # --- SS-stage seed MIXTURE (unified none/single/multi ratio) ---
+  # p_seed_none   = P(EMPTY appearance seed -> x0 all-noise, no forcing)
+  # p_seed_single = P(single-view seed -> n_sub == 1); remainder = multi.
+  # BOTH 0.0 (default) -> LEGACY n_sub ~ U{min_views..max_views}, unchanged.
+  p_seed_none: 0.0
+  p_seed_single: 0.0
+  # --- RecGen loader (additive / opt-in): dirs of released-SLAT objects
+  #     (slat_coords.npy + slat_feats.npy + cond_image_*/cond_mask_* + camera
+  #     metadata), fed to SLAT via matting.  Empty = disabled.  CAVEAT: run a
+  #     GPU decode-compat test before training on RecGen's RELEASED latents. ---
+  recgen_roots: []
+  # encoded_store recgen root with canonical cube cameras (pose_cube.npz /
+  #   views.npz) looked up by sha; needed for CORRECT recgen voxel
+  #   visibility (raw view_metadata alone is geometrically approximate).
+  recgen_pose_store: null
+
+# --------------------------------------------------------------------------- #
+# model -> SlatFlowModel. The generator stack (FlowMatching -> CFG ->
+# SLatFlowModelTdfyWrapper) is hydra-built from the vendored slat_generator.yaml
+# with the pipeline's effective inference config (steps=25, cfg_strength=1,
+# cfg_interval=[0,500], rescale_t=1) baked in by build_slat_generator.
+# --------------------------------------------------------------------------- #
+model:
+  # Warm-start from the deployed SLAT generator (526/526 tensors, verified).
+  pretrained_ckpt: ${MIGRATOR_CHECKPOINTS}/hf/slat_generator.ckpt
+  # Local soft-mask cross-attention bias (§4c). Parity gating (§10 step 4)
+  # PASSED 2026-09-01 (wrapped/zero-bias bit-identical to the pristine stack on
+  # 3 toys4k objects), so the bias is ENABLED for training. Set false to
+  # reproduce the gating configuration.
+  enable_soft_mask: true    # local -10 soft-mask in cross-attention
+  enable_plucker: true      # Plücker ray embedding on non-anchor views
+  bias_value: -10.0          # fixed, fp16-safe; NEVER -inf (§4c / risk #7)
+  # Backbone param dtype: false = lossless fp16->fp32 upcast for training
+  # (optimizer-friendly); true = yaml-verbatim fp16 torso (the parity config).
+  fp16_torso: false
+  # Gradient checkpointing on the 24 backbone DiT cross blocks (per-block
+  # .use_checkpoint flip, same toggle the batch-size bench used): recompute
+  # activations in backward -> big memory cut, ~modest step-time cost.
+  # false = current behavior (no checkpointing).
+  use_checkpoint: true       # 2-GPU resume run (user 2026-09-07): 6 objects/GPU needs activation checkpointing
+  # Train the pretrained EmbedderFuser projections + slot embeddings (the DINO
+  # towers inside are always frozen). false freezes the whole fuser so only
+  # the backbone + Plücker FC train.
+  train_condition_embedder: true
+
+# --------------------------------------------------------------------------- #
+# optim + train loop
+# --------------------------------------------------------------------------- #
+optim:
+  lr: 3.0e-5
+  weight_decay: 0.0          # AdamW
+  grad_clip: 1.0             # max grad norm
+
+# --------------------------------------------------------------------------- #
+# ema — exponential moving average of the TRAINABLE weights (fp32 shadow,
+# updated after every optimizer step; frozen DINO towers excluded).
+# Disabled by default = existing behavior unchanged. State is saved as a
+# per-checkpoint sidecar (step_XXXX_ema.pt, next to the _optimizer.pt sidecar)
+# and restored automatically on resume_from.
+# --------------------------------------------------------------------------- #
+ema:
+  enable: true
+  rate: 0.999               # ema = rate*ema + (1-rate)*param
+  eval_with_ema: true        # swap EMA weights in for the in-loop validation
+
+train:
+  # Loader batch size is PINNED to 1 (per-object coord sets, collate_single);
+  # the effective batch is grad_accum_steps x world_size objects per step.
+  steps: 100000             # ~32 epochs of 37k objects at 12 objects/step
+  num_workers: 16            # CPU work: crops + projections + Plücker per view
+  grad_accum_steps: 1        # NO accumulation: effective batch = batch_objects x world_size = 12
+  batch_objects: 6           # 6 objects/GPU x 2 GPUs = effective batch 12 (same as the 4-GPU run)
+  # --- LR schedule (reused fork build_scheduler: warmup -> cosine -> min_lr) ---
+  scheduler: cosine          # cosine | constant
+  warmup_steps: 500
+  min_lr: 1.0e-6
+  # --- resume ---
+  resume_from: "/data/mv_mesh_data/ckpt/slatflow_prod_20260902/step_0020000.pt"   # resume the 20k prod ckpt (+ema/optimizer sidecars)
+  log_every: 20
+  ckpt_every: 2500
+  ckpt_dir: /data/mv_mesh_data/ckpt/slatflow_resume20k_pslaug_2gpu
+  amp: true
+  amp_dtype: bf16            # bf16 | fp16 (fp16 enables GradScaler)
+  seed: 0
+  # --- distributed (DDP via torchrun; world_size=1 transparently skips it) ---
+  backend: ddp               # ddp | deepspeed
+  deepspeed_config: ""
+  # --- validation: held-out flow v-MSE only (fixed RNG). Decode +
+  #     faithfulness eval = the TrainTest phase (frozen-pipeline decode). ---
+  val_every: 5000            # optimizer steps between validation passes (0 = never)
+  val_max_batches: 8         # val objects per rank per pass
+
+# --------------------------------------------------------------------------- #
+# wandb — rank-0 experiment logging (train/loss|lr|grad_norm per log_every step,
+# val/* per validation pass).  enabled: false makes every wandb call a no-op.
+# Extra metric dicts can be pushed from anywhere via
+#   from mvsam3d.train.train_slat_flow import log_metrics
+#   log_metrics({"val/chamfer": ..., "val/psnr": ...}, step)
+# --------------------------------------------------------------------------- #
+wandb:
+  enabled: true
+  project: "mvsam3d-slatflow"
+  entity: "alphabet1"
+  name: "slatflow_resume20k_pslaug_bs12"
+  dir: "/lp-dev/jonghoon/mv-mesh/wandb"
+
+# --------------------------------------------------------------------------- #
+# val_appforce — APPEARANCE-FORCING validation (mvsam3d/train/val_appforce.py):
+# the trained flow through the exact reported protocol (batch_appforce_sam3d
+# sam3d_geom_dino 2v -> evaluate_appforce.py) on toys4k-100 (textured) +
+# OmniObject3D-117, every `every` optimizer steps (+ step 0 baseline), EMA
+# weights, ALL ranks sample their shard then run the reference-env decode +
+# eval on their own GPU; rank 0 merges and logs val_af/<ds>/<schedule>/<metric>.
+# Stage-1 (frozen z1fwd geometry forcing) is cached ONCE by
+#   tools/val_stage1_ref.py --mode stage1 --exp <exp> --views 2 --out
+#   <stage1_cache>/<name>/2v
+# --------------------------------------------------------------------------- #
+val_appforce:
+  enabled: false               # in-loop val OFF: tools/val_daemon.py validates every 5k ckpt on GPUs 2-3 (training never pauses)
+  every: 5000
+  at_step0: false               # first appearance-forcing val at 5000 (step-0 baseline = the parity run)
+  views: 2
+  schedules: [seed, reinject]   # seed = the training x0 construction; reinject = the reported schedule
+  seed: 42
+  limit: 0                      # debug: cap objects per dataset
+  batch_size: 6                 # objects per BATCHED 25-step ODE solve (1 = old single path)
+  single: true                 # batched B=6 measured 0.8x slower than single; parity verified but no gain
+  decode_procs: 1              # 2 procs x 23 GB OOMed rank 3 at the 10k val
+  ref_threads: 8                # OMP/MKL cap for every reference-env subprocess
+  stage1_cache: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/stage1
+  out_root: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/runs
+  ref_python: /lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/bin/python
+  eval_dataset_flag: toys4k     # evaluate_appforce --dataset (both sets use the toys4k path, as reported)
+  datasets:
+    - name: toys4k100_tex
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/toys4k100_tex
+    - name: omni3d
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/omni3d

migrator/code/mv-sam3d-for-6d-v2-ssflow/configs/train_slatflow_resume22p5k_pslfinal_2gpu.yaml.bak_predatveiw

@@ -0,0 +1,188 @@
+# Training config for the multi-view SLAT flow (SlatFlowModel, SLAT_GEN_PLAN).
+# ALL training hyperparameters live here; train_slat_flow.py reads them and
+# nothing training-related is hardcoded in Python. Launch:
+#   SPARSE_ATTN_BACKEND=sdpa PYTHONPATH=. \
+#   python mvsam3d/train/train_slat_flow.py --config configs/train_slatflow.yaml
+#   (multi-GPU: torchrun --nproc_per_node=N ...)
+# Per-key overrides: --set key.subkey=value (repeatable).
+
+# --------------------------------------------------------------------------- #
+# data -> TrellisSlatFlowDataset (DATA_FORMAT.md layout + per-view RGB assets).
+# Smoke: toys4k200 objects with the toys4k1k inputs/renders fallback for
+# RGB+bbox (V=4 views: front/side/oside/back — camera-verified identical to the
+# stored views.npz). Production roots get views/rgb + views/bbox.npy +
+# slat/slat_sam3d.npz per SLAT_GEN_PLAN §8 (precompute jobs pending).
+# --------------------------------------------------------------------------- #
+data:
+  roots:                      # POOL for the 22.5k->30k PSL-FINAL resume (user 2026-09-08):
+                              #   (a) the 50,621 base-pool objects present at the 20k stop
+                              #       (.debug/slat_prod/pool_base_shas.txt), and
+                              #   (b) the MERGED PSL set listed in
+                              #       /data/mv_mesh_data/psl_aug_occ/psl_final_shas.txt
+                              #       ('<set>\t<sha>': occ -> psl_aug_occ/objects, the
+                              #       occlusion-heavy replacement set; aug -> psl_aug/objects,
+                              #       the earlier whole-view set).
+                              # Symlink-only root built by
+                              # /lp-dev/jonghoon/mv-sam3d-6d-code/build_pool_base_pslfinal.sh
+                              # as <root>/{remote,local,pslocc,pslaug}/objects/<sha[:2]>/<sha>.
+                              # No special weighting: one uniformly-sampled index.
+    - /data/mv_mesh_data/slat_train/dataset_pool_base_pslfinal
+  # Explicit validation roots (same policy as train_ssflow.yaml): non-empty ->
+  # val = ALL objects under val_roots, train = roots minus those ids.
+  # NOTE: val_omni3d has no toys4k1k RGB fallback assets yet, so the smoke val
+  # set is toys4k-only until the production rgb/bbox precompute lands.
+  val_roots: []              # smoke val set has NO official x1 -> flow-loss val would crash; use a hash split of the production roots instead
+  # --- view-subset augmentation (the ONLY train-time stochasticity besides
+  #     the fresh invisible-row noise in x0) ---
+  # smoke data has 4 views/object; production renders 24 (paper §3.1.1).
+  # TRELLIS-style per-object voxel FILTER (structured_latent.py
+  # filter_metadata): objects with more active 64^3 voxels are DROPPED at
+  # index-build time (never downsampled). 20000 = the single-object SLAT
+  # OOM-safe bound (PLAN/BATCH_SIZE_BENCH.md; drops ~4.8% of trellis500k).
+  # 0 disables the filter.
+  max_num_voxels: 20000
+  min_views: 1               # |S| ~ Uniform{min_views..max_views} per sample
+  max_views: 4               # clamped per object to its available view count
+  val_num_views: 2           # deterministic view count for validation samples
+  aug_seed: 0                # seeds the per-(epoch,idx) view-subset RNG
+  # --- legacy hash split (used only when val_roots is empty) ---
+  val_fraction: 0.005        # ~185 held-out production objects for the flow-loss val
+  split_seed: 0
+  # --- SS-stage seed MIXTURE (unified none/single/multi ratio) ---
+  # p_seed_none   = P(EMPTY appearance seed -> x0 all-noise, no forcing)
+  # p_seed_single = P(single-view seed -> n_sub == 1); remainder = multi.
+  # BOTH 0.0 (default) -> LEGACY n_sub ~ U{min_views..max_views}, unchanged.
+  p_seed_none: 0.0
+  p_seed_single: 0.0
+  # --- RecGen loader (additive / opt-in): dirs of released-SLAT objects
+  #     (slat_coords.npy + slat_feats.npy + cond_image_*/cond_mask_* + camera
+  #     metadata), fed to SLAT via matting.  Empty = disabled.  CAVEAT: run a
+  #     GPU decode-compat test before training on RecGen's RELEASED latents. ---
+  recgen_roots: []
+  # encoded_store recgen root with canonical cube cameras (pose_cube.npz /
+  #   views.npz) looked up by sha; needed for CORRECT recgen voxel
+  #   visibility (raw view_metadata alone is geometrically approximate).
+  recgen_pose_store: null
+
+# --------------------------------------------------------------------------- #
+# model -> SlatFlowModel. The generator stack (FlowMatching -> CFG ->
+# SLatFlowModelTdfyWrapper) is hydra-built from the vendored slat_generator.yaml
+# with the pipeline's effective inference config (steps=25, cfg_strength=1,
+# cfg_interval=[0,500], rescale_t=1) baked in by build_slat_generator.
+# --------------------------------------------------------------------------- #
+model:
+  # Warm-start from the deployed SLAT generator (526/526 tensors, verified).
+  pretrained_ckpt: ${MIGRATOR_CHECKPOINTS}/hf/slat_generator.ckpt
+  # Local soft-mask cross-attention bias (§4c). Parity gating (§10 step 4)
+  # PASSED 2026-09-01 (wrapped/zero-bias bit-identical to the pristine stack on
+  # 3 toys4k objects), so the bias is ENABLED for training. Set false to
+  # reproduce the gating configuration.
+  enable_soft_mask: true    # local -10 soft-mask in cross-attention
+  enable_plucker: true      # Plücker ray embedding on non-anchor views
+  bias_value: -10.0          # fixed, fp16-safe; NEVER -inf (§4c / risk #7)
+  # Backbone param dtype: false = lossless fp16->fp32 upcast for training
+  # (optimizer-friendly); true = yaml-verbatim fp16 torso (the parity config).
+  fp16_torso: false
+  # Gradient checkpointing on the 24 backbone DiT cross blocks (per-block
+  # .use_checkpoint flip, same toggle the batch-size bench used): recompute
+  # activations in backward -> big memory cut, ~modest step-time cost.
+  # false = current behavior (no checkpointing).
+  use_checkpoint: true       # 2-GPU resume run (user 2026-09-07): 6 objects/GPU needs activation checkpointing
+  # Train the pretrained EmbedderFuser projections + slot embeddings (the DINO
+  # towers inside are always frozen). false freezes the whole fuser so only
+  # the backbone + Plücker FC train.
+  train_condition_embedder: true
+
+# --------------------------------------------------------------------------- #
+# optim + train loop
+# --------------------------------------------------------------------------- #
+optim:
+  lr: 3.0e-5
+  weight_decay: 0.0          # AdamW
+  grad_clip: 1.0             # max grad norm
+
+# --------------------------------------------------------------------------- #
+# ema — exponential moving average of the TRAINABLE weights (fp32 shadow,
+# updated after every optimizer step; frozen DINO towers excluded).
+# Disabled by default = existing behavior unchanged. State is saved as a
+# per-checkpoint sidecar (step_XXXX_ema.pt, next to the _optimizer.pt sidecar)
+# and restored automatically on resume_from.
+# --------------------------------------------------------------------------- #
+ema:
+  enable: true
+  rate: 0.999               # ema = rate*ema + (1-rate)*param
+  eval_with_ema: true        # swap EMA weights in for the in-loop validation
+
+train:
+  # Loader batch size is PINNED to 1 (per-object coord sets, collate_single);
+  # the effective batch is grad_accum_steps x world_size objects per step.
+  steps: 100000             # ~32 epochs of 37k objects at 12 objects/step
+  num_workers: 16            # CPU work: crops + projections + Plücker per view
+  grad_accum_steps: 1        # NO accumulation: effective batch = batch_objects x world_size = 12
+  batch_objects: 6           # 6 objects/GPU x 2 GPUs = effective batch 12 (same as the 4-GPU run)
+  # --- LR schedule (reused fork build_scheduler: warmup -> cosine -> min_lr) ---
+  scheduler: cosine          # cosine | constant
+  warmup_steps: 500
+  min_lr: 1.0e-6
+  # --- resume ---
+  resume_from: "/data/mv_mesh_data/ckpt/slatflow_resume20k_pslaug_2gpu/step_0022500.pt"   # resume the 22.5k pslaug ckpt (+ema/optimizer sidecars); pool swapped to base + merged PSL final set
+  log_every: 20
+  ckpt_every: 2500
+  ckpt_dir: /data/mv_mesh_data/ckpt/slatflow_resume22p5k_pslfinal_2gpu
+  amp: true
+  amp_dtype: bf16            # bf16 | fp16 (fp16 enables GradScaler)
+  seed: 0
+  # --- distributed (DDP via torchrun; world_size=1 transparently skips it) ---
+  backend: ddp               # ddp | deepspeed
+  deepspeed_config: ""
+  # --- validation: held-out flow v-MSE only (fixed RNG). Decode +
+  #     faithfulness eval = the TrainTest phase (frozen-pipeline decode). ---
+  val_every: 5000            # optimizer steps between validation passes (0 = never)
+  val_max_batches: 8         # val objects per rank per pass
+
+# --------------------------------------------------------------------------- #
+# wandb — rank-0 experiment logging (train/loss|lr|grad_norm per log_every step,
+# val/* per validation pass).  enabled: false makes every wandb call a no-op.
+# Extra metric dicts can be pushed from anywhere via
+#   from mvsam3d.train.train_slat_flow import log_metrics
+#   log_metrics({"val/chamfer": ..., "val/psnr": ...}, step)
+# --------------------------------------------------------------------------- #
+wandb:
+  enabled: true
+  project: "mvsam3d-slatflow"
+  entity: "alphabet1"
+  name: "slatflow_resume22p5k_pslfinal_bs12"
+  dir: "/lp-dev/jonghoon/mv-mesh/wandb"
+
+# --------------------------------------------------------------------------- #
+# val_appforce — APPEARANCE-FORCING validation (mvsam3d/train/val_appforce.py):
+# the trained flow through the exact reported protocol (batch_appforce_sam3d
+# sam3d_geom_dino 2v -> evaluate_appforce.py) on toys4k-100 (textured) +
+# OmniObject3D-117, every `every` optimizer steps (+ step 0 baseline), EMA
+# weights, ALL ranks sample their shard then run the reference-env decode +
+# eval on their own GPU; rank 0 merges and logs val_af/<ds>/<schedule>/<metric>.
+# Stage-1 (frozen z1fwd geometry forcing) is cached ONCE by
+#   tools/val_stage1_ref.py --mode stage1 --exp <exp> --views 2 --out
+#   <stage1_cache>/<name>/2v
+# --------------------------------------------------------------------------- #
+val_appforce:
+  enabled: false               # in-loop val OFF: tools/val_daemon.py validates every 5k ckpt on GPUs 2-3 (training never pauses)
+  every: 5000
+  at_step0: false               # first appearance-forcing val at 5000 (step-0 baseline = the parity run)
+  views: 2
+  schedules: [seed, reinject]   # seed = the training x0 construction; reinject = the reported schedule
+  seed: 42
+  limit: 0                      # debug: cap objects per dataset
+  batch_size: 6                 # objects per BATCHED 25-step ODE solve (1 = old single path)
+  single: true                 # batched B=6 measured 0.8x slower than single; parity verified but no gain
+  decode_procs: 1              # 2 procs x 23 GB OOMed rank 3 at the 10k val
+  ref_threads: 8                # OMP/MKL cap for every reference-env subprocess
+  stage1_cache: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/stage1
+  out_root: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/runs
+  ref_python: /lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/bin/python
+  eval_dataset_flag: toys4k     # evaluate_appforce --dataset (both sets use the toys4k path, as reported)
+  datasets:
+    - name: toys4k100_tex
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/toys4k100_tex
+    - name: omni3d
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/omni3d

migrator/code/mv-sam3d-for-6d-v2-ssflow/configs/train_slatflow_resume22p5k_pslocc_2gpu.yaml.bak_predatveiw

@@ -0,0 +1,187 @@
+# Training config for the multi-view SLAT flow (SlatFlowModel, SLAT_GEN_PLAN).
+# ALL training hyperparameters live here; train_slat_flow.py reads them and
+# nothing training-related is hardcoded in Python. Launch:
+#   SPARSE_ATTN_BACKEND=sdpa PYTHONPATH=. \
+#   python mvsam3d/train/train_slat_flow.py --config configs/train_slatflow.yaml
+#   (multi-GPU: torchrun --nproc_per_node=N ...)
+# Per-key overrides: --set key.subkey=value (repeatable).
+
+# --------------------------------------------------------------------------- #
+# data -> TrellisSlatFlowDataset (DATA_FORMAT.md layout + per-view RGB assets).
+# Smoke: toys4k200 objects with the toys4k1k inputs/renders fallback for
+# RGB+bbox (V=4 views: front/side/oside/back — camera-verified identical to the
+# stored views.npz). Production roots get views/rgb + views/bbox.npy +
+# slat/slat_sam3d.npz per SLAT_GEN_PLAN §8 (precompute jobs pending).
+# --------------------------------------------------------------------------- #
+data:
+  roots:                      # POOL for the 22.5k->30k PSL-OCCLUSION resume (user 2026-09-08):
+                              #   (a) the 50,621 base-pool objects present at the 20k stop
+                              #       (.debug/slat_prod/pool_base_shas.txt), and
+                              #   (b) ALL objects of the REPLACEMENT occlusion set
+                              #       /data/mv_mesh_data/psl_aug_occ/objects (3-4 whole +
+                              #       4-5 occluded views per sample; psl_aug_occ_shas.txt).
+                              # The earlier /data/mv_mesh_data/psl_aug set is NOT included.
+                              # Symlink-only root built by
+                              # /lp-dev/jonghoon/mv-sam3d-6d-code/build_pool_base_pslocc.sh
+                              # as <root>/{remote,local,pslocc}/objects/<sha[:2]>/<sha>.
+                              # No special weighting: one uniformly-sampled index.
+    - /data/mv_mesh_data/slat_train/dataset_pool_base_pslocc
+  # Explicit validation roots (same policy as train_ssflow.yaml): non-empty ->
+  # val = ALL objects under val_roots, train = roots minus those ids.
+  # NOTE: val_omni3d has no toys4k1k RGB fallback assets yet, so the smoke val
+  # set is toys4k-only until the production rgb/bbox precompute lands.
+  val_roots: []              # smoke val set has NO official x1 -> flow-loss val would crash; use a hash split of the production roots instead
+  # --- view-subset augmentation (the ONLY train-time stochasticity besides
+  #     the fresh invisible-row noise in x0) ---
+  # smoke data has 4 views/object; production renders 24 (paper §3.1.1).
+  # TRELLIS-style per-object voxel FILTER (structured_latent.py
+  # filter_metadata): objects with more active 64^3 voxels are DROPPED at
+  # index-build time (never downsampled). 20000 = the single-object SLAT
+  # OOM-safe bound (PLAN/BATCH_SIZE_BENCH.md; drops ~4.8% of trellis500k).
+  # 0 disables the filter.
+  max_num_voxels: 20000
+  min_views: 1               # |S| ~ Uniform{min_views..max_views} per sample
+  max_views: 4               # clamped per object to its available view count
+  val_num_views: 2           # deterministic view count for validation samples
+  aug_seed: 0                # seeds the per-(epoch,idx) view-subset RNG
+  # --- legacy hash split (used only when val_roots is empty) ---
+  val_fraction: 0.005        # ~185 held-out production objects for the flow-loss val
+  split_seed: 0
+  # --- SS-stage seed MIXTURE (unified none/single/multi ratio) ---
+  # p_seed_none   = P(EMPTY appearance seed -> x0 all-noise, no forcing)
+  # p_seed_single = P(single-view seed -> n_sub == 1); remainder = multi.
+  # BOTH 0.0 (default) -> LEGACY n_sub ~ U{min_views..max_views}, unchanged.
+  p_seed_none: 0.0
+  p_seed_single: 0.0
+  # --- RecGen loader (additive / opt-in): dirs of released-SLAT objects
+  #     (slat_coords.npy + slat_feats.npy + cond_image_*/cond_mask_* + camera
+  #     metadata), fed to SLAT via matting.  Empty = disabled.  CAVEAT: run a
+  #     GPU decode-compat test before training on RecGen's RELEASED latents. ---
+  recgen_roots: []
+  # encoded_store recgen root with canonical cube cameras (pose_cube.npz /
+  #   views.npz) looked up by sha; needed for CORRECT recgen voxel
+  #   visibility (raw view_metadata alone is geometrically approximate).
+  recgen_pose_store: null
+
+# --------------------------------------------------------------------------- #
+# model -> SlatFlowModel. The generator stack (FlowMatching -> CFG ->
+# SLatFlowModelTdfyWrapper) is hydra-built from the vendored slat_generator.yaml
+# with the pipeline's effective inference config (steps=25, cfg_strength=1,
+# cfg_interval=[0,500], rescale_t=1) baked in by build_slat_generator.
+# --------------------------------------------------------------------------- #
+model:
+  # Warm-start from the deployed SLAT generator (526/526 tensors, verified).
+  pretrained_ckpt: ${MIGRATOR_CHECKPOINTS}/hf/slat_generator.ckpt
+  # Local soft-mask cross-attention bias (§4c). Parity gating (§10 step 4)
+  # PASSED 2026-09-01 (wrapped/zero-bias bit-identical to the pristine stack on
+  # 3 toys4k objects), so the bias is ENABLED for training. Set false to
+  # reproduce the gating configuration.
+  enable_soft_mask: true    # local -10 soft-mask in cross-attention
+  enable_plucker: true      # Plücker ray embedding on non-anchor views
+  bias_value: -10.0          # fixed, fp16-safe; NEVER -inf (§4c / risk #7)
+  # Backbone param dtype: false = lossless fp16->fp32 upcast for training
+  # (optimizer-friendly); true = yaml-verbatim fp16 torso (the parity config).
+  fp16_torso: false
+  # Gradient checkpointing on the 24 backbone DiT cross blocks (per-block
+  # .use_checkpoint flip, same toggle the batch-size bench used): recompute
+  # activations in backward -> big memory cut, ~modest step-time cost.
+  # false = current behavior (no checkpointing).
+  use_checkpoint: true       # 2-GPU resume run (user 2026-09-07): 6 objects/GPU needs activation checkpointing
+  # Train the pretrained EmbedderFuser projections + slot embeddings (the DINO
+  # towers inside are always frozen). false freezes the whole fuser so only
+  # the backbone + Plücker FC train.
+  train_condition_embedder: true
+
+# --------------------------------------------------------------------------- #
+# optim + train loop
+# --------------------------------------------------------------------------- #
+optim:
+  lr: 3.0e-5
+  weight_decay: 0.0          # AdamW
+  grad_clip: 1.0             # max grad norm
+
+# --------------------------------------------------------------------------- #
+# ema — exponential moving average of the TRAINABLE weights (fp32 shadow,
+# updated after every optimizer step; frozen DINO towers excluded).
+# Disabled by default = existing behavior unchanged. State is saved as a
+# per-checkpoint sidecar (step_XXXX_ema.pt, next to the _optimizer.pt sidecar)
+# and restored automatically on resume_from.
+# --------------------------------------------------------------------------- #
+ema:
+  enable: true
+  rate: 0.999               # ema = rate*ema + (1-rate)*param
+  eval_with_ema: true        # swap EMA weights in for the in-loop validation
+
+train:
+  # Loader batch size is PINNED to 1 (per-object coord sets, collate_single);
+  # the effective batch is grad_accum_steps x world_size objects per step.
+  steps: 100000             # ~32 epochs of 37k objects at 12 objects/step
+  num_workers: 16            # CPU work: crops + projections + Plücker per view
+  grad_accum_steps: 1        # NO accumulation: effective batch = batch_objects x world_size = 12
+  batch_objects: 6           # 6 objects/GPU x 2 GPUs = effective batch 12 (same as the 4-GPU run)
+  # --- LR schedule (reused fork build_scheduler: warmup -> cosine -> min_lr) ---
+  scheduler: cosine          # cosine | constant
+  warmup_steps: 500
+  min_lr: 1.0e-6
+  # --- resume ---
+  resume_from: "/data/mv_mesh_data/ckpt/slatflow_resume20k_pslaug_2gpu/step_0022500.pt"   # resume the 22.5k pslaug ckpt (+ema/optimizer sidecars); pool swapped to base+psl_aug_occ
+  log_every: 20
+  ckpt_every: 2500
+  ckpt_dir: /data/mv_mesh_data/ckpt/slatflow_resume22p5k_pslocc_2gpu
+  amp: true
+  amp_dtype: bf16            # bf16 | fp16 (fp16 enables GradScaler)
+  seed: 0
+  # --- distributed (DDP via torchrun; world_size=1 transparently skips it) ---
+  backend: ddp               # ddp | deepspeed
+  deepspeed_config: ""
+  # --- validation: held-out flow v-MSE only (fixed RNG). Decode +
+  #     faithfulness eval = the TrainTest phase (frozen-pipeline decode). ---
+  val_every: 5000            # optimizer steps between validation passes (0 = never)
+  val_max_batches: 8         # val objects per rank per pass
+
+# --------------------------------------------------------------------------- #
+# wandb — rank-0 experiment logging (train/loss|lr|grad_norm per log_every step,
+# val/* per validation pass).  enabled: false makes every wandb call a no-op.
+# Extra metric dicts can be pushed from anywhere via
+#   from mvsam3d.train.train_slat_flow import log_metrics
+#   log_metrics({"val/chamfer": ..., "val/psnr": ...}, step)
+# --------------------------------------------------------------------------- #
+wandb:
+  enabled: true
+  project: "mvsam3d-slatflow"
+  entity: "alphabet1"
+  name: "slatflow_resume22p5k_pslocc_bs12"
+  dir: "/lp-dev/jonghoon/mv-mesh/wandb"
+
+# --------------------------------------------------------------------------- #
+# val_appforce — APPEARANCE-FORCING validation (mvsam3d/train/val_appforce.py):
+# the trained flow through the exact reported protocol (batch_appforce_sam3d
+# sam3d_geom_dino 2v -> evaluate_appforce.py) on toys4k-100 (textured) +
+# OmniObject3D-117, every `every` optimizer steps (+ step 0 baseline), EMA
+# weights, ALL ranks sample their shard then run the reference-env decode +
+# eval on their own GPU; rank 0 merges and logs val_af/<ds>/<schedule>/<metric>.
+# Stage-1 (frozen z1fwd geometry forcing) is cached ONCE by
+#   tools/val_stage1_ref.py --mode stage1 --exp <exp> --views 2 --out
+#   <stage1_cache>/<name>/2v
+# --------------------------------------------------------------------------- #
+val_appforce:
+  enabled: false               # in-loop val OFF: tools/val_daemon.py validates every 5k ckpt on GPUs 2-3 (training never pauses)
+  every: 5000
+  at_step0: false               # first appearance-forcing val at 5000 (step-0 baseline = the parity run)
+  views: 2
+  schedules: [seed, reinject]   # seed = the training x0 construction; reinject = the reported schedule
+  seed: 42
+  limit: 0                      # debug: cap objects per dataset
+  batch_size: 6                 # objects per BATCHED 25-step ODE solve (1 = old single path)
+  single: true                 # batched B=6 measured 0.8x slower than single; parity verified but no gain
+  decode_procs: 1              # 2 procs x 23 GB OOMed rank 3 at the 10k val
+  ref_threads: 8                # OMP/MKL cap for every reference-env subprocess
+  stage1_cache: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/stage1
+  out_root: /lp-dev/jonghoon/mv-sam3d-6d-code/val_appforce/runs
+  ref_python: /lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/bin/python
+  eval_dataset_flag: toys4k     # evaluate_appforce --dataset (both sets use the toys4k path, as reported)
+  datasets:
+    - name: toys4k100_tex
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/toys4k100_tex
+    - name: omni3d
+      exp: /lp-dev/jonghoon/mv-mesh/exp_faithfulness/omni3d

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen/bunny_003.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14502f014a45dee714dbd919e394b419a72e95419897303bc7386eed8e0a5508
+size 20996178

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen/bunny_008.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92e4ff59ac962b00dc5a5975913c5e952ece70ab3a640d25c0727bd68265ae08
+size 20511442

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen/chair_026.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bdf5dc60ce5b61d76bb78762bd5895cdb21ff3a49252f63d9ef8007c73ed3ffd
+size 20690002

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen/ours_both.log

@@ -0,0 +1,51 @@
+/lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/lib/python3.11/site-packages/torch/cuda/__init__.py:61: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.
+  import pynvml  # type: ignore[import]
+2026-09-01 01:49:09.196 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.sparse:__from_env:39 - [SPARSE] Backend: spconv, Attention: sdpa
+2026-09-01 01:49:12.938 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.attention:__from_env:30 - [ATTENTION] Using backend: sdpa
+[SPARSE][CONV] spconv algo: native
+[slat-pretrained] slat_generator: loaded 526/526 own tensors from '_base_models.generator.*' (0 missing, 0 unexpected)
+2026-09-01 01:49:25.245 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:32 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-09-01 01:49:29.957 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:51 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-09-01 01:49:29.961 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:32 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-09-01 01:49:33.784 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:51 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+[slat-pretrained] slat_condition_embedder: loaded 699/699 own tensors from '_base_models.condition_embedder.*' (0 missing, 0 unexpected)
+[slat-pretrained] slat_generator: loaded 526/526 own tensors from '_base_models.generator.*' (0 missing, 0 unexpected)
+2026-09-01 01:49:44.041 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:32 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-09-01 01:49:47.428 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:51 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-09-01 01:49:47.431 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:32 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-09-01 01:49:51.389 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:51 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+[slat-pretrained] slat_condition_embedder: loaded 699/699 own tensors from '_base_models.condition_embedder.*' (0 missing, 0 unexpected)
+[ours] bunny_003 (N=7984, ref steps=25 strength=1.0 rescale_t=1.0 | deployed self-noise floor=0.000e+00 tol=5.000e-02)
+  [raw]
+    cond                   BIT-IDENTICAL  shape=(1, 5496, 1024) dtype=torch.float16 max|d|=0.000e+00
+    slat_feats_noise   WITHIN-FLOOR  max|d|=6.896e-03 (tol 5.000e-02)
+    slat_feats_forced  WITHIN-FLOOR  max|d|=9.228e-03 (tol 5.000e-02)
+  [wrapped/zero-bias]
+    cond                   BIT-IDENTICAL  shape=(1, 5496, 1024) dtype=torch.float16 max|d|=0.000e+00
+    slat_feats_noise   WITHIN-FLOOR  max|d|=6.896e-03 (tol 5.000e-02)
+    wrapped==raw (noise)   BIT-IDENTICAL  shape=(7984, 8) dtype=torch.float32 max|d|=0.000e+00
+    slat_feats_forced  WITHIN-FLOOR  max|d|=9.228e-03 (tol 5.000e-02)
+    wrapped==raw (forced)  BIT-IDENTICAL  shape=(7984, 8) dtype=torch.float32 max|d|=0.000e+00
+[ours] bunny_008 (N=4619, ref steps=25 strength=1.0 rescale_t=1.0 | deployed self-noise floor=0.000e+00 tol=5.000e-02)
+  [raw]
+    cond                   BIT-IDENTICAL  shape=(1, 5496, 1024) dtype=torch.float16 max|d|=0.000e+00
+    slat_feats_noise   WITHIN-FLOOR  max|d|=3.383e-03 (tol 5.000e-02)
+    slat_feats_forced  WITHIN-FLOOR  max|d|=4.269e-03 (tol 5.000e-02)
+  [wrapped/zero-bias]
+    cond                   BIT-IDENTICAL  shape=(1, 5496, 1024) dtype=torch.float16 max|d|=0.000e+00
+    slat_feats_noise   WITHIN-FLOOR  max|d|=3.383e-03 (tol 5.000e-02)
+    wrapped==raw (noise)   BIT-IDENTICAL  shape=(4619, 8) dtype=torch.float32 max|d|=0.000e+00
+    slat_feats_forced  WITHIN-FLOOR  max|d|=4.269e-03 (tol 5.000e-02)
+    wrapped==raw (forced)  BIT-IDENTICAL  shape=(4619, 8) dtype=torch.float32 max|d|=0.000e+00
+[ours] chair_026 (N=5858, ref steps=25 strength=1.0 rescale_t=1.0 | deployed self-noise floor=0.000e+00 tol=5.000e-02)
+  [raw]
+    cond                   BIT-IDENTICAL  shape=(1, 5496, 1024) dtype=torch.float16 max|d|=0.000e+00
+    slat_feats_noise   WITHIN-FLOOR  max|d|=5.830e-03 (tol 5.000e-02)
+    slat_feats_forced  WITHIN-FLOOR  max|d|=1.043e-02 (tol 5.000e-02)
+  [wrapped/zero-bias]
+    cond                   BIT-IDENTICAL  shape=(1, 5496, 1024) dtype=torch.float16 max|d|=0.000e+00
+    slat_feats_noise   WITHIN-FLOOR  max|d|=5.830e-03 (tol 5.000e-02)
+    wrapped==raw (noise)   BIT-IDENTICAL  shape=(5858, 8) dtype=torch.float32 max|d|=0.000e+00
+    slat_feats_forced  WITHIN-FLOOR  max|d|=1.043e-02 (tol 5.000e-02)
+    wrapped==raw (forced)  BIT-IDENTICAL  shape=(5858, 8) dtype=torch.float32 max|d|=0.000e+00
+[ours] PARITY PASS

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen/probe2_ref.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9518028c75f9bb983889d290b85f83e15fc8435e2072127aab57e4c7d1a4f53
+size 10685283

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen/probe_ref.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:033cd057451f09ac3883647d92a9685d10ca7c0d81f87dc9f1ce94724caf402d
+size 43640209

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen/ref.log

@@ -0,0 +1,73 @@
+/lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/lib/python3.11/site-packages/torch/cuda/__init__.py:61: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.
+  import pynvml  # type: ignore[import]
+2026-08-31 18:47:31.995 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.sparse:__from_env:39 - [SPARSE] Backend: spconv, Attention: sdpa
+2026-08-31 18:47:38.280 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.attention:__from_env:30 - [ATTENTION] Using backend: sdpa
+[SPARSE][CONV] spconv algo: native
+Warp 1.12.1 initialized:
+   CUDA Toolkit 12.9, Driver 13.0
+   Devices:
+     "cpu"      : "x86_64"
+     "cuda:0"   : "NVIDIA A100-SXM4-80GB" (79 GiB, sm_80, mempool enabled)
+   Kernel cache:
+     /home/nvidia/.cache/warp/1.12.1
+2026-08-31 18:47:49.271 | INFO     | sam3d_objects.pipeline.inference_pipeline:set_attention_backend:15 - GPU name is NVIDIA A100-SXM4-80GB
+2026-08-31 18:47:53.396 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+2026-08-31 18:47:53.397 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+[ref] building deployed pipeline ...
+2026-08-31 18:47:53.453 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+/lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/lib/python3.11/site-packages/moge/model/v1.py:172: UserWarning: The following deprecated/invalid arguments are ignored: {'output_mask': True, 'split_head': True}
+  warnings.warn(f"The following deprecated/invalid arguments are ignored: {deprecated_kwargs}")
+2026-08-31 18:48:02.212 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+2026-08-31 18:48:02.214 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:98 - self.device: cuda
+2026-08-31 18:48:02.214 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:99 - CUDA_VISIBLE_DEVICES: 1
+2026-08-31 18:48:02.214 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:100 - Actually using GPU: 0
+2026-08-31 18:48:02.214 | INFO     | sam3d_objects.pipeline.inference_pipeline:init_pose_decoder:295 - Using pose decoder: ScaleShiftInvariant
+2026-08-31 18:48:02.214 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:131 - Loading model weights...
+2026-08-31 18:48:02.515 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/ss_generator.ckpt
+2026-08-31 18:48:13.901 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_generator.ckpt
+2026-08-31 18:48:19.400 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/ss_decoder.ckpt
+2026-08-31 18:48:19.979 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_decoder_gs.ckpt
+2026-08-31 18:48:20.456 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_decoder_gs_4.ckpt
+2026-08-31 18:48:21.159 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_decoder_mesh.ckpt
+2026-08-31 18:48:21.987 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:31 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-08-31 18:48:23.321 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:44 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-08-31 18:48:23.330 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:31 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-08-31 18:48:24.723 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:44 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-08-31 18:48:24.776 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/ss_generator.ckpt
+2026-08-31 18:48:31.503 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:31 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-08-31 18:48:32.940 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:44 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-08-31 18:48:32.949 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:31 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-08-31 18:48:34.490 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:44 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-08-31 18:48:34.519 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_generator.ckpt
+2026-08-31 18:48:40.669 | INFO     | sam3d_objects.pipeline.inference_pipeline:override_ss_generator_cfg_config:520 - ss_generator parameters: inference_steps=25, cfg_strength=7, cfg_interval=[0, 500], rescale_t=3, cfg_strength_pm=0.0
+2026-08-31 18:48:40.669 | INFO     | sam3d_objects.pipeline.inference_pipeline:override_slat_generator_cfg_config:542 - slat_generator parameters: inference_steps=25, cfg_strength=1, cfg_interval=[0, 500], rescale_t=1
+2026-08-31 18:48:40.669 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:196 - Loading model weights completed!
+[ref] pipeline ready: slat steps=25 strength=1 interval=[0, 500] rescale_t=1
+2026-08-31 18:48:42.723 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:48:43.063 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 18:48:43.065 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 18:48:43.065 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:48:43.246 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 18:48:51.925 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 18:48:51.925 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:48:52.142 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+[ref] chair_026: N=5858 cond=(1, 5496, 1024)/torch.float16 feats=(5858, 8)/torch.float32 -> /lp-dev/jonghoon/mv-sam3d-6d-code/migrator/code/mv-sam3d-for-6d-v2/migrator/cache/parity_slatgen/chair_026.pt
+2026-08-31 18:49:00.060 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:49:00.226 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 18:49:00.227 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 18:49:00.227 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:49:00.389 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 18:49:09.140 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 18:49:09.140 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:49:09.316 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+[ref] bunny_003: N=7984 cond=(1, 5496, 1024)/torch.float16 feats=(7984, 8)/torch.float32 -> /lp-dev/jonghoon/mv-sam3d-6d-code/migrator/code/mv-sam3d-for-6d-v2/migrator/cache/parity_slatgen/bunny_003.pt
+2026-08-31 18:49:18.333 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:49:18.496 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 18:49:18.497 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 18:49:18.497 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:49:18.660 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 18:49:26.196 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 18:49:26.196 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 18:49:26.401 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+[ref] bunny_008: N=4619 cond=(1, 5496, 1024)/torch.float16 feats=(4619, 8)/torch.float32 -> /lp-dev/jonghoon/mv-sam3d-6d-code/migrator/code/mv-sam3d-for-6d-v2/migrator/cache/parity_slatgen/bunny_008.pt
+[ref] DONE

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen_b/bunny_003.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14502f014a45dee714dbd919e394b419a72e95419897303bc7386eed8e0a5508
+size 20996178

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen_b/bunny_008.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92e4ff59ac962b00dc5a5975913c5e952ece70ab3a640d25c0727bd68265ae08
+size 20511442

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen_b/chair_026.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bdf5dc60ce5b61d76bb78762bd5895cdb21ff3a49252f63d9ef8007c73ed3ffd
+size 20690002

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/parity_slatgen_b/ref.log

@@ -0,0 +1,73 @@
+/lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/lib/python3.11/site-packages/torch/cuda/__init__.py:61: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.
+  import pynvml  # type: ignore[import]
+2026-08-31 19:04:42.766 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.sparse:__from_env:39 - [SPARSE] Backend: spconv, Attention: sdpa
+2026-08-31 19:04:47.903 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.attention:__from_env:30 - [ATTENTION] Using backend: sdpa
+[SPARSE][CONV] spconv algo: native
+Warp 1.12.1 initialized:
+   CUDA Toolkit 12.9, Driver 13.0
+   Devices:
+     "cpu"      : "x86_64"
+     "cuda:0"   : "NVIDIA A100-SXM4-80GB" (79 GiB, sm_80, mempool enabled)
+   Kernel cache:
+     /home/nvidia/.cache/warp/1.12.1
+2026-08-31 19:04:56.352 | INFO     | sam3d_objects.pipeline.inference_pipeline:set_attention_backend:15 - GPU name is NVIDIA A100-SXM4-80GB
+2026-08-31 19:04:58.555 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+2026-08-31 19:04:58.555 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+[ref] building deployed pipeline ...
+2026-08-31 19:04:58.594 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+/lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/lib/python3.11/site-packages/moge/model/v1.py:172: UserWarning: The following deprecated/invalid arguments are ignored: {'output_mask': True, 'split_head': True}
+  warnings.warn(f"The following deprecated/invalid arguments are ignored: {deprecated_kwargs}")
+2026-08-31 19:05:08.207 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+2026-08-31 19:05:08.209 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:98 - self.device: cuda
+2026-08-31 19:05:08.209 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:99 - CUDA_VISIBLE_DEVICES: 1
+2026-08-31 19:05:08.209 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:100 - Actually using GPU: 0
+2026-08-31 19:05:08.209 | INFO     | sam3d_objects.pipeline.inference_pipeline:init_pose_decoder:295 - Using pose decoder: ScaleShiftInvariant
+2026-08-31 19:05:08.209 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:131 - Loading model weights...
+2026-08-31 19:05:08.653 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/ss_generator.ckpt
+2026-08-31 19:05:20.732 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_generator.ckpt
+2026-08-31 19:05:25.889 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/ss_decoder.ckpt
+2026-08-31 19:05:26.449 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_decoder_gs.ckpt
+2026-08-31 19:05:26.881 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_decoder_gs_4.ckpt
+2026-08-31 19:05:27.467 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_decoder_mesh.ckpt
+2026-08-31 19:05:28.226 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:31 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-08-31 19:05:30.056 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:44 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-08-31 19:05:30.065 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:31 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-08-31 19:05:31.477 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:44 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-08-31 19:05:31.522 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/ss_generator.ckpt
+2026-08-31 19:05:39.237 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:31 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-08-31 19:05:40.567 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:44 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-08-31 19:05:40.576 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:31 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-08-31 19:05:41.857 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:44 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-08-31 19:05:41.882 | INFO     | sam3d_objects.model.io:load_model_from_checkpoint:158 - Loading checkpoint from checkpoints/hf/slat_generator.ckpt
+2026-08-31 19:05:48.113 | INFO     | sam3d_objects.pipeline.inference_pipeline:override_ss_generator_cfg_config:520 - ss_generator parameters: inference_steps=25, cfg_strength=7, cfg_interval=[0, 500], rescale_t=3, cfg_strength_pm=0.0
+2026-08-31 19:05:48.114 | INFO     | sam3d_objects.pipeline.inference_pipeline:override_slat_generator_cfg_config:542 - slat_generator parameters: inference_steps=25, cfg_strength=1, cfg_interval=[0, 500], rescale_t=1
+2026-08-31 19:05:48.114 | INFO     | sam3d_objects.pipeline.inference_pipeline:__init__:196 - Loading model weights completed!
+[ref] pipeline ready: slat steps=25 strength=1 interval=[0, 500] rescale_t=1
+2026-08-31 19:05:48.971 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:05:49.265 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 19:05:49.267 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 19:05:49.267 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:05:49.431 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 19:05:57.635 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 19:05:57.635 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:05:57.803 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+[ref] chair_026: N=5858 cond=(1, 5496, 1024)/torch.float16 feats=(5858, 8)/torch.float32 -> /lp-dev/jonghoon/mv-sam3d-6d-code/migrator/code/mv-sam3d-for-6d-v2/migrator/cache/parity_slatgen_b/chair_026.pt
+2026-08-31 19:06:05.500 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:06:05.675 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 19:06:05.676 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 19:06:05.676 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:06:05.827 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 19:06:14.623 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 19:06:14.623 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:06:14.843 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+[ref] bunny_003: N=7984 cond=(1, 5496, 1024)/torch.float16 feats=(7984, 8)/torch.float32 -> /lp-dev/jonghoon/mv-sam3d-6d-code/migrator/code/mv-sam3d-for-6d-v2/migrator/cache/parity_slatgen_b/bunny_003.pt
+2026-08-31 19:06:22.977 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:06:23.201 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 19:06:23.202 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 19:06:23.202 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:06:23.378 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+2026-08-31 19:06:30.672 | INFO     | sam3d_objects.pipeline.inference_pipeline:sample_slat:860 - Sampling sparse latent: inference_steps=25, strength=1, interval=[0, 500], rescale_t=1
+2026-08-31 19:06:30.672 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:748 - Running condition embedder ...
+2026-08-31 19:06:30.837 | INFO     | sam3d_objects.pipeline.inference_pipeline:get_condition_input:752 - Condition embedder finishes!
+[ref] bunny_008: N=4619 cond=(1, 5496, 1024)/torch.float16 feats=(4619, 8)/torch.float32 -> /lp-dev/jonghoon/mv-sam3d-6d-code/migrator/code/mv-sam3d-for-6d-v2/migrator/cache/parity_slatgen_b/bunny_008.pt
+[ref] DONE

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/smoke_slatflow.log

@@ -0,0 +1,19 @@
+/lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/lib/python3.11/site-packages/torch/cuda/__init__.py:61: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.
+  import pynvml  # type: ignore[import]
+2026-09-01 01:55:05.629 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.sparse:__from_env:39 - [SPARSE] Backend: spconv, Attention: sdpa
+2026-09-01 01:55:09.659 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.attention:__from_env:30 - [ATTENTION] Using backend: sdpa
+2026-09-01 01:55:15.109 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+[SPARSE][CONV] spconv algo: native
+[smoke] object=chair_026 N=5858 n_subset=2 views=[0, 1, 2, 3] crops=(4, 3, 518, 518) uv=(4, 5858, 2) vis=(4, 5858) plucker=(1, 1369, 6) bias_views=1
+[slat-pretrained] slat_generator: loaded 526/526 own tensors from '_base_models.generator.*' (0 missing, 0 unexpected)
+2026-09-01 01:55:25.930 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:32 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-09-01 01:55:31.714 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:51 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-09-01 01:55:31.718 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:32 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-09-01 01:55:36.823 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:51 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+[slat-pretrained] slat_condition_embedder: loaded 699/699 own tensors from '_base_models.condition_embedder.*' (0 missing, 0 unexpected)
+[smoke] model built: trainable=617.7M bias_enabled=True
+[smoke] flow_step: loss=0.7099 frac_visible_x0=0.510 frac_target=0.702
+[smoke] grad norms: backbone=6.378e+01 fuser=2.272e+00 plucker_fc=3.835e-02
+[smoke] bias: shape=(1394, 6865) anchor_max|.|=0.0 nonanchor_vals=[-10.0, 0.0] frac_open=0.0066
+[smoke] sample: cond=(1, 6865, 1024) base=(1, 5858, 8) slat feats=(5858, 8) finite=True std=4.557
+[smoke] SELF-CHECK PASS

migrator/code/mv-sam3d-for-6d-v2-ssflow/migrator/cache/train_slatflow_smoke.log

@@ -0,0 +1,28 @@
+/lp-dev/jonghoon/mv-mesh/envs/mv-sam3d/lib/python3.11/site-packages/torch/cuda/__init__.py:61: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.
+  import pynvml  # type: ignore[import]
+2026-09-01 01:56:18.594 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.sparse:__from_env:39 - [SPARSE] Backend: spconv, Attention: sdpa
+2026-09-01 01:56:22.431 | INFO     | sam3d_objects.model.backbone.tdfy_dit.modules.attention:__from_env:30 - [ATTENTION] Using backend: sdpa
+[SPARSE][CONV] spconv algo: native
+[train] train samples: 201
+[train] val samples: 100
+[slat-pretrained] slat_generator: loaded 526/526 own tensors from '_base_models.generator.*' (0 missing, 0 unexpected)
+2026-09-01 01:56:35.604 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:32 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-09-01 01:56:40.418 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:51 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+2026-09-01 01:56:40.422 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:32 - Loading DINO model: dinov2_vitl14_reg from facebookresearch/dinov2 (source: github)
+2026-09-01 01:56:45.101 | INFO     | sam3d_objects.model.backbone.dit.embedder.dino:__init__:51 - Loaded DINO model - type: <class 'dinov2.models.vision_transformer.DinoVisionTransformer'>, embed_dim: 1024, patch_size: (14, 14)
+[slat-pretrained] slat_condition_embedder: loaded 699/699 own tensors from '_base_models.condition_embedder.*' (0 missing, 0 unexpected)
+[setup] trainable params: 617.7M / 1226.5M (enable_bias=True, fp16_torso=False)
+/lp-dev/jonghoon/mv-sam3d-6d-code/migrator/code/mv-sam3d-for-6d-v2/mvsam3d/train/train_slat_flow.py:277: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.
+  scaler = torch.cuda.amp.GradScaler(enabled=use_scaler)
+[setup] backend=ddp world=1 global_batch=2 (objects/optim-step) steps=2 grad_accum=2 amp=True/bf16 val_every=2
+2026-09-01 01:56:54.846 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+2026-09-01 01:56:54.854 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+2026-09-01 01:56:54.893 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+2026-09-01 01:56:54.945 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+[train] step 1 lr=4.000000e-07 frac_target=0.7416 frac_visible_x0=0.6616 loss=0.9653 loss/slat=0.9653 (0.14 it/s)
+[train] step 2 lr=6.000000e-07 frac_target=0.7212 frac_visible_x0=0.4989 loss=1.9295 loss/slat=1.9295 (0.48 it/s)
+2026-09-01 01:57:04.080 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+2026-09-01 01:57:04.091 | WARNING  | sam3d_objects.data.dataset.tdfy.preprocessor:__post_init__:51 - No rgb pointmap normalizer provided, using scale + shift 
+[val] step 2 frac_target=0.5975 frac_visible_x0=0.4419 loss=0.9582 loss/slat=0.9582 (n=2)
+[train] saved /lp-dev/jonghoon/mv-sam3d-6d-code/migrator/cache/ckpt_slatflow/step_0000002.pt
+[train] done.

migrator/code/mv-sam3d-for-6d-v2-ssflow/mvsam3d/data/__pycache__/adapters.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:859d14326540e24088b672bc15940079ab435832247d5921114087cdbcb3a342
+size 118636

migrator/code/mv-sam3d-for-6d-v2-ssflow/mvsam3d/data/__pycache__/slatflow_dataset.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:920741be4f6ca85689c3629a6d65f832b0a060dbc701db71a0a7bcfd131e179e
+size 126300

migrator/code/mv-sam3d-for-6d-v2-ssflow/mvsam3d/data/slatflow_dataset.py

@@ -903,6 +903,53 @@ class TrellisSlatFlowDataset(TrellisSSFlowDataset):
         }
 
 
+# ---- RecGen camera QC (2026-09-24) ------------------------------------------ #
+# A RecGen view's camera is VALID iff the object's OWN SLAT voxels, projected with
+# that view's camera, land inside RecGen's (modal) mask in proportion to how much
+# of the object RecGen says is visible:
+#     p  = #voxels projecting inside the mask / #voxels        (all voxels)
+#     vf = RecGen view_metadata visible_fraction (modal / amodal)
+#     valid  <=>  vf >= RG_VF_MIN  and  p >= RG_RATIO * vf
+# With a correct pose p ~= vf (occluders remove voxels from the modal mask exactly
+# as they remove visible area).  Calibrated on 4,000 random RecGen sets against our
+# latents: keeps 99.0% of views of trusted analytic poses (p/vf p01 = 0.72), 0% of
+# the analytic poses that failed their own seed test.  Object guard: if fewer than
+# RG_OBJ_MIN_FRAC of the object's verifiable (vf >= RG_VF_MIN) views pass, the pose
+# is treated as systematically wrong and ALL its RecGen views are dropped (the
+# object falls back to white-only, or is skipped if it has no white cond).
+RG_VF_MIN = 0.10
+RG_RATIO = 0.60
+RG_OBJ_MIN_FRAC = 0.50
+
+
+def recgen_view_qc(coords3: np.ndarray, views_all: List[Dict], masks: List[np.ndarray],
+                   vfs: Sequence[float], vf_min: float = RG_VF_MIN,
+                   ratio: float = RG_RATIO, obj_min_frac: float = RG_OBJ_MIN_FRAC):
+    """-> (valid view indices, per-view p).  coords3 (N,3) int voxel coords of the
+    object's SLAT latent; views_all[i] has fx,fy,cx,cy,c2w (rigid, SLAT cube);
+    masks[i] (H,W) bool; vfs[i] RecGen visible_fraction."""
+    pts = (np.asarray(coords3, dtype=np.float64) + 0.5) / VOX - 0.5
+    N = max(len(pts), 1)
+    ps, ok = [], []
+    for v, m, vf in zip(views_all, masks, vfs):
+        w2c = np.linalg.inv(v["c2w"])
+        xc = pts @ w2c[:3, :3].T + w2c[:3, 3]
+        z = xc[:, 2]
+        zs = np.where(z == 0, 1e-12, z)
+        u = np.round(v["fx"] * xc[:, 0] / zs + v["cx"]).astype(np.int64)
+        q = np.round(v["fy"] * xc[:, 1] / zs + v["cy"]).astype(np.int64)
+        H, W = m.shape[:2]
+        inf = (z > 0) & (u >= 0) & (u < W) & (q >= 0) & (q < H)
+        p = float(m[q[inf], u[inf]].sum()) / N
+        ps.append(p)
+        ok.append(bool(vf >= vf_min and p >= ratio * vf))
+    verifiable = sum(1 for vf in vfs if vf >= vf_min)
+    valid = [i for i, o in enumerate(ok) if o]
+    if not valid or len(valid) < obj_min_frac * verifiable:
+        valid = []
+    return valid, ps
+
+
 DEFAULT_TAR_ROOTS = ("/data/mv_mesh_data/slat_tars/processed",)
 DEFAULT_TAR_MANIFESTS = "/data/mv_mesh_data/DATASET_INDEX/hubman/processed/manifests"
 
@@ -960,30 +1007,33 @@ class TarSlatFlowDataset(TrellisSlatFlowDataset):
                  shards: Optional[Sequence[str]] = None,
                  max_objects: Optional[int] = None,
                  use_recgen_images: bool = False,
-                 p_recgen_image: float = 0.0,
                  cond_cameras_fallback: bool = False):
-        # ---- condition-variant knobs (2026-09-24; all OFF by default -> the
-        # index, the draws and every item are byte-identical to the legacy path)
+        # ---- condition-source knobs (2026-09-24).  Class defaults OFF -> index,
+        # draws and every item byte-identical to the legacy loader.  The PROD
+        # config (train_slatflow_prod.yaml) turns BOTH ON.
         #   use_recgen_images : also index ``recgen/<id>/{cameras.json,NN.jpg,
         #       NN_mask.png}`` members (RecGen's own background-baked RGB + its
         #       visible mask + per-view RIGID OpenCV c2w in the SLAT cube) from ANY
-        #       tar under tar_roots, joined to ``latents/<id>.npz`` by id.  Objects
-        #       with a latent + RecGen images but NO white cond (latent-only new
-        #       slats) become trainable instead of being silently skipped.
-        #   p_recgen_image    : when an object has BOTH sources, P(use RecGen) per
-        #       (sample, epoch) on its own rng stream (offset 9191).  Objects with
-        #       only one source always use it.
-        #       RecGen variant = the SAME default path with the RecGen full-frame
-        #       image (background kept, alpha = RecGen mask) substituted for the
-        #       white cond render in the preprocess_slat_image slot (item["image"]);
+        #       tar under tar_roots, joined to ``latents/<id>.npz`` by the SAME id
+        #       string.  Conditioning then follows the ONE-POOL rule:
+        #         * an object with BOTH sources draws its anchor uniformly from the
+        #           union of its (valid) white cond views and (valid) RecGen views;
+        #         * the anchor's source decides everything: ALL auxiliary views of
+        #           the sample come from that same source (and its cameras) — a
+        #           sample never mixes white and RecGen views;
+        #         * single-source objects draw exactly as the legacy loader does on
+        #           the source they have (white-only items are byte-identical to
+        #           legacy; latent-only RecGen slats become trainable).
+        #       A RecGen anchor goes through the SAME default path: the full-frame
+        #       RecGen image (background kept, alpha = its mask) is fed to
+        #       preprocess_slat_image -> item["image"] (+ mask/rgb_image/...);
         #       DINO seed crops / uv / vis use the mask-matted tight crop exactly
-        #       like the white path, cameras = RecGen per-view c2w.
+        #       like the white path.
         #   cond_cameras_fallback : white-cond objects lacking
         #       ``cameras/<id>/cond_cameras.json`` (the 24-view slat5/slat5rs
         #       batches) use ``cond/<id>/transforms.json`` (same transform_matrix;
         #       fx=fy=W/(2 tan(camera_angle_x/2)), cx=cy=W/2 from the PNG width).
         self.use_recgen_images = bool(use_recgen_images)
-        self.p_recgen_image = float(p_recgen_image)
         self.cond_cameras_fallback = bool(cond_cameras_fallback)
         # NOTE: deliberately does NOT call TrellisSlatFlowDataset.__init__ (that
         # scans object DIRS).  We set the attributes its shared methods
@@ -1062,7 +1112,7 @@ class TarSlatFlowDataset(TrellisSlatFlowDataset):
                 # new index semantics -> distinct cache signature (legacy sig
                 # unchanged when both knobs are off, so old caches stay valid)
                 parts.append(f"rg={int(self.use_recgen_images)}"
-                             f":fb={int(self.cond_cameras_fallback)}:v1")
+                             f":fb={int(self.cond_cameras_fallback)}:v2")
             return _hashlib.sha1("|".join(parts).encode()).hexdigest()
         _sig = _tar_sig(tar_files)
         _cache = os.environ.get("TAR_INDEX_CACHE") or os.path.join(
@@ -1290,9 +1340,27 @@ class TarSlatFlowDataset(TrellisSlatFlowDataset):
             views_all.append(dict(depth=None, fx=float(K[0, 0]), fy=float(K[1, 1]),
                                   cx=float(K[0, 2]), cy=float(K[1, 2]),
                                   c2w=np.asarray(c["c2w"], dtype=np.float64),
-                                  res=int(max(int(c["width"]), int(c["height"])))))
+                                  res=int(max(int(c["width"]), int(c["height"]))),
+                                  vf=float(c.get("visible_fraction", -1.0))))
         return views_all, len(views_all)
 
+    def _rg_qc_valid(self, sha: str, m: Dict, views_all: List[Dict],
+                     sc: np.ndarray) -> List[int]:
+        """RecGen views passing the camera QC (recgen_view_qc), cached per object."""
+        key = (sha, "rgqc")
+        v = self._valid_cache.get(key)
+        if v is not None:
+            return v
+        r = m["rg"]
+        tar = self._get_tar(r["tar"])
+        masks = [np.array(Image.open(io.BytesIO(tar.extractfile(n).read())).convert("L")) > 127
+                 for n in r["masks"]]
+        valid, _ = recgen_view_qc(sc, views_all, masks, [vw["vf"] for vw in views_all])
+        if len(self._valid_cache) > 20000:
+            self._valid_cache.clear()
+        self._valid_cache[key] = valid
+        return valid
+
     def _load_view_rgba(self, m: Dict, src: str, i: int) -> np.ndarray:
         """FULL-FRAME RGBA uint8 of view i.  white: the cond render PNG.  recgen:
         RecGen's RGB (background kept) + its visible mask as alpha (>127)."""
@@ -1307,18 +1375,6 @@ class TarSlatFlowDataset(TrellisSlatFlowDataset):
             return np.concatenate([rgb, a], axis=2)
         return self._load_png_rgba(self._get_tar(m["tar"]), m["cond_pngs"][i])
 
-    def _cond_source(self, idx: int, m: Dict) -> str:
-        """'white' | 'recgen' for this (sample, epoch).  Own rng stream (9191)."""
-        has_w = bool(m.get("cond_pngs"))
-        has_r = m.get("rg") is not None
-        if has_r and not has_w:
-            return "recgen"
-        if has_r and has_w and self.p_recgen_image > 0.0:
-            r = float(np.random.default_rng(
-                [self.seed, int(self._epoch), int(idx), 9191]).random())
-            return "recgen" if r < self.p_recgen_image else "white"
-        return "white"
-
     # ---- OPT-IN bad-view gate (tar variant, keyed by sha) -------------- #
     def _tar_valid_views(self, sha: str, tar, views_all, sc, centers, V,
                          src: str = "white") -> List[int]:
@@ -1381,11 +1437,17 @@ class TarSlatFlowDataset(TrellisSlatFlowDataset):
         tar = self._get_tar(m["tar"])
         rng = np.random.default_rng([self.seed, self._epoch, idx])
 
-        src = self._cond_source(idx, m)          # 'white' unless recgen knobs on
-        if src == "recgen":
-            views_all, V = self._rg_cameras(m)
-        else:
-            views_all, V = self._tar_cameras(tar, m)
+        # ---- condition sources present for this object ------------------- #
+        # white  = cond/<id>/NNN.png + its cameras   (always, legacy objects)
+        # recgen = recgen/<id>/NN.jpg + NN_mask.png + cameras.json
+        #          (only indexed when use_recgen_images=True)
+        has_w = bool(m.get("cond_pngs"))
+        has_r = m.get("rg") is not None
+        cams = {}
+        if has_w:
+            cams["white"] = self._tar_cameras(tar, m)
+        if has_r:
+            cams["recgen"] = self._rg_cameras(m)
 
         # x1 = released SLAT: coords 0..63 used DIRECTLY, feats row-aligned.
         zl = np.load(io.BytesIO(tar.extractfile(m["latent"]).read()))
@@ -1398,15 +1460,64 @@ class TarSlatFlowDataset(TrellisSlatFlowDataset):
                             torch.from_numpy(sc).int()], dim=1)      # (N,4) int32
         centers = (sc.astype(np.float64) + 0.5) / VOX - 0.5
 
-        n_sub, no_seed, mode = self._mixture_n_sub(idx, V, rng)
-        if self.filter_bad_views:                  # OPT-IN: draw only from valid
-            valid_arr = np.asarray(
-                self._tar_valid_views(sha, tar, views_all, sc, centers, V, src),
-                dtype=int)
-            n_sub = min(int(n_sub), len(valid_arr))
-            sub = rng.choice(valid_arr, size=n_sub, replace=False)  # anchor in valid
+        # RecGen camera QC (always on for RecGen views): only views whose camera
+        # projects this object's own voxels into RecGen's mask consistently with
+        # RecGen's visible_fraction may enter the pool.  None valid -> the
+        # object's RecGen set is dropped (white-only fallback, or skipped).
+        rg_ok = None
+        if has_r:
+            rg_ok = self._rg_qc_valid(sha, m, cams["recgen"][0], sc)
+            if not rg_ok:
+                has_r = False
+        if not (has_w or has_r):
+            raise ValueError(f"{sha}: no condition view passes (white cond absent, "
+                             f"all RecGen views fail camera QC)")
+
+        def _valid_for(s):
+            va, Vs = cams[s]
+            fb = (np.asarray(self._tar_valid_views(sha, tar, va, sc, centers, Vs, s),
+                             dtype=int) if self.filter_bad_views
+                  else np.arange(Vs, dtype=int))
+            if s == "recgen":                     # QC is the hard rule
+                both = np.asarray([i for i in fb if i in set(rg_ok)], dtype=int)
+                fb = both if len(both) else np.asarray(rg_ok, dtype=int)
+            return fb
+
+        if not (has_w and has_r):
+            # SINGLE source (white-only = every legacy object; recgen-only = the
+            # latent-only new slats): the exact legacy draw on that source.
+            src = "white" if has_w else "recgen"
+            views_all, V = cams[src]
+            n_sub, no_seed, mode = self._mixture_n_sub(idx, V, rng)
+            if src == "recgen":                   # QC-valid (+ bad-view gate) only
+                valid_arr = _valid_for("recgen")
+                n_sub = min(int(n_sub), len(valid_arr))
+                sub = rng.choice(valid_arr, size=n_sub, replace=False)
+            elif self.filter_bad_views:            # OPT-IN: draw only from valid
+                valid_arr = np.asarray(
+                    self._tar_valid_views(sha, tar, views_all, sc, centers, V, src),
+                    dtype=int)
+                n_sub = min(int(n_sub), len(valid_arr))
+                sub = rng.choice(valid_arr, size=n_sub, replace=False)  # anchor in valid
+            else:
+                sub = rng.choice(V, size=n_sub, replace=False)
         else:
-            sub = rng.choice(V, size=n_sub, replace=False)
+            # BOTH sources -> ONE POOL.  Candidate anchors = the union of the
+            # object's (valid) white cond views and (QC-valid) RecGen views; the
+            # anchor is drawn uniformly from the pool, and the ANCHOR'S SOURCE
+            # DECIDES EVERYTHING: all auxiliary views are drawn from that same
+            # source only (with that source's cameras) — never mixed.
+            valid = {s: _valid_for(s) for s in ("white", "recgen")}
+            pool = ([("white", int(i)) for i in valid["white"]]
+                    + [("recgen", int(i)) for i in valid["recgen"]])
+            n_sub, no_seed, mode = self._mixture_n_sub(idx, len(pool), rng)
+            src, a_i = pool[int(rng.integers(len(pool)))]
+            views_all, V = cams[src]
+            rest = np.asarray([i for i in valid[src] if i != a_i], dtype=int)
+            n_sub = min(int(n_sub), 1 + len(rest))
+            aux = (rng.choice(rest, size=n_sub - 1, replace=False) if n_sub > 1
+                   else np.zeros(0, dtype=int))
+            sub = np.concatenate([[a_i], aux]).astype(int)
         order = list(sub) + [i for i in range(V) if i not in set(sub.tolist())]
 
         crops, uvs, viss, fulls = [], [], [], []

migrator/code/mv-sam3d-for-6d-v2-ssflow/mvsam3d/data/slatflow_dataset.py.bak_predatveiw

@@ -0,0 +1,804 @@
+"""TrellisSlatFlowDataset — per-view DINO inputs + cameras + SLAT target on top
+of TrellisSSFlowDataset (SLAT_GEN_PLAN §8).
+
+Reused verbatim from the SS dataset: object scan / meta.json completion marker /
+split logic, the per-(sample, epoch) view-subset RNG, and the views.npz loader
+(per-view K + c2w_cv — those cameras cover BOTH the Plücker rays and the
+voxel->patch projection; no new camera fields).
+
+Per __getitem__ (CPU only — all frozen-GPU work happens in the train step):
+  * coords_slat = downsample(prune(voxels.npz coords, dist=1)) — the exact
+    inference coordinate ops (pure coordinate transforms, run on CPU torch);
+  * a view subset S (|S| ~ U{min_views..max_views}); anchor = S[0]; view order
+    of every per-view tensor = [S..., complement...] so the model can slice
+    the subset (x0/cond) vs all views;
+  * per view: the RGBA crop in the STORED bbox frame -> 518 LANCZOS ->
+    premult-alpha-on-black float [3,518,518] (dino_features convention,
+    batch_appforce:253-264) — feeds the shared frozen DINO forward;
+  * per view: (uv, vis) — voxel-center projections through the ABSOLUTE camera
+    (project_visible: nearest-pixel depth test, TOL=0.02) with uv already in
+    the crop-frame [-1,1] grid_sample convention (sample_feats :267-275),
+    computed in float64 and cast to float32;
+  * anchor: the 4 slat condition tensors via the DEPLOYED slat_preprocessor
+    recipe (OQ-6) on the raw RGBA input image;
+  * non-anchor: per-patch anchor-relative Plücker rays [1369,6] (§4a) and the
+    soft-mask camera dicts (§4b);
+  * x1: ``slat/slat_official_sam3d.npz`` — the OFFICIAL TRELLIS-toolkit
+    latent with SAM3D's slat_encoder (RAW, all active voxels; produced by
+    ``tools/gen_x1_official.py``).  Rows are coord-hash-matched onto
+    coords_slat (a prune-subset of the voxel set) and full coverage is
+    asserted.  There is NO on-the-fly fallback: the former full-view
+    visible-mean target (reimplemented, non-official) was deleted — the
+    train step errors if the file is absent.
+
+RGB SOURCE: the production layout stores ``views/rgb/{i:03d}.webp`` + a
+``views/bbox.npy`` sidecar.  The toys4k SMOKE objects pre-date that layout, so
+when those files are missing the loader falls back to the toys4k1k render
+assets (inputs/<obj>_<view>.png = the bbox crop, renders/<obj>_<view>.npz for
+bbox/res) with the fixed front/side/oside/back view order — the exact files
+batch_appforce consumed.
+"""
+from __future__ import annotations
+
+import os
+from typing import Dict, List, Optional, Sequence
+
+import numpy as np
+import torch
+from PIL import Image
+
+from mvsam3d.data.ssflow_dataset import TrellisSSFlowDataset, load_views_npz
+from mvsam3d.data.slat_preprocess import preprocess_slat_image
+from mvsam3d.model.mv_slat_condition import plucker_rays_for_view
+
+TOL = 0.02                       # visibility depth tolerance (batch_appforce)
+VOX = 64
+# SS-stage seed-mixture mode -> integer code carried in the item/batch (mirrors
+# ss_imgcond_dataset._MODE_CODE; 'val' shares 'single'==1 as an eval label).
+_SEED_MODE_CODE = {"none": 0, "single": 1, "multi": 2, "legacy": 3, "val": 1}
+TOYS4K1K = "/lp-dev/jonghoon/mv-mesh/exp_faithfulness/toys4k1k"
+TOYS4K_VIEW_ORDER = ("front", "side", "oside", "back")
+# TRELLIS-style per-object voxel cap (structured_latent.py filter_metadata):
+# objects with MORE active 64^3 voxels than this are DROPPED at index-build
+# time (never downsampled — downsample_sparse_structure is inference-only and
+# corrupts training targets). 20000 = the single-object SLAT OOM-safe bound
+# (PLAN/BATCH_SIZE_BENCH.md; OOM at N~24000). Drops ~4.8% of trellis500k.
+MAX_NUM_VOXELS_DEFAULT = 20000
+# visibility source when a view has no rendered depth (production data):
+#   raymarch = exact self-occlusion through the 64^3 grid (default)
+#   zbuffer  = image-space min-splat (biased ~1 voxel near; see data/vis_check)
+# Calibrated against rendered-depth GT on 301 toys4k objects x 4 views
+# (data/vis_check/vis_check4.py, run4.log; agreement / IoU vs project_visible_np):
+#   zbuffer tol .03  .8762 / .6692      raymarch skip 1.5  .8113 / .4355
+#   raymarch skip 2.0 .8742 / .6646     raymarch skip 2.5  .8755 / .6724  <- default
+#   raymarch skip 3.0 .8519 / .6472     ray2.0 OR zbuf     .8757 / .6729
+# skip_vox 2.5 mirrors the GT's own TOL=0.02 slack (~1.3 voxels) plus the
+# half-voxel centre offset; it matches the z-buffer's accuracy without the
+# z-buffer's splat-radius/resolution heuristic.  ~40 ms/view (100 ms under a
+# 48-way loaded box) at N=20000.
+VIS_METHOD = os.environ.get("MVSAM3D_VIS_METHOD", "raymarch")
+VIS_SKIP_VOX = float(os.environ.get("MVSAM3D_VIS_SKIP_VOX", "2.5"))
+VIS_ZBUF_TOL = float(os.environ.get("MVSAM3D_VIS_ZBUF_TOL", "0.03"))
+
+
+def num_active_voxels(voxels_npz: str) -> int:
+    """Active 64^3 voxel count = #rows of voxels.npz 'coords'.
+
+    Reads only the .npy header inside the zip archive (streaming decompression
+    of a few hundred bytes) — cheap enough to run over the whole index at
+    dataset-build time.  Falls back to a full np.load on any header oddity."""
+    import zipfile
+    from numpy.lib import format as npfmt
+    try:
+        with zipfile.ZipFile(voxels_npz) as zf:
+            with zf.open("coords.npy") as f:
+                version = npfmt.read_magic(f)
+                shape, _, _ = npfmt._read_array_header(f, version)
+        return int(shape[0])
+    except Exception:
+        return int(np.load(voxels_npz)["coords"].shape[0])
+
+
+# --------------------------------------------------------------------------- #
+def slat_coords_from_voxels(coords3: np.ndarray) -> torch.Tensor:
+    """voxels.npz coords (N,3) -> the SLAT coord set (M,4) int32 (batch col 0):
+    prune_sparse_structure(dist=1) + downsample_sparse_structure — the exact
+    inference ops (inference_pipeline.py:818-833), on CPU."""
+    from sam3d_objects.pipeline.inference_utils import (
+        downsample_sparse_structure, prune_sparse_structure)
+    c = torch.from_numpy(np.asarray(coords3, dtype=np.int64)).int()
+    c4 = torch.cat([torch.zeros(len(c), 1, dtype=torch.int32), c], dim=1)
+    c4 = prune_sparse_structure(c4, max_neighbor_axes_dist=1)
+    c4, _ = downsample_sparse_structure(c4)
+    return c4.int()
+
+
+def project_visible_np(centers: np.ndarray, depth: np.ndarray, fx, fy, cx, cy,
+                       c2w: np.ndarray, res: int):
+    """batch_appforce_sam3d.project_visible (:236-250), verbatim numpy port.
+    centers (N,3) float64 canonical -> (u, v, z, visible)."""
+    w2c = np.linalg.inv(c2w)
+    R, t = w2c[:3, :3], w2c[:3, 3]
+    xc = centers @ R.T + t
+    z = xc[:, 2]
+    u = fx * xc[:, 0] / z + cx
+    vv = fy * xc[:, 1] / z + cy
+    ui = np.round(u).astype(int)
+    vi = np.round(vv).astype(int)
+    inframe = (z > 0) & (ui >= 0) & (ui < res) & (vi >= 0) & (vi < res)
+    dep = np.zeros(len(centers))
+    dep[inframe] = depth[vi[inframe], ui[inframe]]
+    visible = inframe & (dep > 0) & (np.abs(z - dep) < TOL)
+    return u, vv, z, visible
+
+
+def zbuffer_visible(centers: np.ndarray, fx, fy, cx, cy, c2w: np.ndarray,
+                    res: int, tol: float = TOL):
+    """Per-voxel visibility from the object's OWN voxels (no depth image).
+
+    Self-occlusion test: every voxel is splatted into a per-view z-buffer over
+    its projected footprint (min planar depth per pixel); a voxel is visible
+    iff its own depth is within ``tol`` of the buffer at its centre pixel —
+    i.e. nothing closer covers it.  This is the same decision rule as
+    ``project_visible_np`` with the rendered depth map replaced by the depth
+    of the voxelised surface itself (exact up to the 64^3 voxel size, which is
+    below ``tol`` = 0.02 ~ 1.3 voxels).  Returns (u, v, z, visible) like
+    ``project_visible_np``.  Production renders (slat50k cond views) ship no
+    depth pass, so this is the visibility source for training; the eval sets
+    keep their rendered GT depth."""
+    w2c = np.linalg.inv(c2w)
+    R, t = w2c[:3, :3], w2c[:3, 3]
+    xc = centers @ R.T + t
+    z = xc[:, 2]
+    u = fx * xc[:, 0] / z + cx
+    vv = fy * xc[:, 1] / z + cy
+    ui = np.round(u).astype(int)
+    vi = np.round(vv).astype(int)
+    inframe = (z > 0) & (ui >= 0) & (ui < res) & (vi >= 0) & (vi < res)
+    visible = np.zeros(len(centers), dtype=bool)
+    if not inframe.any():
+        return u, vv, z, visible
+    # projected voxel footprint (pixels): voxel edge 1/64 at depth z
+    zf = z[inframe]
+    r = int(np.clip(np.ceil(0.5 * fx / VOX / float(np.median(zf))), 1, 16))
+    buf = np.full((res, res), np.inf, dtype=np.float64)
+    ui_f, vi_f = ui[inframe], vi[inframe]
+    for dy in range(-r, r + 1):
+        yy = vi_f + dy
+        oky = (yy >= 0) & (yy < res)
+        for dx in range(-r, r + 1):
+            xx = ui_f + dx
+            ok = oky & (xx >= 0) & (xx < res)
+            np.minimum.at(buf, (yy[ok], xx[ok]), zf[ok])
+    dep = buf[vi_f, ui_f]
+    visible[inframe] = np.abs(zf - dep) < tol
+    return u, vv, z, visible
+
+
+def raymarch_visible(centers: np.ndarray, coords3: np.ndarray, fx, fy, cx, cy,
+                     c2w: np.ndarray, res: int, skip_vox: float = 2.5,
+                     step_vox: float = 0.5):
+    """Per-voxel visibility by EXACT ray marching through the 64^3 occupancy
+    grid (no image-space splatting, hence none of the z-buffer's near-bias):
+    a voxel is visible iff the ray from its centre to the camera centre meets
+    no occupied voxel beyond ``skip_vox`` voxels from itself (the skip keeps
+    the voxel's own surface neighbours from blocking grazing rays, and matches
+    the rendered-depth reference's TOL=0.02 depth slack; see VIS_SKIP_VOX for
+    the calibration).  Returns (u, v, z, visible) like ``project_visible_np``."""
+    occ = np.zeros((VOX, VOX, VOX), dtype=bool)
+    c3 = np.asarray(coords3, dtype=np.int64)
+    occ[c3[:, 0], c3[:, 1], c3[:, 2]] = True
+    w2c = np.linalg.inv(c2w)
+    R, t = w2c[:3, :3], w2c[:3, 3]
+    xc = centers @ R.T + t
+    z = xc[:, 2]
+    u = fx * xc[:, 0] / z + cx
+    vv = fy * xc[:, 1] / z + cy
+    ui = np.round(u).astype(int)
+    vi = np.round(vv).astype(int)
+    inframe = (z > 0) & (ui >= 0) & (ui < res) & (vi >= 0) & (vi < res)
+    cam = c2w[:3, 3]
+    d = cam[None, :] - centers                       # (N,3) towards the camera
+    dist = np.linalg.norm(d, axis=1)
+    d = d / np.maximum(dist[:, None], 1e-9)
+    # march only while still inside the cube: t_max = exit distance of the ray
+    # from [-0.5,0.5]^3 (voxels outside are never occupied)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        t1 = (-0.5 - centers) / d
+        t2 = (0.5 - centers) / d
+        t_exit = np.nanmin(np.where(d != 0, np.maximum(t1, t2), np.inf), axis=1)
+    t_max = np.minimum(dist, t_exit)
+    # march the still-unblocked voxels only (active set shrinks fast: most
+    # voxels are occluded within a few steps), 16 steps per vectorised chunk
+    occf = occ.reshape(-1)
+    step = step_vox / VOX
+    t = skip_vox / VOX
+    blocked = np.zeros(len(centers), dtype=bool)
+    act = np.flatnonzero(inframe)
+    CH = 16
+    while act.size:
+        tt = t + step * np.arange(CH)                       # (CH,)
+        ca, da, tm = centers[act], d[act], t_max[act]
+        pts = ca[:, None, :] + tt[None, :, None] * da[:, None, :]   # (A,CH,3)
+        valid = tt[None, :] <= tm[:, None]
+        gi = np.floor((pts + 0.5) * VOX).astype(np.int64)
+        inside = valid & np.all((gi >= 0) & (gi < VOX), axis=2)
+        np.clip(gi, 0, VOX - 1, out=gi)
+        flat = (gi[..., 0] * VOX + gi[..., 1]) * VOX + gi[..., 2]
+        hit = (occf[flat] & inside).any(axis=1)
+        blocked[act[hit]] = True
+        t = float(tt[-1]) + step
+        act = act[~hit & (tm >= t)]
+    visible = inframe & ~blocked
+    return u, vv, z, visible
+
+
+def crop_uv_norm(u: np.ndarray, v: np.ndarray, bbox) -> np.ndarray:
+    """sample_feats' grid_sample coords (:267-275): render-frame (u,v) -> the
+    crop-frame [-1,1] convention, float64 -> float32.  (N,2)."""
+    y0, y1, x0, x1 = [float(b) for b in bbox]
+    # PER-AXIS normalisation: the stored crop is rgba[y0:y1, x0:x1] (no square
+    # padding, adapt_slat50k.crop_bbox clamps at the frame edge) and is resized
+    # anisotropically to 518x518, so u maps by the crop WIDTH and v by its
+    # HEIGHT.  Identical to the old single-`side` formula whenever w == h.
+    w = x1 - x0
+    h = y1 - y0
+    un = (u - x0 + 0.5) / w * 2 - 1
+    vn = (v - y0 + 0.5) / h * 2 - 1
+    return np.stack([un, vn], -1).astype(np.float32)
+
+
+def rgba_to_crop(rgba_uint8: np.ndarray) -> Dict[str, np.ndarray]:
+    """In-memory RGBA uint8 (H,W,4) -> {'premult' [3,518,518] float32
+    (dino_features recipe: 518 LANCZOS + alpha-premult on black),
+    'rgba_uint8' (H,W,4)}.  Shared by the clean-RGBA file loader and the
+    RecGen matting path (which has no on-disk RGBA)."""
+    im = Image.fromarray(np.ascontiguousarray(rgba_uint8), mode="RGBA")
+    im518 = im.resize((518, 518), Image.Resampling.LANCZOS)
+    a = np.array(im518).astype(np.float32) / 255.0
+    rgb = a[:, :, :3] * a[:, :, 3:4]           # premult alpha on BLACK
+    return {"premult": rgb.transpose(2, 0, 1), "rgba_uint8": rgba_uint8}
+
+
+def load_crop_rgba(path: str) -> Dict[str, np.ndarray]:
+    """RGBA crop file -> {'premult' [3,518,518] float32 (dino_features recipe:
+    518 LANCZOS + alpha-premult on black), 'rgba_uint8' (H,W,4)} ."""
+    return rgba_to_crop(np.array(Image.open(path).convert("RGBA")))
+
+
+def matte_rgba(rgb_uint8: np.ndarray, mask_uint8: np.ndarray) -> np.ndarray:
+    """RGB (H,W,3) + binary/greyscale mask (H,W) -> RGBA (H,W,4) uint8 CROPPED
+    to the mask's bounding box.  The RecGen ALPHA the SLAT loader's visibility
+    gate needs: cond_image has BACKGROUND baked in and no alpha, so the object
+    mask (prefer cond_mask_sam2, fallback cond_mask) becomes the alpha channel.
+    Returns the tight-bbox crop so ``crop_uv_norm`` / the alpha gate work exactly
+    as they do on the clean transparent-background renders."""
+    rgb = np.asarray(rgb_uint8)
+    m = np.asarray(mask_uint8)
+    if m.ndim == 3:
+        m = m[..., 0]
+    a = (m > 127).astype(np.uint8) * 255
+    ys, xs = np.nonzero(a)
+    if len(ys) == 0:                              # empty mask: whole frame
+        y0, y1, x0, x1 = 0, rgb.shape[0], 0, rgb.shape[1]
+    else:
+        y0, y1 = int(ys.min()), int(ys.max()) + 1
+        x0, x1 = int(xs.min()), int(xs.max()) + 1
+    rgba = np.concatenate([rgb, a[..., None]], axis=2)      # (H,W,4)
+    crop = rgba[y0:y1, x0:x1]
+    return crop, (float(y0), float(y1), float(x0), float(x1))
+
+
+# --------------------------------------------------------------------------- #
+class TrellisSlatFlowDataset(TrellisSSFlowDataset):
+    """SLAT-flow training samples: SS dataset + per-view RGB/DINO inputs,
+    cameras, and the x1 target hookup."""
+
+    def __init__(self, *args, toys4k1k_root: str = TOYS4K1K,
+                 max_num_voxels: Optional[int] = MAX_NUM_VOXELS_DEFAULT,
+                 p_seed_none: float = 0.0,       # unified mixture: P(EMPTY seed)
+                 p_seed_single: float = 0.0,     # P(single-view seed); rest=multi
+                 recgen_roots: Optional[Sequence[str]] = None,
+                 recgen_pose_store: Optional[str] = None,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        self.toys4k1k_root = toys4k1k_root
+        # encoded_store recgen root holding the canonical cube cameras
+        # (pose_cube.npz / views.npz) looked up by sha; None -> analytic fallback.
+        self._recgen_pose_store = recgen_pose_store
+        # ---- SS-STAGE seed MIXTURE (mirror of ss_imgcond_dataset.seed_mode) --
+        # p_seed_none  = P(EMPTY appearance seed -> x0 all-noise, no forcing)
+        # p_seed_single= P(single-view seed -> n_sub == 1)
+        # remainder    = multi (n_sub ~ U{max(2,min_views)..max_views})
+        # BOTH == 0.0 -> the LEGACY path (n_sub ~ U{min_views..max_views}), which
+        # is byte-identical to the pre-mixture behaviour.  VAL (fixed_num_views
+        # set) is never randomised.  Own rng stream (offset 4242 for the mode,
+        # 7717 for the multi view-count) so the mixture never perturbs the
+        # existing view-subset / crop draws on the main [seed,epoch,idx] stream.
+        self.p_seed_none = float(p_seed_none)
+        self.p_seed_single = float(p_seed_single)
+        assert self.p_seed_none + self.p_seed_single <= 1.0 + 1e-9, (
+            self.p_seed_none, self.p_seed_single)
+        # TRELLIS-style max_num_voxels FILTER (mirror of datasets/
+        # structured_latent.py filter_metadata: metadata['num_voxels'] <= cap):
+        # applied at index-build time so oversized objects never reach the
+        # loader.  None / 0 disables the filter.
+        self.max_num_voxels = int(max_num_voxels) if max_num_voxels else None
+        if self.max_num_voxels:
+            n_before = len(self.dirs)
+            self.dirs = [
+                d for d in self.dirs
+                if num_active_voxels(os.path.join(d, "geometry", "voxels.npz"))
+                <= self.max_num_voxels
+            ]
+            n_drop = n_before - len(self.dirs)
+            print(f"[slatflow-data] split={self.split} max_num_voxels="
+                  f"{self.max_num_voxels}: kept {len(self.dirs)}/{n_before} "
+                  f"objects (dropped {n_drop})", flush=True)
+            if not self.dirs:
+                raise RuntimeError(
+                    f"max_num_voxels={self.max_num_voxels} dropped every object "
+                    f"in split={self.split}")
+
+        # ---- RecGen roots (ADDITIVE, opt-in) --------------------------------
+        # RecGen sample objects (<root>/<id>/ with slat_coords.npy + slat_feats.npy
+        # + cond_image_*.jpg + cond_mask*.png + view_metadata.json) do NOT carry a
+        # meta.json / geometry/voxels.npz, so they are invisible to scan_objects.
+        # Scan them separately and APPEND to self.dirs, tracking which dirs are
+        # recgen in self._recgen so __getitem__ can route them to the matting /
+        # released-SLAT loader.  Non-recgen behaviour is untouched.
+        self._recgen = set()
+        if recgen_roots:
+            import glob as _glob
+            if isinstance(recgen_roots, (str, os.PathLike)):
+                recgen_roots = [recgen_roots]
+            rg = []
+            for root in recgen_roots:
+                for sc in _glob.iglob(os.path.join(root, "*", "slat_coords.npy")):
+                    rg.append(os.path.dirname(sc))
+            rg = sorted(set(rg))
+            self._recgen = set(rg)
+            self.dirs = list(self.dirs) + rg
+            print(f"[slatflow-data] split={self.split} recgen_roots: added "
+                  f"{len(rg)} recgen objects (total {len(self.dirs)})", flush=True)
+
+    # ---- SS-stage seed mixture (mirror of ss_imgcond_dataset.seed_mode) -- #
+    def seed_mode(self, idx: int, epoch: int) -> str:
+        """'none' | 'single' | 'multi' | 'legacy' for this (object, epoch).
+
+        Own rng stream (offset 4242) so the mode decision never perturbs the
+        [seed,epoch,idx] view-subset / crop draws.  VAL (fixed_num_views set)
+        keeps the fixed eval view count (returns 'single' as an unused label —
+        __getitem__ pins n_sub to fixed_num_views in that case).  With BOTH
+        knobs 0.0 the mixture is OFF -> 'legacy' (no draw, main stream
+        untouched)."""
+        if self.fixed_num_views is not None:          # val: unchanged
+            return "single"
+        if self.p_seed_none <= 0.0 and self.p_seed_single <= 0.0:
+            return "legacy"
+        r = float(np.random.default_rng(
+            [self.seed, int(epoch), int(idx), 4242]).random())
+        if r < self.p_seed_none:
+            return "none"
+        if r < self.p_seed_none + self.p_seed_single:
+            return "single"
+        return "multi"
+
+    # ---- per-object RGB/bbox adapter ---------------------------------- #
+    def _rgb_assets(self, obj_dir: str, name: str, n_views: int) -> List[Dict]:
+        """-> per-view dict(png=..., bbox=(4,), res=int).  Production layout
+        first (views/rgb + views/bbox.npy); toys4k1k fallback for smoke."""
+        rgb_dir = os.path.join(obj_dir, "views", "rgb")
+        bbox_path = os.path.join(obj_dir, "views", "bbox.npy")
+        if os.path.isdir(rgb_dir) and os.path.isfile(bbox_path):
+            bboxes = np.load(bbox_path)
+            out = []
+            for i in range(n_views):
+                png = os.path.join(rgb_dir, f"{i:03d}.png")      # lossless (adapter)
+                if not os.path.isfile(png):
+                    png = os.path.join(rgb_dir, f"{i:03d}.webp")
+                out.append(dict(png=png, bbox=bboxes[i].astype(np.float64), res=None))
+            return out
+        # toys4k smoke fallback (bbox/res from the render npz; png = the crop)
+        out = []
+        for i in range(n_views):
+            tag = TOYS4K_VIEW_ORDER[i]
+            png = os.path.join(self.toys4k1k_root, "inputs", f"{name}_{tag}.png")
+            rz = np.load(os.path.join(self.toys4k1k_root, "renders",
+                                      f"{name}_{tag}.npz"))
+            out.append(dict(png=png, bbox=rz["bbox"].astype(np.float64),
+                            res=int(rz["res"])))
+        return out
+
+    # ---- SS-stage seed-mixture view-count selection --------------------- #
+    def _mixture_n_sub(self, idx: int, V: int, rng) -> tuple:
+        """Return (n_sub, no_seed, mode).  With the mixture OFF (both knobs 0.0) this
+        is the LEGACY draw — ``rng.integers(min_views, max_views+1)`` off the
+        MAIN [seed,epoch,idx] stream — byte-identical to the pre-mixture path.
+        With the mixture ON the mode comes from the independent 4242 stream
+        (seed_mode), the multi view-count from the independent 7717 stream, so
+        the main stream (and thus the ``sub`` view choice) is only advanced by
+        the legacy branch — exactly as before."""
+        if self.fixed_num_views is not None:              # VAL: never randomised
+            return min(int(self.fixed_num_views), V), False, "val"
+        mode = self.seed_mode(idx, self._epoch)
+        if mode == "legacy":
+            return (min(int(rng.integers(self.min_views, self.max_views + 1)), V),
+                    False, "legacy")
+        if mode == "none":            # EMPTY appearance seed: 1 cond view, x0 all-noise
+            return min(1, V), True, "none"
+        if mode == "single":
+            return min(1, V), False, "single"
+        # multi: n_sub ~ U{max(2,min_views) .. max_views}
+        lo = max(2, int(self.min_views))
+        hi = max(lo, int(self.max_views))
+        k = int(np.random.default_rng(
+            [self.seed, int(self._epoch), int(idx), 7717]).integers(lo, hi + 1))
+        return min(k, V), False, "multi"
+
+    # ---- item ----------------------------------------------------------- #
+    def __getitem__(self, idx: int) -> Dict:
+        d = self.dirs[idx]
+        if d in self._recgen:                       # RecGen loader (additive)
+            return self._getitem_recgen(idx)
+        name = os.path.basename(d)
+        views_path = os.path.join(d, "views", "views.npz")
+
+        # per-(sample, epoch) deterministic RNG — same recipe as SSFlow
+        rng = np.random.default_rng([self.seed, self._epoch, idx])
+        views_all = load_views_npz(views_path)          # K, c2w, depth per view
+        V = len(views_all)
+        n_sub, no_seed, mode = self._mixture_n_sub(idx, V, rng)
+        sub = rng.choice(V, size=n_sub, replace=False)
+        order = list(sub) + [i for i in range(V) if i not in set(sub.tolist())]
+
+        # SLAT coord set (exact inference coordinate ops)
+        vox = np.load(os.path.join(d, "geometry", "voxels.npz"))
+        coords = slat_coords_from_voxels(vox["coords"])            # (N,4) int32
+        centers = (coords[:, 1:].numpy().astype(np.float64) + 0.5) / VOX - 0.5
+
+        assets = self._rgb_assets(d, name, V)
+
+        # Only the SAMPLED subset S feeds the model (cond = anchor + S[1:],
+        # x0 seed = visible-mean over S, x1 = the precomputed official target),
+        # so crops/uv/vis are built for S ONLY: an 8-view object costs |S| <= 4
+        # DINO forwards + projections, not 8.  view_order still lists all views.
+        crops, uvs, viss = [], [], []
+        for i in order[:n_sub]:
+            vw = views_all[i]
+            a = assets[i]
+            if a["res"] is not None:
+                res = a["res"]
+            elif vw["depth"] is not None:
+                res = vw["depth"].shape[0]
+            else:
+                res = vw["res"]
+            if vw["depth"] is not None:          # rendered GT depth (eval sets)
+                u, vv, z, vis = project_visible_np(
+                    centers, vw["depth"], vw["fx"], vw["fy"], vw["cx"], vw["cy"],
+                    vw["c2w"], res)
+            elif VIS_METHOD == "zbuffer":        # production: from the voxels
+                u, vv, z, vis = zbuffer_visible(
+                    centers, vw["fx"], vw["fy"], vw["cx"], vw["cy"], vw["c2w"], res,
+                    tol=VIS_ZBUF_TOL)
+            else:                                # production: exact grid ray march
+                u, vv, z, vis = raymarch_visible(
+                    centers, vox["coords"], vw["fx"], vw["fy"], vw["cx"], vw["cy"],
+                    vw["c2w"], res, skip_vox=VIS_SKIP_VOX)
+            crop = load_crop_rgba(a["png"])
+            uvn = crop_uv_norm(u, vv, a["bbox"])
+            # --- MODAL-MASK (alpha) VISIBILITY GATE ------------------------ #
+            # The geometric tests above (rendered depth / z-buffer / ray march)
+            # only know about the OBJECT's own surface, so they call a voxel
+            # visible even when the stored view actually shows something else
+            # in front of it (PSL occlusion crops) or when the projection falls
+            # outside the stored crop.  The stored RGBA's alpha channel IS the
+            # per-view MODAL mask (what is really seen), so gate `vis` by it:
+            # nearest-pixel lookup in the crop frame (grid_sample's
+            # align_corners=False convention, i.e. px = (un+1)/2*W - 0.5), NO
+            # dilation.  On occluder-free renders (the base pool) alpha covers
+            # the whole silhouette, so this is a near no-op (edge pixels only).
+            alpha = crop["rgba_uint8"][..., 3]
+            Hc, Wc = alpha.shape[0], alpha.shape[1]
+            px = np.rint((uvn[:, 0].astype(np.float64) + 1.0) * 0.5 * Wc - 0.5).astype(np.int64)
+            py = np.rint((uvn[:, 1].astype(np.float64) + 1.0) * 0.5 * Hc - 0.5).astype(np.int64)
+            inside = (px >= 0) & (px < Wc) & (py >= 0) & (py < Hc)
+            vis = np.asarray(vis) & inside
+            if inside.any():
+                vis[inside] &= alpha[py[inside], px[inside]] > 0
+            # --- EMPTY-SEED ('none') gate: contribute ZERO forced x0 rows ---
+            # The x0 appearance seed is built model-side as the visible-mean of
+            # the rows any view marks visible; an all-False `vis` therefore
+            # forces no rows (x0 stays pure noise) while leaving the condition
+            # (DINO crops / cameras) untouched.  Belt-and-suspenders with the
+            # `no_seed` batch flag honoured in slatflow_model.flow_step.
+            if no_seed:
+                vis = np.zeros_like(np.asarray(vis), dtype=bool)
+            # --------------------------------------------------------------- #
+            crops.append(crop)
+            uvs.append(uvn)
+            viss.append(vis)
+
+        # anchor condition inputs (deployed slat_preprocessor recipe, OQ-6)
+        slat_input = preprocess_slat_image(crops[0]["rgba_uint8"])
+
+        # non-anchor Plücker + soft-mask camera dicts (subset views S[1:])
+        anchor_c2w = torch.from_numpy(views_all[order[0]]["c2w"])
+        pluckers, bias_views = [], []
+        for k in range(1, n_sub):
+            i = order[k]
+            vw = views_all[i]
+            a = assets[i]
+            res = (a["res"] if a["res"] is not None else
+                   (vw["depth"].shape[0] if vw["depth"] is not None else vw["res"]))
+            pluckers.append(plucker_rays_for_view(
+                anchor_c2w, torch.from_numpy(vw["c2w"]),
+                vw["fx"], vw["fy"], vw["cx"], vw["cy"], a["bbox"]))
+            bias_views.append(dict(
+                w2c=torch.from_numpy(np.linalg.inv(vw["c2w"])).float(),
+                fx=vw["fx"], fy=vw["fy"], cx=vw["cx"], cy=vw["cy"],
+                bbox=[float(b) for b in a["bbox"]], res=float(res)))
+        plucker = (torch.stack(pluckers) if pluckers
+                   else torch.zeros(0, 1369, 6))
+
+        item = {
+            "name": name,
+            "coords": coords,                                       # (N,4) int32
+            "slat_input": slat_input,                # dict of 4 CPU tensors
+            "crops": torch.from_numpy(np.stack([c["premult"] for c in crops])),
+            "uv": torch.from_numpy(np.stack(uvs)),                  # (V,N,2) f32
+            "vis": torch.from_numpy(np.stack(viss)),                # (V,N) bool
+            "plucker": plucker,                                     # (n_sub-1,1369,6)
+            "bias_views": bias_views,
+            "n_subset": n_sub,
+            "view_order": [int(i) for i in order],
+            # SS-stage seed-mixture flags (default: legacy/no-op).  no_seed=True
+            # => EMPTY appearance seed (x0 pure noise, honoured in flow_step).
+            "no_seed": torch.tensor(bool(no_seed)),
+            "seed_mode": torch.tensor(float(_SEED_MODE_CODE[mode])),
+        }
+
+        # OFFICIAL precomputed x1 target (tools/gen_x1_official.py output):
+        # the exact TRELLIS-toolkit latent (SAM3D slat_encoder) on the FULL
+        # active-voxel set — coord-hash-match its rows onto coords_slat (a
+        # prune-subset of the voxels) and assert every row is covered.
+        slat_npz = os.path.join(d, "slat", "slat_official_sam3d.npz")
+        if os.path.isfile(slat_npz):
+            z = np.load(slat_npz)
+            oc = z["coords"].astype(np.int64)               # (M,3) all voxels
+            ok = (oc[:, 0] * VOX + oc[:, 1]) * VOX + oc[:, 2]
+            order = np.argsort(ok)
+            want_c = coords[:, 1:].numpy().astype(np.int64)
+            want = (want_c[:, 0] * VOX + want_c[:, 1]) * VOX + want_c[:, 2]
+            pos = np.searchsorted(ok[order], want)
+            sel = order[np.clip(pos, 0, len(order) - 1)]
+            assert len(ok) > 0 and np.array_equal(ok[sel], want), \
+                (f"{name}: slat_official_sam3d.npz does not cover coords_slat "
+                 f"(official voxel set mismatch — regenerate with "
+                 f"tools/gen_x1_official.py)")
+            item["x1_feats_raw"] = torch.from_numpy(
+                z["feats"][sel].astype(np.float32))         # (N,8) RAW
+        return item
+
+    # ---- RecGen matting loader (additive) ------------------------------- #
+    def _recgen_cube_c2w(self, d: str, n: int):
+        """Locate the CORRECT camera->cube poses (c2w in the [-0.5,0.5] voxel
+        frame the SLAT loader projects into).  RecGen's cube cameras come from
+        the ANALYTIC ``pose_cube`` conversion (pose_scale / orientation), NOT a
+        simple inv(model2world)@cam2world of the raw view_metadata — that lands
+        the object BEHIND the camera (z<0).  So prefer, in order:
+          1. ``pose_cube.npz`` (c2w_cube) inside the object dir or a views20/;
+          2. the encoded_store's pose_cube.npz / views.npz(c2w_cv), looked up by
+             sha under ``recgen_pose_store`` when set.
+        Returns (c2w array (n,4,4)) or None if no canonical source is found."""
+        import glob as _glob
+        cands = [os.path.join(d, "pose_cube.npz"),
+                 os.path.join(d, "views20", "pose_cube.npz"),
+                 os.path.join(d, "views", "pose_cube.npz")]
+        store = getattr(self, "_recgen_pose_store", None)
+        if store:
+            sha = os.path.basename(d)
+            sf = os.path.join(d, "sha256.txt")
+            if os.path.isfile(sf):
+                sha = open(sf).read().strip() or sha
+            base = os.path.join(store, "objects", sha[:2], sha)
+            cands += [os.path.join(base, "views20", "pose_cube.npz"),
+                      os.path.join(base, "views", "pose_cube.npz")]
+            for vp in (os.path.join(base, "views20", "views.npz"),
+                       os.path.join(base, "views", "views.npz")):
+                if os.path.isfile(vp):
+                    z = np.load(vp)
+                    if "c2w_cv" in z.files:
+                        c = np.asarray(z["c2w_cv"], dtype=np.float64)
+                        if c.shape[0] >= n:
+                            return c[:n]
+        for p in cands:
+            if os.path.isfile(p):
+                z = np.load(p)
+                key = "c2w_cube" if "c2w_cube" in z.files else (
+                    "c2w_cv" if "c2w_cv" in z.files else None)
+                if key is not None:
+                    c = np.asarray(z[key], dtype=np.float64)
+                    if c.shape[0] >= n:
+                        return c[:n]
+        return None
+
+    def _recgen_cameras(self, d: str):
+        """RecGen view_metadata.json -> (views_all, V) in the SAME per-view dict
+        shape ``load_views_npz`` produces (depth=None, fx/fy/cx/cy, c2w, res).
+
+        Intrinsics come from view_metadata.json[i]["intrinsics"] (fx=fy=610,
+        cx=320, cy=240, 640x480).  The camera->cube EXTRINSIC prefers the
+        canonical pose_cube (see _recgen_cube_c2w); if none is found it falls
+        back to the ANALYTIC inv(model2world)@cam2world, which is format-correct
+        but geometrically APPROXIMATE (raw view_metadata alone does not yield the
+        cube frame — see report caveat #2).  transforms.json is empty ({}) and
+        pose_data.json holds the OBJECT 6D pose, not cameras, in these samples."""
+        import json
+        vm_path = os.path.join(d, "view_metadata.json")
+        vm = json.load(open(vm_path))
+        vm = [json.loads(s) if isinstance(s, str) else s for s in vm]
+        V = len(vm)
+        cube = self._recgen_cube_c2w(d, V)          # (V,4,4) canonical, or None
+        views_all = []
+        for i, m in enumerate(vm):
+            K = np.asarray(m["intrinsics"], dtype=np.float64)
+            H = int(m.get("height", 480)); W = int(m.get("width", 640))
+            if cube is not None:
+                c2w = cube[i]
+            else:                                    # approximate fallback
+                c2w = (np.linalg.inv(np.asarray(m["model2world"], dtype=np.float64))
+                       @ np.asarray(m["cam2world"], dtype=np.float64))
+            views_all.append(dict(
+                depth=None,
+                fx=float(K[0, 0]), fy=float(K[1, 1]),
+                cx=float(K[0, 2]), cy=float(K[1, 2]),
+                c2w=c2w, res=int(max(H, W))))
+        return views_all, V
+
+    def _recgen_asset(self, d: str, i: int):
+        """View i -> {'rgba': matted RGBA crop, 'bbox': (y0,y1,x0,x1), 'res': int}.
+        cond_image_i (RGB, background baked in) x cond_mask (prefer the SAM2 mask,
+        fallback the plain mask) -> RGBA so the SLAT alpha-visibility gate works."""
+        img_p = os.path.join(d, f"cond_image_{i:02d}.jpg")
+        rgb = np.array(Image.open(img_p).convert("RGB"))
+        mask_p = os.path.join(d, f"cond_mask_sam2_{i:02d}.png")
+        if not os.path.isfile(mask_p):
+            mask_p = os.path.join(d, f"cond_mask_{i:02d}.png")
+        mask = np.array(Image.open(mask_p).convert("L"))
+        crop_rgba, bbox = matte_rgba(rgb, mask)
+        return dict(rgba=crop_rgba, bbox=bbox, res=int(max(rgb.shape[0], rgb.shape[1])))
+
+    def _getitem_recgen(self, idx: int) -> Dict:
+        d = self.dirs[idx]
+        name = os.path.basename(d)
+
+        rng = np.random.default_rng([self.seed, self._epoch, idx])
+        views_all, V = self._recgen_cameras(d)
+        n_sub, no_seed, mode = self._mixture_n_sub(idx, V, rng)
+        sub = rng.choice(V, size=n_sub, replace=False)
+        order = list(sub) + [i for i in range(V) if i not in set(sub.tolist())]
+
+        # x1 = RecGen's RELEASED SLAT (slat_coords 0..63 int + slat_feats [N,8]).
+        # The released coords ARE the final SLAT coord set (1:1 with slat_feats),
+        # so they are used directly as `coords` (no prune/downsample: RecGen ships
+        # no voxels.npz) and slat_feats is the row-aligned x1 target.  Coverage
+        # is 1:1 by construction; assert the row counts match.
+        sc = np.load(os.path.join(d, "slat_coords.npy")).astype(np.int64)  # (N,3)
+        feats = np.load(os.path.join(d, "slat_feats.npy")).astype(np.float32)  # (N,8)
+        assert sc.ndim == 2 and sc.shape[1] == 3 and feats.shape[0] == sc.shape[0], \
+            (f"{name}: recgen slat_coords {sc.shape} / slat_feats {feats.shape} "
+             f"mismatch (x1 rows must align 1:1 with coords)")
+        assert sc.min() >= 0 and sc.max() < VOX, (name, sc.min(), sc.max())
+        coords = torch.cat([torch.zeros(len(sc), 1, dtype=torch.int32),
+                            torch.from_numpy(sc).int()], dim=1)      # (N,4) int32
+        centers = (sc.astype(np.float64) + 0.5) / VOX - 0.5
+
+        crops, uvs, viss = [], [], []
+        for i in order[:n_sub]:
+            vw = views_all[i]
+            a = self._recgen_asset(d, i)
+            res = a["res"]
+            u, vv, z, vis = raymarch_visible(
+                centers, sc, vw["fx"], vw["fy"], vw["cx"], vw["cy"],
+                vw["c2w"], res, skip_vox=VIS_SKIP_VOX)
+            crop = rgba_to_crop(a["rgba"])
+            uvn = crop_uv_norm(u, vv, a["bbox"])
+            # modal-mask (alpha) gate — identical to the clean-RGBA path
+            alpha = crop["rgba_uint8"][..., 3]
+            Hc, Wc = alpha.shape[0], alpha.shape[1]
+            px = np.rint((uvn[:, 0].astype(np.float64) + 1.0) * 0.5 * Wc - 0.5).astype(np.int64)
+            py = np.rint((uvn[:, 1].astype(np.float64) + 1.0) * 0.5 * Hc - 0.5).astype(np.int64)
+            inside = (px >= 0) & (px < Wc) & (py >= 0) & (py < Hc)
+            vis = np.asarray(vis) & inside
+            if inside.any():
+                vis[inside] &= alpha[py[inside], px[inside]] > 0
+            if no_seed:
+                vis = np.zeros_like(np.asarray(vis), dtype=bool)
+            crops.append(crop)
+            uvs.append(uvn)
+            viss.append(vis)
+            a["_bbox"] = a["bbox"]                    # keep for plucker reuse
+            views_all[i]["_asset"] = a
+
+        slat_input = preprocess_slat_image(crops[0]["rgba_uint8"])
+
+        anchor_c2w = torch.from_numpy(views_all[order[0]]["c2w"])
+        pluckers, bias_views = [], []
+        for k in range(1, n_sub):
+            i = order[k]
+            vw = views_all[i]
+            a = vw["_asset"]
+            res = a["res"]
+            pluckers.append(plucker_rays_for_view(
+                anchor_c2w, torch.from_numpy(vw["c2w"]),
+                vw["fx"], vw["fy"], vw["cx"], vw["cy"], a["bbox"]))
+            bias_views.append(dict(
+                w2c=torch.from_numpy(np.linalg.inv(vw["c2w"])).float(),
+                fx=vw["fx"], fy=vw["fy"], cx=vw["cx"], cy=vw["cy"],
+                bbox=[float(b) for b in a["bbox"]], res=float(res)))
+        plucker = (torch.stack(pluckers) if pluckers else torch.zeros(0, 1369, 6))
+
+        return {
+            "name": name,
+            "coords": coords,
+            "slat_input": slat_input,
+            "crops": torch.from_numpy(np.stack([c["premult"] for c in crops])),
+            "uv": torch.from_numpy(np.stack(uvs)),
+            "vis": torch.from_numpy(np.stack(viss)),
+            "plucker": plucker,
+            "bias_views": bias_views,
+            "n_subset": n_sub,
+            "view_order": [int(i) for i in order],
+            "no_seed": torch.tensor(bool(no_seed)),
+            "seed_mode": torch.tensor(float(_SEED_MODE_CODE[mode])),
+            "x1_feats_raw": torch.from_numpy(feats),      # (N,8) RAW released SLAT
+        }
+
+
+def collate_single(batch: Sequence[Dict]) -> Dict:
+    """bs=1 collate (variable N per object => per-object steps + grad accum)."""
+    assert len(batch) == 1, \
+        "SLAT flow trains bs=1 per object (grad accum for larger batches)"
+    return batch[0]
+
+
+def collate_batched(batch: Sequence[Dict]) -> Dict:
+    """Multi-object collate mirroring TRELLIS ``SLat.collate_fn``: the B
+    objects' SLAT coords are CONCATENATED into one coordinate set whose batch
+    column ([b,x,y,z]) is the object index, with per-object ``layout`` slices
+    recorded.  Everything with a per-object variable shape (crops, uv, vis,
+    plucker, condition inputs, targets) stays a python list — the batched
+    model path builds each object's own condition and seed from them.
+
+    Consumed by ``SlatFlowModel.sample_batch`` (true batched inference:
+    one forward per solver step for all B objects)."""
+    coords_parts: List[torch.Tensor] = []
+    layout: List[slice] = []
+    ofs = 0
+    for i, it in enumerate(batch):
+        c = it["coords"].clone()
+        assert int(c[:, 0].max()) == 0, "per-object coords must have batch col 0"
+        c[:, 0] = i                             # batch-index column
+        coords_parts.append(c)
+        layout.append(slice(ofs, ofs + c.shape[0]))
+        ofs += c.shape[0]
+    return {
+        "coords": torch.cat(coords_parts, dim=0),          # (T_total,4) int32
+        "layout": layout,                                   # per-object slices
+        "names": [it["name"] for it in batch],
+        "slat_input": [it["slat_input"] for it in batch],
+        "crops": [it["crops"] for it in batch],
+        "uv": [it["uv"] for it in batch],
+        "vis": [it["vis"] for it in batch],
+        "plucker": [it["plucker"] for it in batch],
+        "bias_views": [it["bias_views"] for it in batch],
+        "n_subset": [int(it["n_subset"]) for it in batch],
+        "view_order": [it["view_order"] for it in batch],
+        "x1_feats_raw": [it.get("x1_feats_raw") for it in batch],
+        # SS-stage seed-mixture flags (per object; default legacy/no-op)
+        "no_seed": [bool(it["no_seed"]) if it.get("no_seed") is not None else False
+                    for it in batch],
+        "seed_mode": [float(it["seed_mode"]) if it.get("seed_mode") is not None else 3.0
+                      for it in batch],
+    }