Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+raw_pants_train_test/metadata/pants-captions-ldm/canonical/canonical_facts.jsonl filter=lfs diff=lfs merge=lfs -text
+raw_pants_train_test/metadata/pants-captions-ldm/captions/captions_final.jsonl filter=lfs diff=lfs merge=lfs -text
+raw_pants_train_test/metadata/pants-captions-ldm/captions/captions_v2_after_fusion.jsonl filter=lfs diff=lfs merge=lfs -text

model_cache_code_step8000/cache/RESTORE.txt

@@ -0,0 +1,2 @@
+cat cache/wan22_pants_v2_softwin.tar.zst.part-* > wan22_pants_v2_softwin.tar.zst
+tar --use-compress-program zstd -xf wan22_pants_v2_softwin.tar.zst

model_cache_code_step8000/checkpoints/checkpoint-8000/transformer/config.json

@@ -0,0 +1,23 @@
+{
+    "_class_name": "WanTransformer3DModel",
+    "added_kv_proj_dim": null,
+    "attention_head_dim": 128,
+    "cross_attn_norm": true,
+    "eps": 1e-06,
+    "ffn_dim": 14336,
+    "freq_dim": 256,
+    "image_dim": null,
+    "in_channels": 48,
+    "num_attention_heads": 24,
+    "num_layers": 30,
+    "out_channels": 48,
+    "patch_size": [
+        1,
+        2,
+        2
+    ],
+    "pos_embed_seq_len": null,
+    "qk_norm": "rms_norm_across_heads",
+    "rope_max_seq_len": 1024,
+    "text_dim": 4096
+}

model_cache_code_step8000/logs/tracker/wandb/debug-internal.log

@@ -0,0 +1,11 @@
+{"time":"2026-05-19T21:56:09.813911346-07:00","level":"INFO","msg":"wandb-core"}
+{"time":"2026-05-19T21:56:09.813920152-07:00","level":"INFO","msg":"stream: starting","core version":"0.26.1"}
+{"time":"2026-05-19T21:56:10.036673086-07:00","level":"WARN","msg":"featurechecker: GraphQL client is nil, skipping feature loading"}
+{"time":"2026-05-19T21:56:10.036683051-07:00","level":"WARN","msg":"featurechecker: GraphQL client is nil, skipping feature loading"}
+{"time":"2026-05-19T21:56:10.036698092-07:00","level":"INFO","msg":"stream: created new stream","id":"2dcsowl9"}
+{"time":"2026-05-19T21:56:10.036728928-07:00","level":"INFO","msg":"handler: started"}
+{"time":"2026-05-19T21:56:10.038848018-07:00","level":"INFO","msg":"stream: started"}
+{"time":"2026-05-19T21:56:10.03886515-07:00","level":"INFO","msg":"writer: started","stream_id":"2dcsowl9"}
+{"time":"2026-05-19T21:56:10.038881658-07:00","level":"INFO","msg":"sender: started"}
+{"time":"2026-05-19T21:56:10.048249399-07:00","level":"WARN","msg":"featurechecker: GraphQL client is nil, skipping feature loading"}
+{"time":"2026-05-19T21:56:10.04826791-07:00","level":"WARN","msg":"runupserter: server does not expand metric globs but the x_server_side_expand_glob_metrics setting is set; ignoring"}

model_cache_code_step8000/logs/tracker/wandb/debug.log

@@ -0,0 +1,19 @@
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_setup.py:_flush():81] Current SDK version is 0.26.1
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_setup.py:_flush():81] Configure stats pid to 107930
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:setup_run_log_directory():723] Logging user logs to /scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug.log
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:setup_run_log_directory():724] Logging internal logs to /scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug-internal.log
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:init():850] calling init triggers
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:init():855] wandb.init called with sweep_config: {}
+config: {'model_path': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged', 'mode': <ExecutionMode.INFERENCE: 'inference'>, 'workload_type': <WorkloadType.T2V: 't2v'>, 'distributed_executor_backend': 'mp', 'ray_placement_group': None, 'ray_runtime_env': None, 'inference_mode': False, 'trust_remote_code': False, 'revision': None, 'num_gpus': 8, 'tp_size': 1, 'sp_size': 1, 'hsdp_replicate_dim': 8, 'hsdp_shard_dim': 1, 'dist_timeout': None, 'pipeline_config': {'model_path': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged', 'pipeline_config_path': None, 'embedded_cfg_scale': 6.0, 'flow_shift': 3.0, 'flow_shift_sr': None, 'disable_autocast': False, 'is_causal': False, 'dit_config': {'arch_config': {'stacked_params_mapping': [], '_fsdp_shard_conditions': ['is_blocks'], '_compile_conditions': ['is_blocks'], 'param_names_mapping': {'^patch_embedding\\.(.*)$': 'patch_embedding.proj.\\1', '^condition_embedder\\.text_embedder\\.linear_1\\.(.*)$': 'condition_embedder.text_embedder.fc_in.\\1', '^condition_embedder\\.text_embedder\\.linear_2\\.(.*)$': 'condition_embedder.text_embedder.fc_out.\\1', '^condition_embedder\\.time_embedder\\.linear_1\\.(.*)$': 'condition_embedder.time_embedder.mlp.fc_in.\\1', '^condition_embedder\\.time_embedder\\.linear_2\\.(.*)$': 'condition_embedder.time_embedder.mlp.fc_out.\\1', '^condition_embedder\\.time_proj\\.(.*)$': 'condition_embedder.time_modulation.linear.\\1', '^condition_embedder\\.image_embedder\\.ff\\.net\\.0\\.proj\\.(.*)$': 'condition_embedder.image_embedder.ff.fc_in.\\1', '^condition_embedder\\.image_embedder\\.ff\\.net\\.2\\.(.*)$': 'condition_embedder.image_embedder.ff.fc_out.\\1', '^blocks\\.(\\d+)\\.attn1\\.to_q\\.(.*)$': 'blocks.\\1.to_q.\\2', '^blocks\\.(\\d+)\\.attn1\\.to_k\\.(.*)$': 'blocks.\\1.to_k.\\2', '^blocks\\.(\\d+)\\.attn1\\.to_v\\.(.*)$': 'blocks.\\1.to_v.\\2', '^blocks\\.(\\d+)\\.attn1\\.to_out\\.0\\.(.*)$': 'blocks.\\1.to_out.\\2', '^blocks\\.(\\d+)\\.attn1\\.norm_q\\.(.*)$': 'blocks.\\1.norm_q.\\2', '^blocks\\.(\\d+)\\.attn1\\.norm_k\\.(.*)$': 'blocks.\\1.norm_k.\\2', '^blocks\\.(\\d+)\\.attn2\\.to_out\\.0\\.(.*)$': 'blocks.\\1.attn2.to_out.\\2', '^blocks\\.(\\d+)\\.ffn\\.net\\.0\\.proj\\.(.*)$': 'blocks.\\1.ffn.fc_in.\\2', '^blocks\\.(\\d+)\\.ffn\\.net\\.2\\.(.*)$': 'blocks.\\1.ffn.fc_out.\\2', '^blocks\\.(\\d+)\\.norm2\\.(.*)$': 'blocks.\\1.self_attn_residual_norm.norm.\\2'}, 'reverse_param_names_mapping': {}, 'lora_param_names_mapping': {'^blocks\\.(\\d+)\\.self_attn\\.q\\.(.*)$': 'blocks.\\1.attn1.to_q.\\2', '^blocks\\.(\\d+)\\.self_attn\\.k\\.(.*)$': 'blocks.\\1.attn1.to_k.\\2', '^blocks\\.(\\d+)\\.self_attn\\.v\\.(.*)$': 'blocks.\\1.attn1.to_v.\\2', '^blocks\\.(\\d+)\\.self_attn\\.o\\.(.*)$': 'blocks.\\1.attn1.to_out.0.\\2', '^blocks\\.(\\d+)\\.cross_attn\\.q\\.(.*)$': 'blocks.\\1.attn2.to_q.\\2', '^blocks\\.(\\d+)\\.cross_attn\\.k\\.(.*)$': 'blocks.\\1.attn2.to_k.\\2', '^blocks\\.(\\d+)\\.cross_attn\\.v\\.(.*)$': 'blocks.\\1.attn2.to_v.\\2', '^blocks\\.(\\d+)\\.cross_attn\\.o\\.(.*)$': 'blocks.\\1.attn2.to_out.0.\\2', '^blocks\\.(\\d+)\\.ffn\\.0\\.(.*)$': 'blocks.\\1.ffn.fc_in.\\2', '^blocks\\.(\\d+)\\.ffn\\.2\\.(.*)$': 'blocks.\\1.ffn.fc_out.\\2'}, '_supported_attention_backends': [3, 1, 2, 5, 7, 4, 8, 9], 'hidden_size': 5120, 'num_attention_heads': 40, 'num_channels_latents': 16, 'in_channels': 16, 'out_channels': 16, 'exclude_lora_layers': ['embedder'], 'boundary_ratio': None, 'patch_size': [1, 2, 2], 'attention_head_dim': 128, 'text_dim': 4096, 'freq_dim': 256, 'ffn_dim': 13824, 'num_layers': 40, 'cross_attn_norm': True, 'qk_norm': 'rms_norm_across_heads', 'eps': 1e-06, 'image_dim': None, 'added_kv_proj_dim': None, 'rope_max_seq_len': 1024, 'pos_embed_seq_len': None, 'local_attn_size': -1, 'sink_size': 0, 'num_frames_per_block': 3, 'sliding_window_num_frames': 21}, 'prefix': 'Wan', 'quant_config': None}, 'dit_precision': 'fp32', 'upsampler_config': {'arch_config': {'stacked_params_mapping': []}}, 'upsampler_precision': 'fp32', 'vae_config': {'arch_config': {'stacked_params_mapping': [], 'scaling_factor': [[[[[2.0986359119415283]]], [[[0.9648784399032593]]], [[[2.215330123901367]]], [[[0.85638427734375]]], [[[1.8821758031845093]]], [[[2.0040080547332764]]], [[[2.075550079345703]]], [[[1.9948135614395142]]], [[[1.2257906198501587]]], [[[0.9667440056800842]]], [[[1.6966407299041748]]], [[[0.9173470139503479]]], [[[1.4524328708648682]]], [[[1.622059941291809]]], [[[1.1828720569610596]]], [[[2.0088388919830322]]], [[[1.736412525177002]]], [[[2.8384900093078613]]], [[[1.4015417098999023]]], [[[1.4697237014770508]]], [[[1.7143837213516235]]], [[[0.7069135904312134]]], [[[1.1128422021865845]]], [[[1.7670965194702148]]], [[[1.414627194404602]]], [[[1.8733607530593872]]], [[[2.045408010482788]]], [[[2.0337605476379395]]], [[[2.457606315612793]]], [[[2.0004000663757324]]], [[[1.4564520120620728]]], [[[2.4431958198547363]]], [[[1.7516201734542847]]], [[[1.6488045454025269]]], [[[1.5588464736938477]]], [[[2.022653818130493]]], [[[1.7464197874069214]]], [[[0.830426812171936]]], [[[1.8321731090545654]]], [[[0.5921714901924133]]], [[[2.5182573795318604]]], [[[0.943396270275116]]], [[[2.536139965057373]]], [[[1.8060322999954224]]], [[[1.8368847370147705]]], [[[2.4455857276916504]]], [[[1.339046597480774]]], [[[1.2913223505020142]]]]], 'temporal_compression_ratio': 4, 'spatial_compression_ratio': 16, 'base_dim': 160, 'decoder_base_dim': 256, 'z_dim': 48, 'dim_mult': [1, 2, 4, 4], 'num_res_blocks': 2, 'attn_scales': [], 'temperal_downsample': [False, True, True], 'dropout': 0.0, 'latents_mean': [-0.2289, -0.0052, -0.1323, -0.2339, -0.2799, 0.0174, 0.1838, 0.1557, -0.1382, 0.0542, 0.2813, 0.0891, 0.157, -0.0098, 0.0375, -0.1825, -0.2246, -0.1207, -0.0698, 0.5109, 0.2665, -0.2108, -0.2158, 0.2502, -0.2055, -0.0322, 0.1109, 0.1567, -0.0729, 0.0899, -0.2799, -0.123, -0.0313, -0.1649, 0.0117, 0.0723, -0.2839, -0.2083, -0.052, 0.3748, 0.0152, 0.1957, 0.1433, -0.2944, 0.3573, -0.0548, -0.1681, -0.0667], 'latents_std': [0.4765, 1.0364, 0.4514, 1.1677, 0.5313, 0.499, 0.4818, 0.5013, 0.8158, 1.0344, 0.5894, 1.0901, 0.6885, 0.6165, 0.8454, 0.4978, 0.5759, 0.3523, 0.7135, 0.6804, 0.5833, 1.4146, 0.8986, 0.5659, 0.7069, 0.5338, 0.4889, 0.4917, 0.4069, 0.4999, 0.6866, 0.4093, 0.5709, 0.6065, 0.6415, 0.4944, 0.5726, 1.2042, 0.5458, 1.6887, 0.3971, 1.06, 0.3943, 0.5537, 0.5444, 0.4089, 0.7468, 0.7744], 'is_residual': True, 'in_channels': 12, 'out_channels': 12, 'patch_size': 2, 'scale_factor_temporal': 4, 'scale_factor_spatial': 16, 'clip_output': False}, 'load_encoder': False, 'load_decoder': True, 'tile_sample_min_height': 256, 'tile_sample_min_width': 256, 'tile_sample_min_num_frames': 16, 'tile_sample_stride_height': 192, 'tile_sample_stride_width': 192, 'tile_sample_stride_num_frames': 12, 'blend_num_frames': 8, 'use_tiling': False, 'use_temporal_tiling': False, 'use_parallel_tiling': False, 'use_temporal_scaling_frames': True, 'use_feature_cache': True}, 'vae_precision': 'fp32', 'vae_tiling': False, 'vae_sp': False, 'image_encoder_config': {'arch_config': {'stacked_params_mapping': [], 'architectures': [], '_supported_attention_backends': [1, 2], 'output_hidden_states': False, 'use_return_dict': True}, 'prefix': '', 'quant_config': None, 'lora_config': None}, 'image_encoder_precision': 'fp32', 'text_encoder_configs': [{'arch_config': {'stacked_params_mapping': [['.qkv_proj', '.q', 'q'], ['.qkv_proj', '.k', 'k'], ['.qkv_proj', '.v', 'v']], 'architectures': [], '_supported_attention_backends': [1, 2], 'output_hidden_states': False, 'use_return_dict': True, 'vocab_size': 32128, 'hidden_size': 512, 'num_hidden_layers': 0, 'num_attention_heads': 0, 'pad_token_id': 0, 'eos_token_id': 1, 'text_len': 512, 'hidden_state_skip_layer': 0, 'decoder_start_token_id': 0, 'output_past': True, 'scalable_attention': True, 'tie_word_embeddings': False, 'tokenizer_kwargs': {'truncation': True, 'max_length': 512, 'add_special_tokens': True, 'return_attention_mask': True, 'return_tensors': 'pt'}, '_fsdp_shard_conditions': ['_is_transformer_layer', '_is_embeddings', '_is_final_layernorm'], 'd_model': 512, 'd_kv': 64, 'd_ff': 2048, 'num_layers': 6, 'num_decoder_layers': None, 'num_heads': 8, 'relative_attention_num_buckets': 32, 'relative_attention_max_distance': 128, 'dropout_rate': 0.1, 'layer_norm_epsilon': 1e-06, 'initializer_factor': 1.0, 'feed_forward_proj': 'relu', 'dense_act_fn': 'relu', 'is_gated_act': False, 'is_encoder_decoder': True, 'use_cache': True, 'classifier_dropout': 0.0, 'dtype': None, 'gradient_checkpointing': False, 'n_positions': 512, 'task_specific_params': None}, 'prefix': 't5', 'quant_config': None, 'lora_config': None, 'is_chat_model': False, 'treat_empty_as_dot': False}], 'text_encoder_precisions': ['fp32'], 'preprocess_text_funcs': ['preprocess_text'], 'postprocess_text_funcs': ['t5_postprocess_text'], 'dmd_denoising_steps': None, 'ti2v_task': False, 'boundary_ratio': None, 'precision': 'bf16', 'warp_denoising_step': True}, 'preprocess_config': None, 'lora_path': None, 'lora_nickname': 'default', 'lora_target_modules': None, 'output_type': 'pil', 'dit_cpu_offload': False, 'use_fsdp_inference': False, 'dit_layerwise_offload': False, 'text_encoder_cpu_offload': False, 'image_encoder_cpu_offload': False, 'vae_cpu_offload': False, 'pin_cpu_memory': False, 'enable_torch_compile': False, 'enable_torch_compile_text_encoder': False, 'enable_torch_compile_vae': False, 'enable_torch_compile_audio_vae': False, 'torch_compile_kwargs': None, 'torch_compile_kwargs_dit': {}, 'torch_compile_kwargs_text_encoder': {}, 'torch_compile_kwargs_vae': {}, 'torch_compile_kwargs_audio_vae': {}, 'disable_autocast': False, 'VSA_sparsity': 0.0, 'moba_config_path': None, 'moba_config': {}, 'master_port': None, 'enable_stage_verification': True, 'prompt_txt': None, 'ltx2_vae_tiling': None, 'ltx2_vae_spatial_tile_size_in_pixels': None, 'ltx2_vae_spatial_tile_overlap_in_pixels': None, 'ltx2_vae_temporal_tile_size_in_frames': None, 'ltx2_vae_temporal_tile_overlap_in_frames': None, 'ltx2_initial_latent_path': None, 'ltx2_audio_latent_path': None, 'refine_enabled': None, 'refine_upsampler_path': None, 'refine_transformer_path': None, 'refine_lora_path': None, 'refine_num_inference_steps': None, 'refine_guidance_scale': None, 'refine_add_noise': None, 'refine_noise_path': None, 'refine_audio_noise_path': None, 'ltx2_refine_enabled': False, 'ltx2_refine_upsampler_path': None, 'ltx2_refine_transformer_path': None, 'ltx2_refine_lora_path': None, 'ltx2_refine_num_inference_steps': 3, 'ltx2_refine_guidance_scale': 1.0, 'ltx2_refine_add_noise': True, 'ltx2_refine_noise_path': None, 'ltx2_refine_audio_noise_path': None, 'ltx2_legacy_native_noise_order': False, 'ltx2_use_distilled_sigmas': True, 'model_paths': {'transformer': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/transformer', 'vae': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/vae'}, 'model_loaded': {'transformer': True, 'vae': True, 'upsampler': True}, 'override_text_encoder_safetensors': None, 'override_text_encoder_quant': None, 'transformer_quant': None, 'override_transformer_cls_name': None, 'init_weights_from_safetensors': None, 'init_weights_from_safetensors_2': None, 'override_pipeline_cls_name': None, 'boundary_ratio': 0.875, 'data_path': '/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin', 'dataloader_num_workers': 2, 'num_height': 320, 'num_width': 288, 'num_frames': 153, 'train_batch_size': 16, 'num_latent_t': 39, 'group_frame': False, 'group_resolution': False, 'pretrained_model_name_or_path': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged', 'real_score_model_path': None, 'fake_score_model_path': None, 'ema_decay': 0.999, 'ema_start_step': 1, 'training_cfg_rate': 0.05, 'precondition_outputs': False, 'validation_dataset_file': None, 'validation_preprocessed_path': None, 'validation_sampling_steps': None, 'validation_guidance_scale': None, 'validation_steps': None, 'log_validation': False, 'trackers': [], 'tracker_project_name': 'pants_wan22_fullrep', 'wandb_run_name': 'pants_b16_9k_20260519_215532', 'seed': 42, 'output_dir': '/scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532', 'checkpoints_total_limit': 2, 'resume_from_checkpoint': None, 'num_train_epochs': None, 'max_train_steps': 9000, 'gradient_accumulation_steps': 1, 'learning_rate': 1e-06, 'scale_lr': False, 'lr_scheduler': 'constant', 'lr_warmup_steps': 0, 'max_grad_norm': 1.0, 'enable_gradient_checkpointing_type': 'full', 'selective_checkpointing': None, 'mixed_precision': 'bf16', 'train_sp_batch_size': 1, 'fsdp_sharding_startegy': '', 'weighting_scheme': 'uniform', 'logit_mean': 0.0, 'logit_std': 1.0, 'mode_scale': 1.29, 'num_euler_timesteps': 50, 'lr_num_cycles': None, 'lr_power': None, 'min_lr_ratio': 0.5, 'not_apply_cfg_solver': False, 'distill_cfg': None, 'scheduler_type': None, 'linear_quadratic_threshold': None, 'linear_range': None, 'weight_decay': 0.01, 'betas': '0.9,0.999', 'use_ema': True, 'multi_phased_distill_schedule': None, 'pred_decay_weight': None, 'pred_decay_type': None, 'hunyuan_teacher_disable_cfg': False, 'master_weight_type': None, 'VSA_decay_rate': 0.01, 'VSA_decay_interval_steps': 1, 'lora_rank': None, 'lora_alpha': None, 'lora_training': False, 'ltx2_first_frame_conditioning_p': 0.1, 'generator_update_interval': 5, 'dfake_gen_update_ratio': 5, 'min_timestep_ratio': 0.2, 'max_timestep_ratio': 0.98, 'real_score_guidance_scale': 3.5, 'fake_score_learning_rate': 0.0, 'fake_score_lr_scheduler': 'constant', 'fake_score_betas': '0.9,0.999', 'training_state_checkpointing_steps': 4000, 'weight_only_checkpointing_steps': None, 'log_visualization': False, 'visualization_steps': None, 'simulate_generator_forward': False, 'warp_denoising_step': False, 'num_frame_per_block': 3, 'independent_first_frame': False, 'enable_gradient_masking': False, 'gradient_mask_last_n_frames': 21, 'same_step_across_blocks': False, 'last_step_only': False, 'context_noise': 0, '_wandb': {}}
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:init():898] starting backend
+2026-05-19 21:56:09,805 INFO    MainThread:107930 [wandb_init.py:init():913] sending inform_init request
+2026-05-19 21:56:10,039 INFO    MainThread:107930 [wandb_init.py:init():918] backend started and connected
+2026-05-19 21:56:10,041 INFO    MainThread:107930 [wandb_init.py:init():988] updated telemetry
+2026-05-19 21:56:10,044 INFO    MainThread:107930 [wandb_init.py:init():1011] communicating run to backend with 90.0 second timeout
+2026-05-19 21:56:10,051 INFO    MainThread:107930 [wandb_init.py:init():1056] starting run threads in backend
+2026-05-19 21:56:10,141 INFO    MainThread:107930 [wandb_run.py:_console_start():2554] atexit reg
+2026-05-19 21:56:10,141 INFO    MainThread:107930 [wandb_run.py:_redirect():2403] redirect: wrap_raw
+2026-05-19 21:56:10,141 INFO    MainThread:107930 [wandb_run.py:_redirect():2472] Wrapping output streams.
+2026-05-19 21:56:10,141 INFO    MainThread:107930 [wandb_run.py:_redirect():2495] Redirects installed.
+2026-05-19 21:56:10,144 INFO    MainThread:107930 [wandb_init.py:init():1094] run started, returning control to user process

model_cache_code_step8000/logs/tracker/wandb/offline-run-20260519_215609-2dcsowl9/files/requirements.txt

@@ -0,0 +1,116 @@
+accelerate==1.13.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.5
+aiosignal==1.4.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.13.0
+attrs==26.1.0
+certifi==2026.4.22
+charset-normalizer==3.4.7
+click==8.3.3
+clip==1.0
+cloudpickle==3.1.2
+cuda-bindings==12.9.4
+cuda-pathfinder==1.2.2
+cuda-toolkit==12.6.3
+datasets==4.8.5
+deepspeed==0.18.9
+diffusers==0.37.1
+dill==0.4.1
+einops==0.8.2
+filelock==3.25.2
+frozenlist==1.8.0
+fsspec==2026.2.0
+ftfy==6.3.1
+gitdb==4.0.12
+GitPython==3.1.49
+h11==0.16.0
+hf-xet==1.4.3
+hjson==3.1.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.12.2
+idna==3.13
+ImageIO==2.37.3
+importlib_metadata==9.0.0
+importlib_resources==7.1.0
+Jinja2==3.1.6
+lazy-loader==0.5
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+mpmath==1.3.0
+msgpack==1.1.2
+multidict==6.7.1
+multiprocess==0.70.19
+networkx==3.6.1
+nibabel==5.4.2
+ninja==1.13.0
+numpy==2.4.4
+nvidia-cublas-cu12==12.6.4.1
+nvidia-cuda-cupti-cu12==12.6.80
+nvidia-cuda-nvrtc-cu12==12.6.85
+nvidia-cuda-runtime-cu12==12.6.77
+nvidia-cudnn-cu12==9.10.2.21
+nvidia-cufft-cu12==11.3.0.4
+nvidia-cufile-cu12==1.11.1.6
+nvidia-curand-cu12==10.3.7.77
+nvidia-cusolver-cu12==11.7.1.2
+nvidia-cusparse-cu12==12.5.4.2
+nvidia-cusparselt-cu12==0.7.1
+nvidia-nccl-cu12==2.28.9
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nvshmem-cu12==3.4.5
+nvidia-nvtx-cu12==12.6.77
+packaging==26.2
+pandas==3.0.3
+peft==0.19.1
+pillow==12.2.0
+pip==26.1
+platformdirs==4.9.6
+prodigy-plus-schedule-free==2.0.1
+prodigyopt==1.1.2
+propcache==0.5.2
+protobuf==7.34.1
+psutil==7.2.2
+py-cpuinfo==9.0.0
+pyarrow==24.0.0
+pydantic==2.13.3
+pydantic_core==2.46.3
+Pygments==2.20.0
+python-dateutil==2.9.0.post0
+PyYAML==6.0.3
+regex==2026.4.4
+remote-pdb==2.1.0
+requests==2.33.1
+rich==15.0.0
+safetensors==0.7.0
+scikit-image==0.26.0
+scipy==1.17.1
+sentencepiece==0.2.1
+sentry-sdk==2.58.0
+setuptools==70.2.0
+shellingham==1.5.4
+six==1.17.0
+smmap==5.0.3
+sympy==1.14.0
+tifffile==2026.3.3
+tokenizers==0.22.2
+torch==2.11.0+cu126
+torchaudio==2.11.0+cu126
+torchdata==0.11.0
+torchvision==0.26.0+cu126
+tqdm==4.67.3
+transformers==5.7.0
+triton==3.6.0
+typer==0.25.0
+typing_extensions==4.15.0
+typing-inspection==0.4.2
+urllib3==2.6.3
+wandb==0.26.1
+wcwidth==0.7.0
+wheel==0.47.0
+xxhash==3.7.0
+yarl==1.24.2
+zipp==3.23.1

model_cache_code_step8000/logs/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug-core.log

@@ -0,0 +1,6 @@
+{"time":"2026-05-19T21:56:09.621954004-07:00","level":"INFO","msg":"main: starting server","port-filename":"/scratch/user/yuhwang/artifacts/twoframe/tmp/tmpcfxztyxi/port-107930.txt","pid":107930,"detached":false,"idle-timeout":600000000000,"log-level":0,"disable-analytics":false,"shutdown-on-parent-exit":false,"enable-dcgm-profiling":false}
+{"time":"2026-05-19T21:56:09.628989105-07:00","level":"INFO","msg":"server: will exit if parent process dies","ppid":107930}
+{"time":"2026-05-19T21:56:09.628971091-07:00","level":"INFO","msg":"server: accepting connections","addr":{"Name":"/scratch/user/yuhwang/artifacts/twoframe/tmp/wandb-107930-108495-2861732827/socket","Net":"unix"}}
+{"time":"2026-05-19T21:56:09.804909188-07:00","level":"INFO","msg":"connection: ManageConnectionData: new connection created","id":"1(@)"}
+{"time":"2026-05-19T21:56:09.812088416-07:00","level":"INFO","msg":"handleInformInit: received","streamId":"2dcsowl9","id":"1(@)"}
+{"time":"2026-05-19T21:56:10.038853675-07:00","level":"INFO","msg":"handleInformInit: stream started","streamId":"2dcsowl9","id":"1(@)"}

model_cache_code_step8000/logs/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug-internal.log

@@ -0,0 +1,11 @@
+{"time":"2026-05-19T21:56:09.813911346-07:00","level":"INFO","msg":"wandb-core"}
+{"time":"2026-05-19T21:56:09.813920152-07:00","level":"INFO","msg":"stream: starting","core version":"0.26.1"}
+{"time":"2026-05-19T21:56:10.036673086-07:00","level":"WARN","msg":"featurechecker: GraphQL client is nil, skipping feature loading"}
+{"time":"2026-05-19T21:56:10.036683051-07:00","level":"WARN","msg":"featurechecker: GraphQL client is nil, skipping feature loading"}
+{"time":"2026-05-19T21:56:10.036698092-07:00","level":"INFO","msg":"stream: created new stream","id":"2dcsowl9"}
+{"time":"2026-05-19T21:56:10.036728928-07:00","level":"INFO","msg":"handler: started"}
+{"time":"2026-05-19T21:56:10.038848018-07:00","level":"INFO","msg":"stream: started"}
+{"time":"2026-05-19T21:56:10.03886515-07:00","level":"INFO","msg":"writer: started","stream_id":"2dcsowl9"}
+{"time":"2026-05-19T21:56:10.038881658-07:00","level":"INFO","msg":"sender: started"}
+{"time":"2026-05-19T21:56:10.048249399-07:00","level":"WARN","msg":"featurechecker: GraphQL client is nil, skipping feature loading"}
+{"time":"2026-05-19T21:56:10.04826791-07:00","level":"WARN","msg":"runupserter: server does not expand metric globs but the x_server_side_expand_glob_metrics setting is set; ignoring"}

model_cache_code_step8000/logs/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug.log

@@ -0,0 +1,19 @@
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_setup.py:_flush():81] Current SDK version is 0.26.1
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_setup.py:_flush():81] Configure stats pid to 107930
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:setup_run_log_directory():723] Logging user logs to /scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug.log
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:setup_run_log_directory():724] Logging internal logs to /scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug-internal.log
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:init():850] calling init triggers
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:init():855] wandb.init called with sweep_config: {}
+config: {'model_path': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged', 'mode': <ExecutionMode.INFERENCE: 'inference'>, 'workload_type': <WorkloadType.T2V: 't2v'>, 'distributed_executor_backend': 'mp', 'ray_placement_group': None, 'ray_runtime_env': None, 'inference_mode': False, 'trust_remote_code': False, 'revision': None, 'num_gpus': 8, 'tp_size': 1, 'sp_size': 1, 'hsdp_replicate_dim': 8, 'hsdp_shard_dim': 1, 'dist_timeout': None, 'pipeline_config': {'model_path': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged', 'pipeline_config_path': None, 'embedded_cfg_scale': 6.0, 'flow_shift': 3.0, 'flow_shift_sr': None, 'disable_autocast': False, 'is_causal': False, 'dit_config': {'arch_config': {'stacked_params_mapping': [], '_fsdp_shard_conditions': ['is_blocks'], '_compile_conditions': ['is_blocks'], 'param_names_mapping': {'^patch_embedding\\.(.*)$': 'patch_embedding.proj.\\1', '^condition_embedder\\.text_embedder\\.linear_1\\.(.*)$': 'condition_embedder.text_embedder.fc_in.\\1', '^condition_embedder\\.text_embedder\\.linear_2\\.(.*)$': 'condition_embedder.text_embedder.fc_out.\\1', '^condition_embedder\\.time_embedder\\.linear_1\\.(.*)$': 'condition_embedder.time_embedder.mlp.fc_in.\\1', '^condition_embedder\\.time_embedder\\.linear_2\\.(.*)$': 'condition_embedder.time_embedder.mlp.fc_out.\\1', '^condition_embedder\\.time_proj\\.(.*)$': 'condition_embedder.time_modulation.linear.\\1', '^condition_embedder\\.image_embedder\\.ff\\.net\\.0\\.proj\\.(.*)$': 'condition_embedder.image_embedder.ff.fc_in.\\1', '^condition_embedder\\.image_embedder\\.ff\\.net\\.2\\.(.*)$': 'condition_embedder.image_embedder.ff.fc_out.\\1', '^blocks\\.(\\d+)\\.attn1\\.to_q\\.(.*)$': 'blocks.\\1.to_q.\\2', '^blocks\\.(\\d+)\\.attn1\\.to_k\\.(.*)$': 'blocks.\\1.to_k.\\2', '^blocks\\.(\\d+)\\.attn1\\.to_v\\.(.*)$': 'blocks.\\1.to_v.\\2', '^blocks\\.(\\d+)\\.attn1\\.to_out\\.0\\.(.*)$': 'blocks.\\1.to_out.\\2', '^blocks\\.(\\d+)\\.attn1\\.norm_q\\.(.*)$': 'blocks.\\1.norm_q.\\2', '^blocks\\.(\\d+)\\.attn1\\.norm_k\\.(.*)$': 'blocks.\\1.norm_k.\\2', '^blocks\\.(\\d+)\\.attn2\\.to_out\\.0\\.(.*)$': 'blocks.\\1.attn2.to_out.\\2', '^blocks\\.(\\d+)\\.ffn\\.net\\.0\\.proj\\.(.*)$': 'blocks.\\1.ffn.fc_in.\\2', '^blocks\\.(\\d+)\\.ffn\\.net\\.2\\.(.*)$': 'blocks.\\1.ffn.fc_out.\\2', '^blocks\\.(\\d+)\\.norm2\\.(.*)$': 'blocks.\\1.self_attn_residual_norm.norm.\\2'}, 'reverse_param_names_mapping': {}, 'lora_param_names_mapping': {'^blocks\\.(\\d+)\\.self_attn\\.q\\.(.*)$': 'blocks.\\1.attn1.to_q.\\2', '^blocks\\.(\\d+)\\.self_attn\\.k\\.(.*)$': 'blocks.\\1.attn1.to_k.\\2', '^blocks\\.(\\d+)\\.self_attn\\.v\\.(.*)$': 'blocks.\\1.attn1.to_v.\\2', '^blocks\\.(\\d+)\\.self_attn\\.o\\.(.*)$': 'blocks.\\1.attn1.to_out.0.\\2', '^blocks\\.(\\d+)\\.cross_attn\\.q\\.(.*)$': 'blocks.\\1.attn2.to_q.\\2', '^blocks\\.(\\d+)\\.cross_attn\\.k\\.(.*)$': 'blocks.\\1.attn2.to_k.\\2', '^blocks\\.(\\d+)\\.cross_attn\\.v\\.(.*)$': 'blocks.\\1.attn2.to_v.\\2', '^blocks\\.(\\d+)\\.cross_attn\\.o\\.(.*)$': 'blocks.\\1.attn2.to_out.0.\\2', '^blocks\\.(\\d+)\\.ffn\\.0\\.(.*)$': 'blocks.\\1.ffn.fc_in.\\2', '^blocks\\.(\\d+)\\.ffn\\.2\\.(.*)$': 'blocks.\\1.ffn.fc_out.\\2'}, '_supported_attention_backends': [3, 1, 2, 5, 7, 4, 8, 9], 'hidden_size': 5120, 'num_attention_heads': 40, 'num_channels_latents': 16, 'in_channels': 16, 'out_channels': 16, 'exclude_lora_layers': ['embedder'], 'boundary_ratio': None, 'patch_size': [1, 2, 2], 'attention_head_dim': 128, 'text_dim': 4096, 'freq_dim': 256, 'ffn_dim': 13824, 'num_layers': 40, 'cross_attn_norm': True, 'qk_norm': 'rms_norm_across_heads', 'eps': 1e-06, 'image_dim': None, 'added_kv_proj_dim': None, 'rope_max_seq_len': 1024, 'pos_embed_seq_len': None, 'local_attn_size': -1, 'sink_size': 0, 'num_frames_per_block': 3, 'sliding_window_num_frames': 21}, 'prefix': 'Wan', 'quant_config': None}, 'dit_precision': 'fp32', 'upsampler_config': {'arch_config': {'stacked_params_mapping': []}}, 'upsampler_precision': 'fp32', 'vae_config': {'arch_config': {'stacked_params_mapping': [], 'scaling_factor': [[[[[2.0986359119415283]]], [[[0.9648784399032593]]], [[[2.215330123901367]]], [[[0.85638427734375]]], [[[1.8821758031845093]]], [[[2.0040080547332764]]], [[[2.075550079345703]]], [[[1.9948135614395142]]], [[[1.2257906198501587]]], [[[0.9667440056800842]]], [[[1.6966407299041748]]], [[[0.9173470139503479]]], [[[1.4524328708648682]]], [[[1.622059941291809]]], [[[1.1828720569610596]]], [[[2.0088388919830322]]], [[[1.736412525177002]]], [[[2.8384900093078613]]], [[[1.4015417098999023]]], [[[1.4697237014770508]]], [[[1.7143837213516235]]], [[[0.7069135904312134]]], [[[1.1128422021865845]]], [[[1.7670965194702148]]], [[[1.414627194404602]]], [[[1.8733607530593872]]], [[[2.045408010482788]]], [[[2.0337605476379395]]], [[[2.457606315612793]]], [[[2.0004000663757324]]], [[[1.4564520120620728]]], [[[2.4431958198547363]]], [[[1.7516201734542847]]], [[[1.6488045454025269]]], [[[1.5588464736938477]]], [[[2.022653818130493]]], [[[1.7464197874069214]]], [[[0.830426812171936]]], [[[1.8321731090545654]]], [[[0.5921714901924133]]], [[[2.5182573795318604]]], [[[0.943396270275116]]], [[[2.536139965057373]]], [[[1.8060322999954224]]], [[[1.8368847370147705]]], [[[2.4455857276916504]]], [[[1.339046597480774]]], [[[1.2913223505020142]]]]], 'temporal_compression_ratio': 4, 'spatial_compression_ratio': 16, 'base_dim': 160, 'decoder_base_dim': 256, 'z_dim': 48, 'dim_mult': [1, 2, 4, 4], 'num_res_blocks': 2, 'attn_scales': [], 'temperal_downsample': [False, True, True], 'dropout': 0.0, 'latents_mean': [-0.2289, -0.0052, -0.1323, -0.2339, -0.2799, 0.0174, 0.1838, 0.1557, -0.1382, 0.0542, 0.2813, 0.0891, 0.157, -0.0098, 0.0375, -0.1825, -0.2246, -0.1207, -0.0698, 0.5109, 0.2665, -0.2108, -0.2158, 0.2502, -0.2055, -0.0322, 0.1109, 0.1567, -0.0729, 0.0899, -0.2799, -0.123, -0.0313, -0.1649, 0.0117, 0.0723, -0.2839, -0.2083, -0.052, 0.3748, 0.0152, 0.1957, 0.1433, -0.2944, 0.3573, -0.0548, -0.1681, -0.0667], 'latents_std': [0.4765, 1.0364, 0.4514, 1.1677, 0.5313, 0.499, 0.4818, 0.5013, 0.8158, 1.0344, 0.5894, 1.0901, 0.6885, 0.6165, 0.8454, 0.4978, 0.5759, 0.3523, 0.7135, 0.6804, 0.5833, 1.4146, 0.8986, 0.5659, 0.7069, 0.5338, 0.4889, 0.4917, 0.4069, 0.4999, 0.6866, 0.4093, 0.5709, 0.6065, 0.6415, 0.4944, 0.5726, 1.2042, 0.5458, 1.6887, 0.3971, 1.06, 0.3943, 0.5537, 0.5444, 0.4089, 0.7468, 0.7744], 'is_residual': True, 'in_channels': 12, 'out_channels': 12, 'patch_size': 2, 'scale_factor_temporal': 4, 'scale_factor_spatial': 16, 'clip_output': False}, 'load_encoder': False, 'load_decoder': True, 'tile_sample_min_height': 256, 'tile_sample_min_width': 256, 'tile_sample_min_num_frames': 16, 'tile_sample_stride_height': 192, 'tile_sample_stride_width': 192, 'tile_sample_stride_num_frames': 12, 'blend_num_frames': 8, 'use_tiling': False, 'use_temporal_tiling': False, 'use_parallel_tiling': False, 'use_temporal_scaling_frames': True, 'use_feature_cache': True}, 'vae_precision': 'fp32', 'vae_tiling': False, 'vae_sp': False, 'image_encoder_config': {'arch_config': {'stacked_params_mapping': [], 'architectures': [], '_supported_attention_backends': [1, 2], 'output_hidden_states': False, 'use_return_dict': True}, 'prefix': '', 'quant_config': None, 'lora_config': None}, 'image_encoder_precision': 'fp32', 'text_encoder_configs': [{'arch_config': {'stacked_params_mapping': [['.qkv_proj', '.q', 'q'], ['.qkv_proj', '.k', 'k'], ['.qkv_proj', '.v', 'v']], 'architectures': [], '_supported_attention_backends': [1, 2], 'output_hidden_states': False, 'use_return_dict': True, 'vocab_size': 32128, 'hidden_size': 512, 'num_hidden_layers': 0, 'num_attention_heads': 0, 'pad_token_id': 0, 'eos_token_id': 1, 'text_len': 512, 'hidden_state_skip_layer': 0, 'decoder_start_token_id': 0, 'output_past': True, 'scalable_attention': True, 'tie_word_embeddings': False, 'tokenizer_kwargs': {'truncation': True, 'max_length': 512, 'add_special_tokens': True, 'return_attention_mask': True, 'return_tensors': 'pt'}, '_fsdp_shard_conditions': ['_is_transformer_layer', '_is_embeddings', '_is_final_layernorm'], 'd_model': 512, 'd_kv': 64, 'd_ff': 2048, 'num_layers': 6, 'num_decoder_layers': None, 'num_heads': 8, 'relative_attention_num_buckets': 32, 'relative_attention_max_distance': 128, 'dropout_rate': 0.1, 'layer_norm_epsilon': 1e-06, 'initializer_factor': 1.0, 'feed_forward_proj': 'relu', 'dense_act_fn': 'relu', 'is_gated_act': False, 'is_encoder_decoder': True, 'use_cache': True, 'classifier_dropout': 0.0, 'dtype': None, 'gradient_checkpointing': False, 'n_positions': 512, 'task_specific_params': None}, 'prefix': 't5', 'quant_config': None, 'lora_config': None, 'is_chat_model': False, 'treat_empty_as_dot': False}], 'text_encoder_precisions': ['fp32'], 'preprocess_text_funcs': ['preprocess_text'], 'postprocess_text_funcs': ['t5_postprocess_text'], 'dmd_denoising_steps': None, 'ti2v_task': False, 'boundary_ratio': None, 'precision': 'bf16', 'warp_denoising_step': True}, 'preprocess_config': None, 'lora_path': None, 'lora_nickname': 'default', 'lora_target_modules': None, 'output_type': 'pil', 'dit_cpu_offload': False, 'use_fsdp_inference': False, 'dit_layerwise_offload': False, 'text_encoder_cpu_offload': False, 'image_encoder_cpu_offload': False, 'vae_cpu_offload': False, 'pin_cpu_memory': False, 'enable_torch_compile': False, 'enable_torch_compile_text_encoder': False, 'enable_torch_compile_vae': False, 'enable_torch_compile_audio_vae': False, 'torch_compile_kwargs': None, 'torch_compile_kwargs_dit': {}, 'torch_compile_kwargs_text_encoder': {}, 'torch_compile_kwargs_vae': {}, 'torch_compile_kwargs_audio_vae': {}, 'disable_autocast': False, 'VSA_sparsity': 0.0, 'moba_config_path': None, 'moba_config': {}, 'master_port': None, 'enable_stage_verification': True, 'prompt_txt': None, 'ltx2_vae_tiling': None, 'ltx2_vae_spatial_tile_size_in_pixels': None, 'ltx2_vae_spatial_tile_overlap_in_pixels': None, 'ltx2_vae_temporal_tile_size_in_frames': None, 'ltx2_vae_temporal_tile_overlap_in_frames': None, 'ltx2_initial_latent_path': None, 'ltx2_audio_latent_path': None, 'refine_enabled': None, 'refine_upsampler_path': None, 'refine_transformer_path': None, 'refine_lora_path': None, 'refine_num_inference_steps': None, 'refine_guidance_scale': None, 'refine_add_noise': None, 'refine_noise_path': None, 'refine_audio_noise_path': None, 'ltx2_refine_enabled': False, 'ltx2_refine_upsampler_path': None, 'ltx2_refine_transformer_path': None, 'ltx2_refine_lora_path': None, 'ltx2_refine_num_inference_steps': 3, 'ltx2_refine_guidance_scale': 1.0, 'ltx2_refine_add_noise': True, 'ltx2_refine_noise_path': None, 'ltx2_refine_audio_noise_path': None, 'ltx2_legacy_native_noise_order': False, 'ltx2_use_distilled_sigmas': True, 'model_paths': {'transformer': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/transformer', 'vae': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/vae'}, 'model_loaded': {'transformer': True, 'vae': True, 'upsampler': True}, 'override_text_encoder_safetensors': None, 'override_text_encoder_quant': None, 'transformer_quant': None, 'override_transformer_cls_name': None, 'init_weights_from_safetensors': None, 'init_weights_from_safetensors_2': None, 'override_pipeline_cls_name': None, 'boundary_ratio': 0.875, 'data_path': '/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin', 'dataloader_num_workers': 2, 'num_height': 320, 'num_width': 288, 'num_frames': 153, 'train_batch_size': 16, 'num_latent_t': 39, 'group_frame': False, 'group_resolution': False, 'pretrained_model_name_or_path': '/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged', 'real_score_model_path': None, 'fake_score_model_path': None, 'ema_decay': 0.999, 'ema_start_step': 1, 'training_cfg_rate': 0.05, 'precondition_outputs': False, 'validation_dataset_file': None, 'validation_preprocessed_path': None, 'validation_sampling_steps': None, 'validation_guidance_scale': None, 'validation_steps': None, 'log_validation': False, 'trackers': [], 'tracker_project_name': 'pants_wan22_fullrep', 'wandb_run_name': 'pants_b16_9k_20260519_215532', 'seed': 42, 'output_dir': '/scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532', 'checkpoints_total_limit': 2, 'resume_from_checkpoint': None, 'num_train_epochs': None, 'max_train_steps': 9000, 'gradient_accumulation_steps': 1, 'learning_rate': 1e-06, 'scale_lr': False, 'lr_scheduler': 'constant', 'lr_warmup_steps': 0, 'max_grad_norm': 1.0, 'enable_gradient_checkpointing_type': 'full', 'selective_checkpointing': None, 'mixed_precision': 'bf16', 'train_sp_batch_size': 1, 'fsdp_sharding_startegy': '', 'weighting_scheme': 'uniform', 'logit_mean': 0.0, 'logit_std': 1.0, 'mode_scale': 1.29, 'num_euler_timesteps': 50, 'lr_num_cycles': None, 'lr_power': None, 'min_lr_ratio': 0.5, 'not_apply_cfg_solver': False, 'distill_cfg': None, 'scheduler_type': None, 'linear_quadratic_threshold': None, 'linear_range': None, 'weight_decay': 0.01, 'betas': '0.9,0.999', 'use_ema': True, 'multi_phased_distill_schedule': None, 'pred_decay_weight': None, 'pred_decay_type': None, 'hunyuan_teacher_disable_cfg': False, 'master_weight_type': None, 'VSA_decay_rate': 0.01, 'VSA_decay_interval_steps': 1, 'lora_rank': None, 'lora_alpha': None, 'lora_training': False, 'ltx2_first_frame_conditioning_p': 0.1, 'generator_update_interval': 5, 'dfake_gen_update_ratio': 5, 'min_timestep_ratio': 0.2, 'max_timestep_ratio': 0.98, 'real_score_guidance_scale': 3.5, 'fake_score_learning_rate': 0.0, 'fake_score_lr_scheduler': 'constant', 'fake_score_betas': '0.9,0.999', 'training_state_checkpointing_steps': 4000, 'weight_only_checkpointing_steps': None, 'log_visualization': False, 'visualization_steps': None, 'simulate_generator_forward': False, 'warp_denoising_step': False, 'num_frame_per_block': 3, 'independent_first_frame': False, 'enable_gradient_masking': False, 'gradient_mask_last_n_frames': 21, 'same_step_across_blocks': False, 'last_step_only': False, 'context_noise': 0, '_wandb': {}}
+2026-05-19 21:56:09,558 INFO    MainThread:107930 [wandb_init.py:init():898] starting backend
+2026-05-19 21:56:09,805 INFO    MainThread:107930 [wandb_init.py:init():913] sending inform_init request
+2026-05-19 21:56:10,039 INFO    MainThread:107930 [wandb_init.py:init():918] backend started and connected
+2026-05-19 21:56:10,041 INFO    MainThread:107930 [wandb_init.py:init():988] updated telemetry
+2026-05-19 21:56:10,044 INFO    MainThread:107930 [wandb_init.py:init():1011] communicating run to backend with 90.0 second timeout
+2026-05-19 21:56:10,051 INFO    MainThread:107930 [wandb_init.py:init():1056] starting run threads in backend
+2026-05-19 21:56:10,141 INFO    MainThread:107930 [wandb_run.py:_console_start():2554] atexit reg
+2026-05-19 21:56:10,141 INFO    MainThread:107930 [wandb_run.py:_redirect():2403] redirect: wrap_raw
+2026-05-19 21:56:10,141 INFO    MainThread:107930 [wandb_run.py:_redirect():2472] Wrapping output streams.
+2026-05-19 21:56:10,141 INFO    MainThread:107930 [wandb_run.py:_redirect():2495] Redirects installed.
+2026-05-19 21:56:10,144 INFO    MainThread:107930 [wandb_init.py:init():1094] run started, returning control to user process

model_cache_code_step8000/metadata/FastVideo.git_status.txt

@@ -0,0 +1,7 @@
+repo=FastVideo
+/usr/bin/git
+main
+72cb427cd97ab727cfbfa0db558029765d7fe1a5
+ M fastvideo/dataset/__init__.py
+ M fastvideo/training/training_pipeline.py
+?? fastvideo/dataset/pants_latent_dataset.py

model_cache_code_step8000/metadata/FastVideo.uncommitted.diff

@@ -0,0 +1,182 @@
+diff --git a/fastvideo/dataset/__init__.py b/fastvideo/dataset/__init__.py
+index b82c653..f76077b 100644
+--- a/fastvideo/dataset/__init__.py
++++ b/fastvideo/dataset/__init__.py
+@@ -4,6 +4,8 @@ from torchvision.transforms import Lambda
+ 
+ from fastvideo.dataset.parquet_dataset_map_style import (
+     build_parquet_map_style_dataloader)
++from fastvideo.dataset.pants_latent_dataset import (
++    build_pants_latent_dataloader, is_pants_latent_path)
+ from fastvideo.dataset.ltx2_precomputed_dataset import (
+     build_ltx2_precomputed_dataloader, LTX2PrecomputedDataset)
+ from fastvideo.dataset.preprocessing_datasets import VideoCaptionMergedDataset, TextDataset
+@@ -46,6 +48,8 @@ def gettextdataset(args) -> TextDataset:
+ 
+ __all__ = [
+     "build_parquet_map_style_dataloader",
++    "build_pants_latent_dataloader",
++    "is_pants_latent_path",
+     "build_ltx2_precomputed_dataloader",
+     "LTX2PrecomputedDataset",
+     "ValidationDataset",
+diff --git a/fastvideo/training/training_pipeline.py b/fastvideo/training/training_pipeline.py
+index 575d6dc..140bb31 100644
+--- a/fastvideo/training/training_pipeline.py
++++ b/fastvideo/training/training_pipeline.py
+@@ -28,7 +28,11 @@ try:
+ except Exception:
+     pass
+ from fastvideo.api.sampling_param import SamplingParam
+-from fastvideo.dataset import build_parquet_map_style_dataloader
++from fastvideo.dataset import (
++    build_pants_latent_dataloader,
++    build_parquet_map_style_dataloader,
++    is_pants_latent_path,
++)
+ from fastvideo.dataset.dataloader.schema import pyarrow_schema_t2v
+ from fastvideo.dataset.validation_dataset import ValidationDataset
+ from fastvideo.distributed import (cleanup_dist_env_and_memory, get_local_torch_device, get_sp_group, get_world_group)
+@@ -42,7 +46,8 @@ from fastvideo.training.activation_checkpoint import (apply_activation_checkpoin
+ from fastvideo.training.trackers import (DummyTracker, TrackerType, initialize_trackers, Trackers)
+ from fastvideo.training.training_utils import (clip_grad_norm_while_handling_failing_dtensor_cases,
+                                                compute_density_for_timestep_sampling, count_trainable, get_scheduler,
+-                                               get_sigmas, load_checkpoint, normalize_dit_input, save_checkpoint)
++                                               get_sigmas, load_checkpoint, normalize_dit_input, save_checkpoint,
++                                               EMA_FSDP, gather_state_dict_on_cpu_rank0, custom_to_hf_state_dict)
+ from fastvideo.utils import (is_vmoba_available, is_vsa_available, set_random_seed, shallow_asdict)
+ 
+ try:
+@@ -82,6 +87,7 @@ class TrainingPipeline(LoRAPipeline, ABC):
+         super().__init__(model_path, fastvideo_args, required_config_modules, loaded_modules)  # type: ignore
+         self.tracker = DummyTracker()
+         self.validation_ref_videos_logged = False
++        self.generator_ema: EMA_FSDP | None = None
+ 
+     def create_pipeline_stages(self, fastvideo_args: FastVideoArgs):
+         raise RuntimeError("create_pipeline_stages should not be called for training pipeline")
+@@ -167,16 +173,27 @@ class TrainingPipeline(LoRAPipeline, ABC):
+                 last_epoch=self.init_steps - 1,
+             )
+ 
+-        self.train_dataset, self.train_dataloader = build_parquet_map_style_dataloader(
+-            training_args.data_path,
+-            training_args.train_batch_size,
+-            parquet_schema=self.train_dataset_schema,
+-            num_data_workers=training_args.dataloader_num_workers,
+-            cfg_rate=training_args.training_cfg_rate,
+-            drop_last=True,
+-            text_padding_length=training_args.pipeline_config.text_encoder_configs[0].arch_config.
+-            text_len,  # type: ignore[attr-defined]
+-            seed=self.seed)
++        text_padding_length = training_args.pipeline_config.text_encoder_configs[0].arch_config.text_len  # type: ignore[attr-defined]
++        if is_pants_latent_path(training_args.data_path):
++            self.train_dataset, self.train_dataloader = build_pants_latent_dataloader(
++                training_args.data_path,
++                training_args.train_batch_size,
++                num_data_workers=training_args.dataloader_num_workers,
++                cfg_rate=training_args.training_cfg_rate,
++                drop_last=True,
++                text_padding_length=text_padding_length,
++                seed=self.seed,
++            )
++        else:
++            self.train_dataset, self.train_dataloader = build_parquet_map_style_dataloader(
++                training_args.data_path,
++                training_args.train_batch_size,
++                parquet_schema=self.train_dataset_schema,
++                num_data_workers=training_args.dataloader_num_workers,
++                cfg_rate=training_args.training_cfg_rate,
++                drop_last=True,
++                text_padding_length=text_padding_length,
++                seed=self.seed)
+ 
+         self.noise_scheduler = noise_scheduler
+         if self.training_args.boundary_ratio is not None:
+@@ -460,6 +477,43 @@ class TrainingPipeline(LoRAPipeline, ABC):
+         training_batch.grad_norm = grad_norm
+         return training_batch
+ 
++    def _maybe_init_ema(self, step: int) -> None:
++        if not self.training_args.use_ema:
++            return
++        if self.generator_ema is not None:
++            return
++        if step < self.training_args.ema_start_step:
++            return
++        if self.training_args.ema_decay <= 0:
++            return
++        self.generator_ema = EMA_FSDP(self.transformer, decay=self.training_args.ema_decay)
++        logger.info("Created generator EMA at step %s with decay=%s", step, self.training_args.ema_decay)
++
++    def _maybe_update_ema(self, step: int) -> None:
++        self._maybe_init_ema(step)
++        if self.generator_ema is not None:
++            self.generator_ema.update(self.transformer)
++
++    def _save_ema_weights(self, step: int) -> None:
++        if not self.training_args.use_ema or self.generator_ema is None:
++            return
++        ema_dir = os.path.join(self.training_args.output_dir, f"ema_checkpoint-{step}")
++        os.makedirs(ema_dir, exist_ok=True)
++        with self.generator_ema.apply_to_model(self.transformer):
++            cpu_state = gather_state_dict_on_cpu_rank0(self.transformer, device=None)
++        if self.global_rank == 0:
++            from safetensors.torch import save_file
++
++            diffusers_state_dict = custom_to_hf_state_dict(
++                cpu_state,
++                self.transformer.reverse_param_names_mapping,
++            )
++            save_file(
++                diffusers_state_dict,
++                os.path.join(ema_dir, "diffusion_pytorch_model.safetensors"),
++            )
++            logger.info("Saved EMA transformer weights to %s", ema_dir)
++
+     @profile_region("profiler_region_training_train_one_step")
+     def train_one_step(self, training_batch: TrainingBatch) -> TrainingBatch:
+         training_batch = self._prepare_training(training_batch)
+@@ -571,6 +625,7 @@ class TrainingPipeline(LoRAPipeline, ABC):
+             training_batch.current_timestep = step
+             training_batch.current_vsa_sparsity = current_vsa_sparsity
+             training_batch = self.train_one_step(training_batch)
++            self._maybe_update_ema(step)
+ 
+             loss = float(training_batch.total_loss)
+             grad_norm = training_batch.grad_norm
+@@ -594,6 +649,9 @@ class TrainingPipeline(LoRAPipeline, ABC):
+                     "grad_norm": grad_norm,
+                     "vsa_sparsity": current_vsa_sparsity,
+                 }
++                if self.training_args.use_ema:
++                    metrics["ema_enabled"] = self.generator_ema is not None
++                    metrics["ema_decay"] = self.training_args.ema_decay
+                 try:
+                     metrics["batch_size"] = int(training_batch.raw_latent_shape[0])
+ 
+@@ -622,6 +680,7 @@ class TrainingPipeline(LoRAPipeline, ABC):
+                     save_checkpoint(self.transformer, self.global_rank, self.training_args.output_dir, step,
+                                     self.optimizer, self.train_dataloader, self.lr_scheduler,
+                                     self.noise_random_generator)
++                    self._save_ema_weights(step)
+                 self.transformer.train()
+                 self.sp_group.barrier()
+ 
+@@ -637,9 +696,13 @@ class TrainingPipeline(LoRAPipeline, ABC):
+                                 trainable_params)
+ 
+         self.tracker.finish()
+-        save_checkpoint(self.transformer, self.global_rank, self.training_args.output_dir,
+-                        self.training_args.max_train_steps, self.optimizer, self.train_dataloader, self.lr_scheduler,
+-                        self.noise_random_generator)
++        if os.environ.get("FASTVIDEO_SKIP_FINAL_CHECKPOINT", "0") == "1":
++            logger.info("Skipping final checkpoint because FASTVIDEO_SKIP_FINAL_CHECKPOINT=1")
++        else:
++            save_checkpoint(self.transformer, self.global_rank, self.training_args.output_dir,
++                            self.training_args.max_train_steps, self.optimizer, self.train_dataloader,
++                            self.lr_scheduler, self.noise_random_generator)
++            self._save_ema_weights(self.training_args.max_train_steps)
+ 
+         if envs.FASTVIDEO_TORCH_PROFILER_DIR:
+             logger.info("Stopping profiler...")

model_cache_code_step8000/metadata/FastVideo.untracked_files.txt

@@ -0,0 +1 @@
+fastvideo/dataset/pants_latent_dataset.py

model_cache_code_step8000/metadata/TwoFrame.git_status.txt

@@ -0,0 +1,197 @@
+repo=TwoFrame
+/usr/bin/git
+main
+d923e4d7647196b00bf74d043f29988a9fe8ca51
+ M requirements.txt
+ M scripts/aggregate_phase_b_report.py
+ M scripts/build_rich_caption_probe.py
+ M scripts/convert_pico_jsonl_to_twoframe_manifest.py
+ M scripts/eval_pair_metrics.py
+ M scripts/eval_source_reconstruction.py
+ M scripts/infer_9b_lora_twoframe_8gpu.sh
+ M scripts/infer_batch_condition.py
+ M scripts/infer_batch_multiframe.py
+ M scripts/infer_batch_twoframe.py
+ M scripts/infer_d10_mid_refresh.py
+ M scripts/infer_d5_self_conditioning.py
+ M scripts/infer_d8_oracle_clean_source.py
+ M scripts/infer_d9_block_cfg.py
+ M scripts/infer_flux_klein_twoframe.py
+ M scripts/infer_twostep_baseline.py
+ M scripts/make_multiframe_gallery.py
+ M scripts/make_multiframe_probe_combo_html.py
+ M scripts/make_multiframe_test100_html.py
+ M scripts/make_phase2_complex_highscore_html.py
+ M scripts/make_reasoning_holdout500_html.py
+ M scripts/make_reasoning_holdout_sampled_html.py
+ M scripts/make_reasoning_sample_html.py
+ M scripts/measure_pair_consistency.py
+ M scripts/phase_b_master_loop.sh
+ M scripts/phase_b_status_emit.sh
+ M scripts/phase_b_watchdog.sh
+ M scripts/phase_c_status.sh
+ M scripts/precompute_flux2_vae_cache.py
+ M scripts/precompute_flux2_vae_cache_8gpu.sh
+ M scripts/prepare_benchmark_manifests.py
+ M scripts/prepare_ccb_c8_manifest.py
+ M scripts/prepare_eval_manifests.py
+ M scripts/prepare_phase_a_manifests.py
+ M scripts/prepare_reasoning_holdout_infer_manifest.py
+ M scripts/prepare_reasoning_holdout_test_manifest.py
+ M scripts/prepare_reasoning_manifest.py
+ M scripts/prepare_short_instruction_manifests.py
+ M scripts/run0_sonnet_select.py
+ M scripts/run_all_eval.sh
+ M scripts/run_all_inference_machine_a.sh
+ M scripts/run_d11_real_source_eval.sh
+ M scripts/run_d1_d2_d3.sh
+ M scripts/run_d4_failure_taxonomy.sh
+ M scripts/run_d5_self_conditioning.sh
+ M scripts/run_d6_structured_joint.sh
+ M scripts/run_d7_text_factorization.sh
+ M scripts/run_d8_oracle.sh
+ M scripts/run_eval_data_quality_6jobs.sh
+ M scripts/run_eval_imgedit_gedit_mode.sh
+ M scripts/run_eval_machine_a_m3source_wait_m2.sh
+ M scripts/run_eval_machine_a_scoring.sh
+ M scripts/run_eval_machine_a_stage1.sh
+ M scripts/run_eval_machine_c_imgedit.sh
+ M scripts/run_eval_machine_d_gedit.sh
+ M scripts/run_exp_k_machine_b_eval.sh
+ M scripts/run_exp_k_machine_b_infer.sh
+ M scripts/run_generate_twoframe_complex_22k_cfg7_ckpt35k.sh
+ M scripts/run_infer_c2_8gpu.sh
+ M scripts/run_infer_c3_8gpu.sh
+ M scripts/run_infer_c4_8gpu.sh
+ M scripts/run_infer_node_consolidated_until_done.sh
+ M scripts/run_m2new_infer_eval.sh
+ M scripts/run_m3_cfg7_only.sh
+ M scripts/run_m3_s50_eval.sh
+ M scripts/run_m3ft_35000_8gpu.sh
+ M scripts/run_m3ft_inference.sh
+ M scripts/run_m3ft_missing_resume.sh
+ M scripts/run_m3ft_resume60k.sh
+ M scripts/run_m3ft_sweep_eval.sh
+ M scripts/run_m3source_round_end2end.sh
+ M scripts/run_machine_a_eval.sh
+ M scripts/run_machine_a_infer.sh
+ M scripts/run_machine_b_distilled_train.sh
+ M scripts/run_machine_b_distilled_train_local.sh
+ M scripts/run_missing_inference_resume.sh
+ M scripts/run_missing_machine_a.sh
+ M scripts/run_missing_machine_a_m1_rewrite.sh
+ M scripts/run_missing_machine_b.sh
+ M scripts/run_multiframe_4img_probe10.sh
+ M scripts/run_multiframe_resample100.sh
+ M scripts/run_multiframe_smoke_1gpu.sh
+ M scripts/run_multiframe_smoke_8gpu.sh
+ M scripts/run_multiframe_smoke_8gpu_debug.sh
+ M scripts/run_multiframe_test100.sh
+ M scripts/run_multiframe_test100_latest_when_free.sh
+ M scripts/run_multiframe_train.sh
+ M scripts/run_phase2_refilter_4jobs.sh
+ M scripts/run_phase_a.sh
+ M scripts/run_phase_a_eval.sh
+ M scripts/run_phase_a_eval_parallel.sh
+ M scripts/run_phase_a_mllm_eval_sonnet46.sh
+ M scripts/run_phase_b_eval_all.sh
+ M scripts/run_phase_c.sh
+ M scripts/run_reasoning_holdout500_infer.sh
+ M scripts/run_reasoning_probe.sh
+ M scripts/run_reasoning_train.sh
+ M scripts/run_rewrite_structured.sh
+ M scripts/run_rich_caption_probe.sh
+ M scripts/run_unified_cfg4_test.sh
+ M scripts/run_v2_instr_filter_2jobs.sh
+ M scripts/run_watchdog_1h.sh
+ M scripts/sample_multiframe_4img_probe10.py
+ M scripts/sample_multiframe_resample100.py
+ M scripts/switch_current_to_machine_b.sh
+ M scripts/train_4b_base_editlong_pico400k_train20k_bs2_lr1e5_vae_cache_zero2.sh
+ M scripts/train_4b_full.sh
+ M scripts/train_4b_full_pico400k_opusstage2_long_train20k_bs2_lr1e5_jointtext_t0_zero2.sh
+ M scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_cfgdrop0.sh
+ M scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_cfgdrop0_zero2.sh
+ M scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_jointtext_t0_zero2.sh
+ M scripts/train_4b_full_pico400k_short_zero2_smoke.sh
+ M scripts/train_4b_lora.sh
+ M scripts/train_4b_lora_moe_prodigy_pico400k_short_jointtext_t0_bs2_zero2.sh
+ M scripts/train_9b_base_editlong_pico400k_train20k_bs2_lr1e6_vae_cache_zero2.sh
+ M scripts/train_9b_full.sh
+ M scripts/train_9b_full_direct_edit_baseline_zero2.sh
+ M scripts/train_9b_full_direct_edit_baseline_zero3.sh
+ M scripts/train_9b_full_pico400k_opusstage2_long_train20k_bs2_lr1e6_jointtext_t0_zero2.sh
+ M scripts/train_9b_full_pico57k_corner10k_long_jointtext_zero2.sh
+ M scripts/train_9b_full_pico57k_corner10k_long_jointtext_zero3.sh
+ M scripts/train_9b_full_twoframe_lr5e6_zero2.sh
+ M scripts/train_9b_lora.sh
+ M scripts/train_9b_lora_downstream_edit_combined_zero2.sh
+ M scripts/train_9b_lora_downstream_edit_phase2_zero2.sh
+ M scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_fluxfill_icedittargets_zero2.sh
+ M scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_simpletuner_flux2targets_zero2.sh
+ M scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_zero2.sh
+ M scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_zero3.sh
+ M scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_zero2.sh
+ M scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_nogc_zero2.sh
+ M scripts/train_9b_lora_moe_prodigy_finalmix80k_short_no_latent_nogc_zero2.sh
+ M scripts/train_9b_lora_moe_prodigy_pico400k_long_jointtext_t0_bs2_zero2.sh
+ M scripts/train_9b_lora_pico57k_corner10k_long_jointtext_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_smoke_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_textimgemb_full25k_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_v1_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_icedit6targets_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_finalmix80k_short_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_node2_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_finalmix80k_short_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_zero2.sh
+ M scripts/train_9b_lora_standard_prodigy_pico400k_long_jointtext_t0_bs1ga2_icedit6targets_vae_cache_zero2.sh
+ M scripts/train_exp_e_phase2_only.sh
+ M scripts/train_exp_f_phase2_pico.sh
+ M scripts/train_exp_g_phase2_all.sh
+ M scripts/wait_then_resume_m3ft60k.sh
+ M scripts/wait_then_run_multiframe_4img_probe10.sh
+ M scripts/watch_and_run_m3ft_sweep.sh
+ M scripts/watch_m3ft_35000_launch.sh
+ M train.py
+ M twoframe/modeling.py
+ M twoframe/native_inference.py
+?? configs/accelerate_8gpu_zero2_ga2.yaml
+?? configs/flux_klein9b_mixed_bucketed_editor_only_ma034235_ma79931_ucsf.yaml
+?? configs/flux_klein9b_mixed_bucketed_joint_ema_resume_ucsf.yaml
+?? configs/flux_klein9b_mixed_bucketed_ma034235_ma79931_ucsf.yaml
+?? docs/TWOFRAME_DATA_ENGINE.md
+?? docs/UCSF_EVAL_EXPERIMENT_TRACKER.md
+?? scripts/analyze_ma034235_manifest_filter.py
+?? scripts/analyze_ma034235_manifest_filter_ucsf.sbatch
+?? scripts/build_bucket_cache.py
+?? scripts/build_mixed_bucket_caches_h200_ucsf.sbatch
+?? scripts/build_mixed_bucket_caches_ucsf.sbatch
+?? scripts/build_multiref_condition_manifest_from_outputs.py
+?? scripts/check_bucketed_dataloader.py
+?? scripts/eval_generate_single_gpu_ucsf.sbatch
+?? scripts/hold_h200_allocation_ucsf.sbatch
+?? scripts/infer_multiref_condition_editor.py
+?? scripts/infer_twoframe_data_engine.py
+?? scripts/launch_twoframe_data_engine_ctmux_ucsf.sh
+?? scripts/prepare_ucsf_eval_manifests.py
+?? scripts/run_multiref_backfill_queue_ucsf.sh
+?? scripts/run_multiref_condition_editor_inalloc_8g_ucsf.sh
+?? scripts/run_singleref_condition_baselines_inalloc_8g_ucsf.sh
+?? scripts/run_singleref_pair_metrics_8gpu_ucsf.sbatch
+?? scripts/run_singleref_pair_metrics_ucsf.sbatch
+?? scripts/run_twoframe_data_engine_inalloc_ucsf.sh
+?? scripts/run_wandb_login_tail_both_loop_ucsf.sh
+?? scripts/run_wandb_login_tail_both_persistent_ucsf.sh
+?? scripts/run_wandb_login_tail_loop_ucsf.sh
+?? scripts/run_wandb_login_tail_ucsf.sh
+?? scripts/srun_in_h200_allocation_ucsf.sh
+?? scripts/tail_train_log_to_wandb.py
+?? scripts/tail_train_log_to_wandb_ucsf.sbatch
+?? scripts/train_mixed_bucketed_editor_only_ucsf.sbatch
+?? scripts/train_mixed_bucketed_joint_ema_resume_ucsf.sbatch
+?? scripts/train_mixed_bucketed_joint_ucsf.sbatch
+?? scripts/train_mixed_bucketed_ucsf.sbatch
+?? scripts/verify_mixed_bucket_caches_ucsf.sbatch
+?? scripts/verify_mixed_bucket_caches_ucsf.sh
+?? scripts/wait_then_run_multiref_condition_baselines_ucsf.sh
+?? twoframe/data_bucketed.py

model_cache_code_step8000/metadata/TwoFrame.uncommitted.diff

@@ -0,0 +1,1627 @@
+diff --git a/requirements.txt b/requirements.txt
+index a93eefd..c0825fe 100644
+--- a/requirements.txt
++++ b/requirements.txt
+@@ -10,5 +10,7 @@ einops
+ PyYAML
+ Pillow
+ numpy
++scikit-image
+ huggingface_hub
+ safetensors
++git+https://github.com/openai/CLIP.git
+diff --git a/scripts/aggregate_phase_b_report.py b/scripts/aggregate_phase_b_report.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/build_rich_caption_probe.py b/scripts/build_rich_caption_probe.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/convert_pico_jsonl_to_twoframe_manifest.py b/scripts/convert_pico_jsonl_to_twoframe_manifest.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/eval_pair_metrics.py b/scripts/eval_pair_metrics.py
+index a7832f7..eb93cea 100644
+--- a/scripts/eval_pair_metrics.py
++++ b/scripts/eval_pair_metrics.py
+@@ -25,8 +25,10 @@ Usage:
+ from __future__ import annotations
+ 
+ import argparse
++import hashlib
+ import json
+ import logging
++import os
+ from pathlib import Path
+ 
+ import clip
+@@ -46,6 +48,34 @@ logging.basicConfig(
+ logger = logging.getLogger(__name__)
+ 
+ 
++def clip_download_root() -> str | None:
++    root = os.environ.get("CLIP_CACHE_DIR")
++    if not root and os.environ.get("XDG_CACHE_HOME"):
++        root = str(Path(os.environ["XDG_CACHE_HOME"]) / "clip")
++    if root:
++        Path(root).mkdir(parents=True, exist_ok=True)
++    return root
++
++
++def load_dinov2_vitl14(device: str) -> torch.nn.Module:
++    repo = os.environ.get("DINOV2_REPO")
++    if not repo:
++        repo = str(Path(torch.hub.get_dir()) / "facebookresearch_dinov2_main")
++    repo_path = Path(repo)
++    if repo_path.exists():
++        logger.info(f"Loading DINOv2 ViT-L/14 from local torch hub repo: {repo_path}")
++        model = torch.hub.load(str(repo_path), "dinov2_vitl14", source="local", pretrained=True)
++    else:
++        logger.info("Loading DINOv2 ViT-L/14 from torch hub remote repo")
++        model = torch.hub.load(
++            "facebookresearch/dinov2",
++            "dinov2_vitl14",
++            pretrained=True,
++            skip_validation=True,
++        )
++    return model.to(device).eval().requires_grad_(False)
++
++
+ class PairMetrics(nn.Module):
+     """Compute CLIP, DINOv2, SSIM metrics for source-target pairs."""
+ 
+@@ -55,14 +85,15 @@ class PairMetrics(nn.Module):
+ 
+         # CLIP ViT-L/14
+         logger.info("Loading CLIP ViT-L/14...")
+-        self.clip_model, self.clip_preprocess = clip.load("ViT-L/14", device=device)
++        self.clip_model, self.clip_preprocess = clip.load(
++            "ViT-L/14", device=device, download_root=clip_download_root()
++        )
+         self.clip_model.eval().requires_grad_(False)
+         self.clip_size = 224
+ 
+         # DINOv2 ViT-L/14
+         logger.info("Loading DINOv2 ViT-L/14...")
+-        self.dinov2 = torch.hub.load("facebookresearch/dinov2", "dinov2_vitl14", pretrained=True)
+-        self.dinov2 = self.dinov2.to(device).eval().requires_grad_(False)
++        self.dinov2 = load_dinov2_vitl14(device)
+ 
+         self.register_buffer("clip_mean", torch.tensor((0.48145466, 0.4578275, 0.40821073)))
+         self.register_buffer("clip_std", torch.tensor((0.26862954, 0.26130258, 0.27577711)))
+@@ -164,6 +195,11 @@ def parse_args():
+     ap.add_argument("--output-dir", required=True)
+     ap.add_argument("--device", default="cuda:0")
+     ap.add_argument("--id-field", default="item_id")
++    ap.add_argument("--source-fallback-field", default="source_image_abs",
++                    help="Manifest field to use when a method directory has no {id}_source image. "
++                         "Set empty to disable fallback.")
++    ap.add_argument("--shard-id", type=int, default=0)
++    ap.add_argument("--num-shards", type=int, default=1)
+     return ap.parse_args()
+ 
+ 
+@@ -184,6 +220,13 @@ def main():
+         for line in f:
+             if line.strip():
+                 eval_items.append(json.loads(line))
++    if args.num_shards > 1:
++        before = len(eval_items)
++        eval_items = [
++            item for item in eval_items
++            if int(hashlib.md5(str(item[args.id_field]).encode()).hexdigest(), 16) % args.num_shards == args.shard_id
++        ]
++        logger.info(f"Shard {args.shard_id}/{args.num_shards}: {len(eval_items)}/{before} items")
+     logger.info(f"Eval manifest: {len(eval_items)} items")
+ 
+     # Initialize metrics
+@@ -203,6 +246,13 @@ def main():
+             src = find_image(method_dir, item_id, "source")
+             tgt = find_image(method_dir, item_id, "target")
+ 
++            if not src and args.source_fallback_field:
++                fallback = item.get(args.source_fallback_field, "")
++                if fallback:
++                    fallback_path = Path(fallback)
++                    if fallback_path.exists():
++                        src = fallback_path
++
+             if not src or not tgt:
+                 continue
+ 
+diff --git a/scripts/eval_source_reconstruction.py b/scripts/eval_source_reconstruction.py
+index 3f867ec..fb2e658 100644
+--- a/scripts/eval_source_reconstruction.py
++++ b/scripts/eval_source_reconstruction.py
+@@ -26,6 +26,7 @@ from __future__ import annotations
+ import argparse
+ import json
+ import logging
++import os
+ from pathlib import Path
+ 
+ import clip
+@@ -44,18 +45,47 @@ logging.basicConfig(
+ logger = logging.getLogger(__name__)
+ 
+ 
++def clip_download_root() -> str | None:
++    root = os.environ.get("CLIP_CACHE_DIR")
++    if not root and os.environ.get("XDG_CACHE_HOME"):
++        root = str(Path(os.environ["XDG_CACHE_HOME"]) / "clip")
++    if root:
++        Path(root).mkdir(parents=True, exist_ok=True)
++    return root
++
++
++def load_dinov2_vitl14(device: str) -> torch.nn.Module:
++    repo = os.environ.get("DINOV2_REPO")
++    if not repo:
++        repo = str(Path(torch.hub.get_dir()) / "facebookresearch_dinov2_main")
++    repo_path = Path(repo)
++    if repo_path.exists():
++        logger.info(f"Loading DINOv2 ViT-L/14 from local torch hub repo: {repo_path}")
++        model = torch.hub.load(str(repo_path), "dinov2_vitl14", source="local", pretrained=True)
++    else:
++        logger.info("Loading DINOv2 ViT-L/14 from torch hub remote repo")
++        model = torch.hub.load(
++            "facebookresearch/dinov2",
++            "dinov2_vitl14",
++            pretrained=True,
++            skip_validation=True,
++        )
++    return model.to(device).eval().requires_grad_(False)
++
++
+ class ImageEncoders(nn.Module):
+     def __init__(self, device: str = "cuda:0"):
+         super().__init__()
+         self.device = device
+ 
+         logger.info("Loading CLIP ViT-L/14...")
+-        self.clip_model, _ = clip.load("ViT-L/14", device=device)
++        self.clip_model, _ = clip.load(
++            "ViT-L/14", device=device, download_root=clip_download_root()
++        )
+         self.clip_model.eval().requires_grad_(False)
+ 
+         logger.info("Loading DINOv2 ViT-L/14...")
+-        self.dinov2 = torch.hub.load("facebookresearch/dinov2", "dinov2_vitl14", pretrained=True)
+-        self.dinov2 = self.dinov2.to(device).eval().requires_grad_(False)
++        self.dinov2 = load_dinov2_vitl14(device)
+ 
+         self.register_buffer("clip_mean", torch.tensor((0.48145466, 0.4578275, 0.40821073)))
+         self.register_buffer("clip_std", torch.tensor((0.26862954, 0.26130258, 0.27577711)))
+diff --git a/scripts/infer_9b_lora_twoframe_8gpu.sh b/scripts/infer_9b_lora_twoframe_8gpu.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/infer_batch_condition.py b/scripts/infer_batch_condition.py
+index 3aae26b..bd0564d 100644
+--- a/scripts/infer_batch_condition.py
++++ b/scripts/infer_batch_condition.py
+@@ -58,6 +58,10 @@ def parse_args() -> argparse.Namespace:
+     ap.add_argument("--output-dir", required=True, help="Output directory.")
+     # Model loading
+     ap.add_argument("--model-id", default="black-forest-labs/FLUX.2-klein-base-9B")
++    ap.add_argument("--base-model-root", default=None,
++                    help="Local FLUX.2 klein base root. Sets KLEIN_9B_BASE_MODEL_ROOT.")
++    ap.add_argument("--require-local-base", action="store_true",
++                    help="Fail if the requested local base root is missing.")
+     ap.add_argument("--lora", default=None, help="LoRA adapter path.")
+     ap.add_argument("--transformer-checkpoint", default=None,
+                     help="Full transformer checkpoint dir (for full FT models).")
+@@ -136,6 +140,17 @@ def main() -> None:
+         logger.info("Nothing to do.")
+         return
+ 
++    if args.base_model_root:
++        base_root = Path(args.base_model_root).expanduser()
++        if args.require_local_base and not base_root.exists():
++            raise FileNotFoundError(f"Local base model root not found: {base_root}")
++        os.environ["KLEIN_9B_BASE_MODEL_ROOT"] = str(base_root)
++        os.environ.setdefault(
++            "KLEIN_9B_BASE_MODEL_PATH",
++            str(base_root / "flux-2-klein-base-9b.safetensors"),
++        )
++        logger.info(f"Using local base model root: {base_root}")
++
+     # Setup device
+     device = torch.device(
+         f"cuda:{args.shard_id % torch.cuda.device_count()}"
+diff --git a/scripts/infer_batch_multiframe.py b/scripts/infer_batch_multiframe.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/infer_batch_twoframe.py b/scripts/infer_batch_twoframe.py
+old mode 100644
+new mode 100755
+index be33e67..605c77e
+--- a/scripts/infer_batch_twoframe.py
++++ b/scripts/infer_batch_twoframe.py
+@@ -38,6 +38,8 @@ def parse_args() -> argparse.Namespace:
+     ap.add_argument("--lora", default=None, help="LoRA adapter path (directory with adapter files).")
+     ap.add_argument("--transformer-checkpoint", default=None,
+                     help="Full transformer checkpoint dir (for full FT models).")
++    ap.add_argument("--aux-path", default=None,
++                    help="Optional twoframe_aux.{safetensors,pt}; defaults to searching the checkpoint/LoRA dir.")
+     ap.add_argument("--model-id", default="black-forest-labs/FLUX.2-klein-base-9B")
+     ap.add_argument("--steps", type=int, default=28)
+     ap.add_argument("--cfg", type=float, default=6.0)
+@@ -65,6 +67,29 @@ def parse_args() -> argparse.Namespace:
+     return ap.parse_args()
+ 
+ 
++def find_aux_path(*roots: str | None) -> str | None:
++    """Find saved TwoFrame auxiliary embeddings next to a checkpoint/adapter."""
++    for root in roots:
++        if not root:
++            continue
++        path = Path(root).expanduser()
++        search_dir = path if path.is_dir() else path.parent
++        for name in ("twoframe_aux.safetensors", "twoframe_aux.pt"):
++            candidate = search_dir / name
++            if candidate.exists():
++                return str(candidate)
++    return None
++
++
++def format_twoframe_prompt(template: str, source_caption: str, instruction: str) -> str:
++    source_blocks = f"[Source Image 1]\n{source_caption or 'reference image 1'}"
++    return template.format(
++        source_caption=source_caption,
++        instruction=instruction,
++        source_blocks=source_blocks,
++    )
++
++
+ def shard_items(items: list[dict], shard_id: int, num_shards: int) -> list[dict]:
+     """Hash-based sharding for deterministic distribution."""
+     if num_shards <= 1:
+@@ -131,6 +156,10 @@ def main() -> None:
+         engine.load_lora(args.lora)
+     else:
+         logger.info("No adapter loaded — using base model.")
++    aux_candidate = args.aux_path or find_aux_path(args.transformer_checkpoint, args.lora)
++    if aux_candidate:
++        engine.load_twoframe_aux(aux_candidate)
++        logger.info(f"Loaded twoframe aux embeddings: {aux_candidate}")
+     logger.info("Model ready.")
+ 
+     need_negative = args.cfg > 1.0
+@@ -145,12 +174,14 @@ def main() -> None:
+ 
+         try:
+             # Encode text (joint mode)
+-            merged_prompt = args.text_template.format(
+-                source_caption=source_caption,
+-                instruction=instruction,
+-            )
++            merged_prompt = format_twoframe_prompt(args.text_template, source_caption, instruction)
+             pos_embeds, text_ids = engine.encode_text_joint(
+-                [merged_prompt], text_t=args.text_t,
++                [merged_prompt],
++                text_t=args.text_t,
++                source_captions=[source_caption],
++                instructions=[instruction],
++                text_template=args.text_template,
++                strict_template=engine.extra_embed_strict_template,
+             )
+             neg_embeds = neg_text_ids = None
+             if need_negative:
+diff --git a/scripts/infer_d10_mid_refresh.py b/scripts/infer_d10_mid_refresh.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/infer_d5_self_conditioning.py b/scripts/infer_d5_self_conditioning.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/infer_d8_oracle_clean_source.py b/scripts/infer_d8_oracle_clean_source.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/infer_d9_block_cfg.py b/scripts/infer_d9_block_cfg.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/infer_flux_klein_twoframe.py b/scripts/infer_flux_klein_twoframe.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/infer_twostep_baseline.py b/scripts/infer_twostep_baseline.py
+old mode 100644
+new mode 100755
+index eb8f476..715410c
+--- a/scripts/infer_twostep_baseline.py
++++ b/scripts/infer_twostep_baseline.py
+@@ -66,6 +66,8 @@ def parse_args() -> argparse.Namespace:
+     ap.add_argument("--model-id", default="black-forest-labs/FLUX.2-klein-base-9B")
+     ap.add_argument("--edit-checkpoint", default=None,
+                     help="Checkpoint for the edit step. None = use base model (M1→M1).")
++    ap.add_argument("--edit-aux-path", default=None,
++                    help="Optional twoframe_aux.{safetensors,pt} for the edit checkpoint.")
+     # T2I step params
+     ap.add_argument("--steps-t2i", type=int, default=28)
+     ap.add_argument("--cfg-t2i", type=float, default=4.0)
+@@ -95,6 +97,20 @@ def parse_args() -> argparse.Namespace:
+     return ap.parse_args()
+ 
+ 
++def find_aux_path(*roots: str | None) -> str | None:
++    """Find saved TwoFrame auxiliary embeddings next to a checkpoint/adapter."""
++    for root in roots:
++        if not root:
++            continue
++        path = Path(root).expanduser()
++        search_dir = path if path.is_dir() else path.parent
++        for name in ("twoframe_aux.safetensors", "twoframe_aux.pt"):
++            candidate = search_dir / name
++            if candidate.exists():
++                return str(candidate)
++    return None
++
++
+ def shard_items(items: list[dict], shard_id: int, num_shards: int) -> list[dict]:
+     if num_shards <= 1:
+         return items
+@@ -244,6 +260,10 @@ def main() -> None:
+         logger.info(f"Loading edit checkpoint: {args.edit_checkpoint}")
+         n_miss, n_unexp = engine.load_flow_checkpoint(args.edit_checkpoint)
+         logger.info(f"  missing={n_miss}, unexpected={n_unexp}")
++        aux_candidate = args.edit_aux_path or find_aux_path(args.edit_checkpoint)
++        if aux_candidate:
++            engine.load_twoframe_aux(aux_candidate)
++            logger.info(f"Loaded edit twoframe aux embeddings: {aux_candidate}")
+ 
+     # Re-encode negative for edit step
+     if need_negative:
+@@ -282,7 +302,12 @@ def main() -> None:
+                 source_caption=source_caption,
+             )
+             pos_embeds, text_ids = engine.encode_text_joint(
+-                [prompt], text_t=args.text_t,
++                [prompt],
++                text_t=args.text_t,
++                source_captions=[source_caption],
++                instructions=[instruction],
++                text_template=args.edit_text_template,
++                strict_template=engine.extra_embed_strict_template,
+             )
+ 
+             # Encode source as condition
+diff --git a/scripts/make_multiframe_gallery.py b/scripts/make_multiframe_gallery.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/make_multiframe_probe_combo_html.py b/scripts/make_multiframe_probe_combo_html.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/make_multiframe_test100_html.py b/scripts/make_multiframe_test100_html.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/make_phase2_complex_highscore_html.py b/scripts/make_phase2_complex_highscore_html.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/make_reasoning_holdout500_html.py b/scripts/make_reasoning_holdout500_html.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/make_reasoning_holdout_sampled_html.py b/scripts/make_reasoning_holdout_sampled_html.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/make_reasoning_sample_html.py b/scripts/make_reasoning_sample_html.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/measure_pair_consistency.py b/scripts/measure_pair_consistency.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/phase_b_master_loop.sh b/scripts/phase_b_master_loop.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/phase_b_status_emit.sh b/scripts/phase_b_status_emit.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/phase_b_watchdog.sh b/scripts/phase_b_watchdog.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/phase_c_status.sh b/scripts/phase_c_status.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/precompute_flux2_vae_cache.py b/scripts/precompute_flux2_vae_cache.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/precompute_flux2_vae_cache_8gpu.sh b/scripts/precompute_flux2_vae_cache_8gpu.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/prepare_benchmark_manifests.py b/scripts/prepare_benchmark_manifests.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/prepare_ccb_c8_manifest.py b/scripts/prepare_ccb_c8_manifest.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/prepare_eval_manifests.py b/scripts/prepare_eval_manifests.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/prepare_phase_a_manifests.py b/scripts/prepare_phase_a_manifests.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/prepare_reasoning_holdout_infer_manifest.py b/scripts/prepare_reasoning_holdout_infer_manifest.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/prepare_reasoning_holdout_test_manifest.py b/scripts/prepare_reasoning_holdout_test_manifest.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/prepare_reasoning_manifest.py b/scripts/prepare_reasoning_manifest.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/prepare_short_instruction_manifests.py b/scripts/prepare_short_instruction_manifests.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/run0_sonnet_select.py b/scripts/run0_sonnet_select.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_all_eval.sh b/scripts/run_all_eval.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_all_inference_machine_a.sh b/scripts/run_all_inference_machine_a.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_d11_real_source_eval.sh b/scripts/run_d11_real_source_eval.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_d1_d2_d3.sh b/scripts/run_d1_d2_d3.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_d4_failure_taxonomy.sh b/scripts/run_d4_failure_taxonomy.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_d5_self_conditioning.sh b/scripts/run_d5_self_conditioning.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_d6_structured_joint.sh b/scripts/run_d6_structured_joint.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_d7_text_factorization.sh b/scripts/run_d7_text_factorization.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_d8_oracle.sh b/scripts/run_d8_oracle.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_eval_data_quality_6jobs.sh b/scripts/run_eval_data_quality_6jobs.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_eval_imgedit_gedit_mode.sh b/scripts/run_eval_imgedit_gedit_mode.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_eval_machine_a_m3source_wait_m2.sh b/scripts/run_eval_machine_a_m3source_wait_m2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_eval_machine_a_scoring.sh b/scripts/run_eval_machine_a_scoring.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_eval_machine_a_stage1.sh b/scripts/run_eval_machine_a_stage1.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_eval_machine_c_imgedit.sh b/scripts/run_eval_machine_c_imgedit.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_eval_machine_d_gedit.sh b/scripts/run_eval_machine_d_gedit.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_exp_k_machine_b_eval.sh b/scripts/run_exp_k_machine_b_eval.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_exp_k_machine_b_infer.sh b/scripts/run_exp_k_machine_b_infer.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_generate_twoframe_complex_22k_cfg7_ckpt35k.sh b/scripts/run_generate_twoframe_complex_22k_cfg7_ckpt35k.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_infer_c2_8gpu.sh b/scripts/run_infer_c2_8gpu.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_infer_c3_8gpu.sh b/scripts/run_infer_c3_8gpu.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_infer_c4_8gpu.sh b/scripts/run_infer_c4_8gpu.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_infer_node_consolidated_until_done.sh b/scripts/run_infer_node_consolidated_until_done.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m2new_infer_eval.sh b/scripts/run_m2new_infer_eval.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m3_cfg7_only.sh b/scripts/run_m3_cfg7_only.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m3_s50_eval.sh b/scripts/run_m3_s50_eval.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m3ft_35000_8gpu.sh b/scripts/run_m3ft_35000_8gpu.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m3ft_inference.sh b/scripts/run_m3ft_inference.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m3ft_missing_resume.sh b/scripts/run_m3ft_missing_resume.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m3ft_resume60k.sh b/scripts/run_m3ft_resume60k.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m3ft_sweep_eval.sh b/scripts/run_m3ft_sweep_eval.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_m3source_round_end2end.sh b/scripts/run_m3source_round_end2end.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_machine_a_eval.sh b/scripts/run_machine_a_eval.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_machine_a_infer.sh b/scripts/run_machine_a_infer.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_machine_b_distilled_train.sh b/scripts/run_machine_b_distilled_train.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_machine_b_distilled_train_local.sh b/scripts/run_machine_b_distilled_train_local.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_missing_inference_resume.sh b/scripts/run_missing_inference_resume.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_missing_machine_a.sh b/scripts/run_missing_machine_a.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_missing_machine_a_m1_rewrite.sh b/scripts/run_missing_machine_a_m1_rewrite.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_missing_machine_b.sh b/scripts/run_missing_machine_b.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_multiframe_4img_probe10.sh b/scripts/run_multiframe_4img_probe10.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_multiframe_resample100.sh b/scripts/run_multiframe_resample100.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_multiframe_smoke_1gpu.sh b/scripts/run_multiframe_smoke_1gpu.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_multiframe_smoke_8gpu.sh b/scripts/run_multiframe_smoke_8gpu.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_multiframe_smoke_8gpu_debug.sh b/scripts/run_multiframe_smoke_8gpu_debug.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_multiframe_test100.sh b/scripts/run_multiframe_test100.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_multiframe_test100_latest_when_free.sh b/scripts/run_multiframe_test100_latest_when_free.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_multiframe_train.sh b/scripts/run_multiframe_train.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_phase2_refilter_4jobs.sh b/scripts/run_phase2_refilter_4jobs.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_phase_a.sh b/scripts/run_phase_a.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_phase_a_eval.sh b/scripts/run_phase_a_eval.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_phase_a_eval_parallel.sh b/scripts/run_phase_a_eval_parallel.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_phase_a_mllm_eval_sonnet46.sh b/scripts/run_phase_a_mllm_eval_sonnet46.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_phase_b_eval_all.sh b/scripts/run_phase_b_eval_all.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_phase_c.sh b/scripts/run_phase_c.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_reasoning_holdout500_infer.sh b/scripts/run_reasoning_holdout500_infer.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_reasoning_probe.sh b/scripts/run_reasoning_probe.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_reasoning_train.sh b/scripts/run_reasoning_train.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_rewrite_structured.sh b/scripts/run_rewrite_structured.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_rich_caption_probe.sh b/scripts/run_rich_caption_probe.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_unified_cfg4_test.sh b/scripts/run_unified_cfg4_test.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_v2_instr_filter_2jobs.sh b/scripts/run_v2_instr_filter_2jobs.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/run_watchdog_1h.sh b/scripts/run_watchdog_1h.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/sample_multiframe_4img_probe10.py b/scripts/sample_multiframe_4img_probe10.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/sample_multiframe_resample100.py b/scripts/sample_multiframe_resample100.py
+old mode 100644
+new mode 100755
+diff --git a/scripts/switch_current_to_machine_b.sh b/scripts/switch_current_to_machine_b.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_base_editlong_pico400k_train20k_bs2_lr1e5_vae_cache_zero2.sh b/scripts/train_4b_base_editlong_pico400k_train20k_bs2_lr1e5_vae_cache_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_full.sh b/scripts/train_4b_full.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_full_pico400k_opusstage2_long_train20k_bs2_lr1e5_jointtext_t0_zero2.sh b/scripts/train_4b_full_pico400k_opusstage2_long_train20k_bs2_lr1e5_jointtext_t0_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_cfgdrop0.sh b/scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_cfgdrop0.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_cfgdrop0_zero2.sh b/scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_cfgdrop0_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_jointtext_t0_zero2.sh b/scripts/train_4b_full_pico400k_short_train20k_bs2_lr1e5_jointtext_t0_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_full_pico400k_short_zero2_smoke.sh b/scripts/train_4b_full_pico400k_short_zero2_smoke.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_lora.sh b/scripts/train_4b_lora.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_4b_lora_moe_prodigy_pico400k_short_jointtext_t0_bs2_zero2.sh b/scripts/train_4b_lora_moe_prodigy_pico400k_short_jointtext_t0_bs2_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_base_editlong_pico400k_train20k_bs2_lr1e6_vae_cache_zero2.sh b/scripts/train_9b_base_editlong_pico400k_train20k_bs2_lr1e6_vae_cache_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_full.sh b/scripts/train_9b_full.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_full_direct_edit_baseline_zero2.sh b/scripts/train_9b_full_direct_edit_baseline_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_full_direct_edit_baseline_zero3.sh b/scripts/train_9b_full_direct_edit_baseline_zero3.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_full_pico400k_opusstage2_long_train20k_bs2_lr1e6_jointtext_t0_zero2.sh b/scripts/train_9b_full_pico400k_opusstage2_long_train20k_bs2_lr1e6_jointtext_t0_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_full_pico57k_corner10k_long_jointtext_zero2.sh b/scripts/train_9b_full_pico57k_corner10k_long_jointtext_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_full_pico57k_corner10k_long_jointtext_zero3.sh b/scripts/train_9b_full_pico57k_corner10k_long_jointtext_zero3.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_full_twoframe_lr5e6_zero2.sh b/scripts/train_9b_full_twoframe_lr5e6_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora.sh b/scripts/train_9b_lora.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_downstream_edit_combined_zero2.sh b/scripts/train_9b_lora_downstream_edit_combined_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_downstream_edit_phase2_zero2.sh b/scripts/train_9b_lora_downstream_edit_phase2_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_fluxfill_icedittargets_zero2.sh b/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_fluxfill_icedittargets_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_simpletuner_flux2targets_zero2.sh b/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_simpletuner_flux2targets_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_zero2.sh b/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_zero3.sh b/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_zero3.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_zero2.sh b/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_gc40k_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_nogc_zero2.sh b/scripts/train_9b_lora_moe_prodigy_finalmix80k_long_no_latent_nogc_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_moe_prodigy_finalmix80k_short_no_latent_nogc_zero2.sh b/scripts/train_9b_lora_moe_prodigy_finalmix80k_short_no_latent_nogc_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_moe_prodigy_pico400k_long_jointtext_t0_bs2_zero2.sh b/scripts/train_9b_lora_moe_prodigy_pico400k_long_jointtext_t0_bs2_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_pico57k_corner10k_long_jointtext_zero2.sh b/scripts/train_9b_lora_pico57k_corner10k_long_jointtext_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_smoke_zero2.sh b/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_smoke_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_zero2.sh b/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_textimgemb_full25k_zero2.sh b/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_textimgemb_full25k_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_zero2.sh b/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_v1_zero2.sh b/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_jointtext_t0_cache40k_bs1ga2_routing_v1_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_icedit6targets_zero2.sh b/scripts/train_9b_lora_standard_prodigy_finalmix80k_long_no_latent_gc40k_bs1ga2_icedit6targets_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_finalmix80k_short_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_node2_zero2.sh b/scripts/train_9b_lora_standard_prodigy_finalmix80k_short_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_node2_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_finalmix80k_short_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_zero2.sh b/scripts/train_9b_lora_standard_prodigy_finalmix80k_short_jointtext_t0_cache40k_bs1ga2_routing_render_mod_v2_gcfix_strictoff_full40k_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_9b_lora_standard_prodigy_pico400k_long_jointtext_t0_bs1ga2_icedit6targets_vae_cache_zero2.sh b/scripts/train_9b_lora_standard_prodigy_pico400k_long_jointtext_t0_bs1ga2_icedit6targets_vae_cache_zero2.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_exp_e_phase2_only.sh b/scripts/train_exp_e_phase2_only.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_exp_f_phase2_pico.sh b/scripts/train_exp_f_phase2_pico.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/train_exp_g_phase2_all.sh b/scripts/train_exp_g_phase2_all.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/wait_then_resume_m3ft60k.sh b/scripts/wait_then_resume_m3ft60k.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/wait_then_run_multiframe_4img_probe10.sh b/scripts/wait_then_run_multiframe_4img_probe10.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/watch_and_run_m3ft_sweep.sh b/scripts/watch_and_run_m3ft_sweep.sh
+old mode 100644
+new mode 100755
+diff --git a/scripts/watch_m3ft_35000_launch.sh b/scripts/watch_m3ft_35000_launch.sh
+old mode 100644
+new mode 100755
+diff --git a/train.py b/train.py
+index f7f193e..ab21282 100644
+--- a/train.py
++++ b/train.py
+@@ -5,6 +5,7 @@ import argparse
+ import inspect
+ import json
+ import os
++import random
+ import time
+ from pathlib import Path
+ 
+@@ -16,6 +17,11 @@ from torch.utils.data import DataLoader
+ from tqdm.auto import tqdm
+ 
+ from twoframe.data import TwoFrameEditingDataset, collate_fn
++from twoframe.data_bucketed import (
++    BucketedFrameDataset,
++    DistributedBucketBatchSampler,
++    bucketed_frame_collate_fn,
++)
+ from twoframe.data_multiframe import MultiFrameEditingDataset, multiframe_collate_fn
+ from twoframe.modeling import FluxKleinTwoFrame, count_parameters
+ 
+@@ -31,12 +37,24 @@ def apply_env_overrides(cfg: dict) -> dict:
+         cfg["training"]["mixed_precision"] = os.environ["MIXED_PRECISION"]
+     if os.getenv("GRADIENT_ACCUMULATION"):
+         cfg["training"]["gradient_accumulation_steps"] = int(os.environ["GRADIENT_ACCUMULATION"])
++    if os.getenv("PER_GPU_BATCH_SIZE"):
++        cfg["training"]["per_gpu_batch_size"] = int(os.environ["PER_GPU_BATCH_SIZE"])
+     if os.getenv("GRAD_CLIP"):
+         cfg["training"]["max_grad_norm"] = float(os.environ["GRAD_CLIP"])
+     if os.getenv("SAVE_EVERY"):
+         cfg["training"]["save_every"] = int(os.environ["SAVE_EVERY"])
++    if os.getenv("LOG_EVERY"):
++        cfg["training"]["log_every"] = int(os.environ["LOG_EVERY"])
+     if os.getenv("MAX_STEPS"):
+         cfg["training"]["max_steps"] = int(os.environ["MAX_STEPS"])
++    if os.getenv("LOAD_TRAINABLE_CHECKPOINT"):
++        cfg["training"]["load_trainable_checkpoint"] = os.environ["LOAD_TRAINABLE_CHECKPOINT"]
++    if os.getenv("RESUME_FROM"):
++        cfg["training"]["resume_from"] = os.environ["RESUME_FROM"]
++    if os.getenv("OUT"):
++        cfg["training"]["output_dir"] = os.environ["OUT"]
++    if os.getenv("OUTPUT_DIR"):
++        cfg["training"]["output_dir"] = os.environ["OUTPUT_DIR"]
+     return cfg
+ 
+ 
+@@ -140,6 +158,236 @@ def latest_checkpoint_path(ckpt_root: Path) -> Path | None:
+     return candidates[-1]
+ 
+ 
++def _dtype_from_name(name: str | None, default: torch.dtype = torch.bfloat16) -> torch.dtype:
++    key = str(name or "").strip().lower()
++    if key in {"fp16", "float16", "half"}:
++        return torch.float16
++    if key in {"fp32", "float32", "full"}:
++        return torch.float32
++    if key in {"bf16", "bfloat16"}:
++        return torch.bfloat16
++    return default
++
++
++def _is_ema_enabled(training_cfg: dict) -> bool:
++    ema_cfg = training_cfg.get("ema", None)
++    if isinstance(ema_cfg, dict):
++        return bool(ema_cfg.get("enabled", False))
++    if ema_cfg is not None:
++        return bool(ema_cfg)
++    return bool(training_cfg.get("use_ema", False))
++
++
++def _ema_cfg(training_cfg: dict) -> dict:
++    ema_cfg = training_cfg.get("ema", {})
++    if not isinstance(ema_cfg, dict):
++        ema_cfg = {"enabled": bool(ema_cfg)}
++    out = dict(ema_cfg)
++    if "enabled" not in out:
++        out["enabled"] = _is_ema_enabled(training_cfg)
++    if "decay" not in out and "ema_decay" in training_cfg:
++        out["decay"] = training_cfg["ema_decay"]
++    if "device" not in out and "ema_device" in training_cfg:
++        out["device"] = training_cfg["ema_device"]
++    if "dtype" not in out and "ema_dtype" in training_cfg:
++        out["dtype"] = training_cfg["ema_dtype"]
++    return out
++
++
++class TrainableEMA:
++    """EMA for components saved by FluxKleinTwoFrame.save_trainable().
++
++    EMA checkpoints are written as a parallel trainable directory containing
++    flow_model.safetensors and optional twoframe_aux.pt, so existing loading
++    code can use the EMA weights by pointing load_trainable_checkpoint at the
++    EMA directory.
++    """
++
++    def __init__(self, decay: float, device: torch.device, dtype: torch.dtype):
++        self.decay = float(decay)
++        self.device = device
++        self.dtype = dtype
++        self.num_updates = 0
++        self.transformer: dict[str, torch.Tensor] = {}
++        self.aux_tensors: dict[str, torch.Tensor] = {}
++
++    @staticmethod
++    def _tensor_for_ema(tensor: torch.Tensor, device: torch.device, dtype: torch.dtype) -> torch.Tensor:
++        target_dtype = dtype if tensor.is_floating_point() else tensor.dtype
++        return tensor.detach().to(device=device, dtype=target_dtype).clone()
++
++    @classmethod
++    def from_model(cls, model: FluxKleinTwoFrame, decay: float, device: torch.device, dtype: torch.dtype):
++        ema = cls(decay=decay, device=device, dtype=dtype)
++        ema.copy_from_model(model)
++        return ema
++
++    def copy_from_model(self, model: FluxKleinTwoFrame) -> None:
++        module = model.trainable_module
++        if hasattr(module, "module"):
++            module = module.module
++        self.transformer = {
++            key: self._tensor_for_ema(value, self.device, self.dtype)
++            for key, value in module.state_dict().items()
++        }
++        aux = model._extra_aux_state()
++        self.aux_tensors = {
++            key: self._tensor_for_ema(value, self.device, self.dtype)
++            for key, value in aux.items()
++            if isinstance(value, torch.Tensor)
++        }
++        self.num_updates = 0
++
++    def update(self, model: FluxKleinTwoFrame) -> None:
++        module = model.trainable_module
++        if hasattr(module, "module"):
++            module = module.module
++        one_minus_decay = 1.0 - self.decay
++        with torch.no_grad():
++            for key, value in module.state_dict().items():
++                if key not in self.transformer:
++                    self.transformer[key] = self._tensor_for_ema(value, self.device, self.dtype)
++                    continue
++                ema_value = self.transformer[key]
++                current = value.detach().to(device=ema_value.device, dtype=ema_value.dtype)
++                if ema_value.is_floating_point():
++                    ema_value.mul_(self.decay).add_(current, alpha=one_minus_decay)
++                else:
++                    ema_value.copy_(current)
++
++            aux = model._extra_aux_state()
++            for key, value in aux.items():
++                if not isinstance(value, torch.Tensor):
++                    continue
++                if key not in self.aux_tensors:
++                    self.aux_tensors[key] = self._tensor_for_ema(value, self.device, self.dtype)
++                    continue
++                ema_value = self.aux_tensors[key]
++                current = value.detach().to(device=ema_value.device, dtype=ema_value.dtype)
++                if ema_value.is_floating_point():
++                    ema_value.mul_(self.decay).add_(current, alpha=one_minus_decay)
++                else:
++                    ema_value.copy_(current)
++        self.num_updates += 1
++
++    def save(self, model: FluxKleinTwoFrame, output_dir: Path, metadata: dict | None = None) -> None:
++        from safetensors.torch import save_file as save_safetensors
++
++        output_dir.mkdir(parents=True, exist_ok=True)
++        transformer_cpu = {key: value.detach().cpu().contiguous() for key, value in self.transformer.items()}
++        torch.save(transformer_cpu, output_dir / "flow_model.pt")
++        save_safetensors(transformer_cpu, output_dir / "flow_model.safetensors")
++
++        aux = model._extra_aux_state()
++        aux_enabled = False
++        for key, value in self.aux_tensors.items():
++            aux[key] = value.detach().cpu().contiguous()
++            aux_enabled = True
++        if aux_enabled:
++            torch.save(aux, output_dir / "twoframe_aux.pt")
++            safe_aux = {key: value for key, value in aux.items() if isinstance(value, torch.Tensor)}
++            if safe_aux:
++                save_safetensors(safe_aux, output_dir / "twoframe_aux.safetensors")
++
++        meta = {
++            "checkpoint_type": "ema_full_transformer",
++            "ema_decay": self.decay,
++            "ema_num_updates": self.num_updates,
++            "raw_trainable_loader_compatible": True,
++            "aux_file": "twoframe_aux.pt" if aux_enabled else None,
++        }
++        if metadata:
++            meta.update(metadata)
++        with (output_dir / "twoframe_checkpoint_meta.json").open("w", encoding="utf-8") as f:
++            json.dump(meta, f, ensure_ascii=False, indent=2)
++
++
++def _move_to_device(value, device: torch.device):
++    if torch.is_tensor(value):
++        return value.to(device, non_blocking=True)
++    if isinstance(value, list):
++        return [_move_to_device(item, device) for item in value]
++    if isinstance(value, tuple):
++        return tuple(_move_to_device(item, device) for item in value)
++    if isinstance(value, dict):
++        return {key: _move_to_device(item, device) for key, item in value.items()}
++    return value
++
++
++def _build_bucketed_dataset(name: str, data_cfg: dict, common_cfg: dict) -> BucketedFrameDataset:
++    cfg = {**common_cfg, **dict(data_cfg)}
++    return BucketedFrameDataset(
++        manifest_path=cfg["manifest_path"],
++        num_sources=int(cfg["num_sources"]),
++        source_max_side=int(cfg["source_max_side"]),
++        target_max_side=int(cfg["target_max_side"]),
++        source_bucket_kind=str(cfg.get("source_bucket_kind", "source5")),
++        target_bucket_kind=str(cfg.get("target_bucket_kind", "target9")),
++        round_multiple=int(cfg.get("round_multiple", 32)),
++        bucket_cache_path=cfg.get("bucket_cache_path", None),
++        build_bucket_index=bool(cfg.get("build_bucket_index", False)),
++        skip_missing=bool(cfg.get("skip_missing", True)),
++        max_records=cfg.get("max_records", None),
++        source_image_field=str(cfg.get("source_image_field", "source_image")),
++        target_image_field=str(cfg.get("target_image_field", "target_image")),
++        source_caption_field=str(cfg.get("source_caption_field", "source_caption")),
++        source_caption_fallback_fields=_as_str_list(
++            cfg.get("source_caption_fallback_fields", ["source_caption"]),
++            default=["source_caption"],
++        ),
++        instruction_field=str(cfg.get("instruction_field", "instruction")),
++        instruction_fallback_fields=_as_str_list(
++            cfg.get("instruction_fallback_fields", ["edit_instruction_short", "edit_prompt_short", "text"]),
++            default=["edit_instruction_short", "edit_prompt_short", "text"],
++        ),
++    )
++
++
++def _stage_for_step(stages: list[dict], step: int) -> dict:
++    cursor = 0
++    for stage in stages:
++        cursor += int(stage["steps"])
++        if step < cursor:
++            return stage
++    return stages[-1]
++
++
++def _sample_weighted_key(weights: dict, rng: random.Random) -> str:
++    items = [(str(key), float(value)) for key, value in weights.items() if float(value) > 0]
++    if not items:
++        raise ValueError("No positive sampling weights configured.")
++    total = sum(weight for _, weight in items)
++    draw = rng.random() * total
++    running = 0.0
++    for key, weight in items:
++        running += weight
++        if draw <= running:
++            return key
++    return items[-1][0]
++
++
++def _dataset_key_for_stage(stage: dict, sampled_k: str) -> str:
++    dataset_map = stage.get("dataset_map", {})
++    if sampled_k in dataset_map:
++        return str(dataset_map[sampled_k])
++    return sampled_k
++
++
++def _sampled_k_from_dataset_key(dataset_key: str) -> str:
++    key = str(dataset_key)
++    if key.startswith("K1"):
++        return "K1"
++    if key.startswith("K2"):
++        return "K2"
++    if key.startswith("K3"):
++        return "K3"
++    return key
++
++
++def _stable_name_offset(name: str) -> int:
++    return sum((idx + 1) * ord(ch) for idx, ch in enumerate(str(name))) % 100000
++
++
+ def main():
+     parser = argparse.ArgumentParser()
+     parser.add_argument("--config", type=str, required=True)
+@@ -184,7 +432,59 @@ def main():
+         print("=" * 80)
+ 
+     dataset_type = str(cfg["data"].get("dataset_type", "twoframe")).strip().lower()
+-    if dataset_type == "multiframe":
++    mixed_loaders: dict[str, DataLoader] = {}
++    mixed_iters: dict[str, object] = {}
++    mixed_stages: list[dict] = []
++    if dataset_type == "mixed_bucketed":
++        data_common = dict(cfg["data"].get("common", {}))
++        data_common.setdefault("round_multiple", cfg["data"].get("round_multiple", 32))
++        data_common.setdefault("skip_missing", cfg["data"].get("skip_missing", True))
++        data_common.setdefault("build_bucket_index", cfg["data"].get("build_bucket_index", False))
++        dataset_cfgs = cfg["data"].get("datasets", {})
++        if not isinstance(dataset_cfgs, dict) or not dataset_cfgs:
++            raise ValueError("data.datasets must define bucketed datasets for dataset_type=mixed_bucketed.")
++
++        per_gpu_batch = int(cfg["training"].get("per_gpu_batch_size", 1))
++        for name, dataset_cfg in dataset_cfgs.items():
++            dataset = _build_bucketed_dataset(str(name), dataset_cfg, data_common)
++            sampler = DistributedBucketBatchSampler(
++                bucket_to_indices=dataset.bucket_to_indices,
++                batch_size=per_gpu_batch,
++                rank=accelerator.process_index,
++                world_size=accelerator.num_processes,
++                seed=int(cfg["training"].get("seed", 42)) + _stable_name_offset(str(name)),
++            )
++            loader = DataLoader(
++                dataset,
++                batch_sampler=sampler,
++                num_workers=int(cfg["data"].get("num_workers", 8)),
++                pin_memory=True,
++                collate_fn=bucketed_frame_collate_fn,
++                persistent_workers=bool(cfg["data"].get("persistent_workers", False))
++                and int(cfg["data"].get("num_workers", 8)) > 0,
++            )
++            mixed_loaders[str(name)] = loader
++            if accelerator.is_main_process:
++                print(
++                    f"bucketed dataset {name}: records={len(dataset):,} buckets={len(dataset.bucket_to_indices):,}"
++                )
++
++        mixed_stages = list(cfg.get("mixed_training", {}).get("stages", []))
++        if not mixed_stages:
++            raise ValueError("mixed_training.stages is required for dataset_type=mixed_bucketed.")
++        force_dataset_key = os.environ.get("FORCE_DATASET_KEY")
++        if force_dataset_key:
++            if force_dataset_key not in mixed_loaders:
++                raise ValueError(
++                    f"FORCE_DATASET_KEY={force_dataset_key!r} is not one of "
++                    f"{sorted(mixed_loaders.keys())!r}."
++                )
++            if accelerator.is_main_process:
++                print(f"forcing mixed dataset key for debug: {force_dataset_key}")
++        used_collate_fn = bucketed_frame_collate_fn
++        dataset = None
++        loader = None
++    elif dataset_type == "multiframe":
+         dataset = MultiFrameEditingDataset(
+             manifest_path=cfg["data"]["manifest_path"],
+             target_resolution=int(cfg["data"].get("target_resolution", 1024)),
+@@ -231,15 +531,16 @@ def main():
+             print("data mode: online VAE encoding from images")
+ 
+     per_gpu_batch = int(cfg["training"].get("per_gpu_batch_size", 1))
+-    loader = DataLoader(
+-        dataset,
+-        batch_size=per_gpu_batch,
+-        shuffle=True,
+-        num_workers=int(cfg["data"].get("num_workers", 8)),
+-        pin_memory=True,
+-        drop_last=True,
+-        collate_fn=used_collate_fn,
+-    )
++    if dataset_type != "mixed_bucketed":
++        loader = DataLoader(
++            dataset,
++            batch_size=per_gpu_batch,
++            shuffle=True,
++            num_workers=int(cfg["data"].get("num_workers", 8)),
++            pin_memory=True,
++            drop_last=True,
++            collate_fn=used_collate_fn,
++        )
+ 
+     dtype_name = cfg["training"].get("weight_dtype", "bf16").lower()
+     if dtype_name == "fp16":
+@@ -294,8 +595,22 @@ def main():
+         extra_embed_joint_policy=str(cfg["model"].get("extra_embed_joint_policy", "binary_full")),
+         extra_embed_zero_init=bool(cfg["model"].get("extra_embed_zero_init", True)),
+         extra_embed_strict_template=bool(cfg["model"].get("extra_embed_strict_template", True)),
++        image_frame_embed_slots=int(cfg["model"].get("image_frame_embed_slots", 2)),
++        multiframe_loss_mode=str(cfg["training"].get("multiframe_loss_mode", "frame_average")),
+     )
+ 
++    trainable_checkpoint = cfg["training"].get("load_trainable_checkpoint", None)
++    if trainable_checkpoint:
++        missing, unexpected = model.load_trainable_checkpoint(
++            trainable_checkpoint,
++            strict=bool(cfg["training"].get("load_trainable_strict", True)),
++        )
++        if accelerator.is_main_process:
++            print(
++                f"loaded trainable checkpoint: {trainable_checkpoint} "
++                f"missing={missing} unexpected={unexpected}"
++            )
++
+     total_params, trainable_params = count_parameters(model.trainable_module)
+     if accelerator.is_main_process:
+         print(f"model trainable module total params: {total_params:,}")
+@@ -319,10 +634,23 @@ def main():
+             lr_lambda=lambda step: min((step + 1) / max(1, warmup_steps), 1.0),
+         )
+ 
+-    if scheduler is None:
+-        model, optimizer, loader = accelerator.prepare(model, optimizer, loader)
++    if dataset_type == "mixed_bucketed":
++        if use_deepspeed and getattr(accelerator.state, "deepspeed_plugin", None) is not None:
++            ds_cfg = accelerator.state.deepspeed_plugin.deepspeed_config
++            ds_cfg["train_micro_batch_size_per_gpu"] = per_gpu_batch
++            ds_cfg["gradient_accumulation_steps"] = int(
++                cfg["training"].get("gradient_accumulation_steps", 1)
++            )
++        if scheduler is None:
++            model, optimizer = accelerator.prepare(model, optimizer)
++        else:
++            model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
++        mixed_iters = {}
+     else:
+-        model, optimizer, loader, scheduler = accelerator.prepare(model, optimizer, loader, scheduler)
++        if scheduler is None:
++            model, optimizer, loader = accelerator.prepare(model, optimizer, loader)
++        else:
++            model, optimizer, loader, scheduler = accelerator.prepare(model, optimizer, loader, scheduler)
+ 
+     if accelerator.is_main_process:
+         print(f"optimizer: {optimizer_name}")
+@@ -343,9 +671,27 @@ def main():
+             except Exception:
+                 start_step = 0
+ 
++    ema = None
++    ema_options = _ema_cfg(cfg["training"])
++    if bool(ema_options.get("enabled", False)):
++        ema_decay = float(ema_options.get("decay", 0.999))
++        ema_device_name = str(ema_options.get("device", "cuda")).strip().lower()
++        ema_device = accelerator.device if ema_device_name in {"cuda", "gpu", "accelerator"} else torch.device("cpu")
++        ema_dtype = _dtype_from_name(str(ema_options.get("dtype", cfg["training"].get("weight_dtype", "bf16"))))
++        if accelerator.is_main_process:
++            unwrapped = accelerator.unwrap_model(model)
++            ema = TrainableEMA.from_model(unwrapped, decay=ema_decay, device=ema_device, dtype=ema_dtype)
++            print(
++                f"EMA enabled: decay={ema_decay} device={ema_device} dtype={ema_dtype} "
++                "init=current_model",
++                flush=True,
++            )
++        accelerator.wait_for_everyone()
++
+     save_every = int(cfg["training"].get("save_every", 5000))
+     log_every = int(cfg["training"].get("log_every", 10))
+     grad_clip = float(cfg["training"].get("max_grad_norm", 1.0))
++    ema_dir_name = str(ema_options.get("save_dir_name", "trainable_ema"))
+ 
+     if accelerator.is_main_process and cfg["training"].get("log_with", None):
+         init_kwargs = {}
+@@ -359,7 +705,7 @@ def main():
+         )
+ 
+     step = start_step
+-    data_iter = iter(loader)
++    data_iter = None if dataset_type == "mixed_bucketed" else iter(loader)
+     progress = tqdm(total=max_steps, disable=not accelerator.is_main_process, initial=start_step)
+ 
+     running_loss = 0.0
+@@ -367,16 +713,42 @@ def main():
+     running_src = 0.0
+     running_count = 0
+     t_last = time.time()
++    micro_step = 0
++    last_batch_info: dict[str, str] = {}
+ 
+     while step < max_steps:
+-        try:
+-            batch = next(data_iter)
+-        except StopIteration:
+-            data_iter = iter(loader)
+-            batch = next(data_iter)
++        if dataset_type == "mixed_bucketed":
++            stage = _stage_for_step(mixed_stages, step)
++            rng = random.Random(int(cfg["training"].get("seed", 42)) + micro_step)
++            if force_dataset_key:
++                dataset_key = force_dataset_key
++                sampled_k = _sampled_k_from_dataset_key(dataset_key)
++            else:
++                sampled_k = _sample_weighted_key(stage["k_weights"], rng)
++                dataset_key = _dataset_key_for_stage(stage, sampled_k)
++            if dataset_key not in mixed_iters:
++                mixed_iters[dataset_key] = iter(mixed_loaders[dataset_key])
++            try:
++                batch = next(mixed_iters[dataset_key])
++            except StopIteration:
++                mixed_iters[dataset_key] = iter(mixed_loaders[dataset_key])
++                batch = next(mixed_iters[dataset_key])
++            batch = _move_to_device(batch, accelerator.device)
++            last_batch_info = {
++                "stage": str(stage.get("name", "")),
++                "sampled_k": sampled_k,
++                "dataset_key": dataset_key,
++                "bucket_key": str(batch.get("bucket_key", "")),
++            }
++        else:
++            try:
++                batch = next(data_iter)
++            except StopIteration:
++                data_iter = iter(loader)
++                batch = next(data_iter)
+ 
+         with accelerator.accumulate(model):
+-            if dataset_type == "multiframe":
++            if dataset_type in {"multiframe", "mixed_bucketed"}:
+                 out = model.forward_multiframe(
+                     pixel_values_sources=batch["pixel_values_sources"],
+                     pixel_values_target=batch["pixel_values_target"],
+@@ -407,10 +779,13 @@ def main():
+             if scheduler is not None:
+                 scheduler.step()
+             optimizer.zero_grad(set_to_none=True)
++        micro_step += 1
+ 
+         if accelerator.sync_gradients:
+             step += 1
+             progress.update(1)
++            if ema is not None:
++                ema.update(accelerator.unwrap_model(model))
+ 
+             loss_item = float(loss.detach().item())
+             tgt_item = float(out.loss_target.detach().item())
+@@ -443,6 +818,11 @@ def main():
+                     "grad_norm": grad_norm_val,
+                     "step_time_sec": dt / log_every,
+                 }
++                if ema is not None:
++                    payload["ema_decay"] = ema.decay
++                    payload["ema_updates"] = ema.num_updates
++                if last_batch_info:
++                    payload.update(last_batch_info)
+                 accelerator.print(json.dumps(payload, ensure_ascii=False))
+ 
+                 if cfg["training"].get("log_with", None):
+@@ -458,9 +838,18 @@ def main():
+                 if accelerator.is_main_process:
+                     unwrapped = accelerator.unwrap_model(model)
+                     unwrapped.save_trainable(str(ckpt_dir / "trainable"))
++                    if ema is not None:
++                        ema.save(
++                            unwrapped,
++                            ckpt_dir / ema_dir_name,
++                            metadata={"step": step, "source": "train.py"},
++                        )
+                     with open(output_dir / "latest_step.txt", "w", encoding="utf-8") as f:
+                         f.write(str(step))
+                     print(f"Saved checkpoint at step={step}: {ckpt_dir}")
++                    if ema is not None:
++                        print(f"Saved EMA checkpoint at step={step}: {ckpt_dir / ema_dir_name}")
++                accelerator.wait_for_everyone()
+ 
+     accelerator.wait_for_everyone()
+     if accelerator.is_main_process:
+diff --git a/twoframe/modeling.py b/twoframe/modeling.py
+index 8f00154..90308fe 100644
+--- a/twoframe/modeling.py
++++ b/twoframe/modeling.py
+@@ -10,6 +10,7 @@ from typing import Iterable, Sequence
+ import torch
+ import torch.nn as nn
+ from einops import rearrange
++from safetensors.torch import load_file as load_safetensors
+ from transformers import Qwen2TokenizerFast, Qwen3ForCausalLM
+ 
+ from .backbone import load_autoencoder, load_flow_model, normalize_model_size, repo_id_for, spec_for
+@@ -81,6 +82,8 @@ class FluxKleinTwoFrame(nn.Module):
+         extra_embed_joint_policy: str = "binary_full",
+         extra_embed_zero_init: bool = True,
+         extra_embed_strict_template: bool = True,
++        image_frame_embed_slots: int = 2,
++        multiframe_loss_mode: str = "frame_average",
+     ):
+         super().__init__()
+ 
+@@ -122,6 +125,15 @@ class FluxKleinTwoFrame(nn.Module):
+             )
+         self.extra_embed_zero_init = bool(extra_embed_zero_init)
+         self.extra_embed_strict_template = bool(extra_embed_strict_template)
++        self.image_frame_embed_slots = int(image_frame_embed_slots)
++        if self.image_frame_embed_slots < 2:
++            raise ValueError("image_frame_embed_slots must be >= 2.")
++        self.multiframe_loss_mode = str(multiframe_loss_mode).strip().lower()
++        if self.multiframe_loss_mode not in {"frame_average", "block_balanced"}:
++            raise ValueError(
++                f"Unsupported multiframe_loss_mode={multiframe_loss_mode}. "
++                "Choose from ['frame_average', 'block_balanced']."
++            )
+         self._warned_non_joint_extra = False
+         self.source_loss_weight = float(source_loss_weight)
+         self.target_loss_weight = float(target_loss_weight)
+@@ -231,7 +243,7 @@ class FluxKleinTwoFrame(nn.Module):
+         if use_image:
+             if in_channels <= 0:
+                 raise ValueError("Failed to detect transformer in_channels for image frame embedding.")
+-            self.image_frame_embed = nn.Embedding(2, in_channels)
++            self.image_frame_embed = nn.Embedding(self.image_frame_embed_slots, in_channels)
+             if self.extra_embed_zero_init:
+                 nn.init.zeros_(self.image_frame_embed.weight)
+ 
+@@ -518,7 +530,12 @@ class FluxKleinTwoFrame(nn.Module):
+     ) -> list[str]:
+         prompts: list[str] = []
+         for captions, instruction in zip(source_captions, instructions):
++            source_blocks = "\n\n".join(
++                f"[Source Image {idx}]\n{caption or f'reference image {idx}'}"
++                for idx, caption in enumerate(captions, start=1)
++            )
+             prompt = self.text_template
++            prompt = prompt.replace("{source_blocks}", source_blocks)
+             for idx, caption in enumerate(captions, start=1):
+                 prompt = prompt.replace(
+                     f"{{source{idx}_caption}}",
+@@ -678,18 +695,24 @@ class FluxKleinTwoFrame(nn.Module):
+ 
+     def forward_multiframe(
+         self,
+-        pixel_values_sources: torch.Tensor,
++        pixel_values_sources: torch.Tensor | list[torch.Tensor],
+         pixel_values_target: torch.Tensor,
+         source_captions_long: list[list[str]],
+         instructions: list[str],
+     ) -> TwoFrameLoss:
+         if self.text_mode != "joint":
+             raise ValueError("forward_multiframe currently supports only text_mode='joint'.")
+-        if pixel_values_sources.ndim != 5:
++        if isinstance(pixel_values_sources, torch.Tensor) and pixel_values_sources.ndim != 5:
+             raise ValueError(
+                 "pixel_values_sources must have shape (B,N,3,H,W), "
+                 f"got {tuple(pixel_values_sources.shape)}."
+             )
++        if isinstance(pixel_values_sources, list):
++            if not pixel_values_sources:
++                raise ValueError("pixel_values_sources list must not be empty.")
++            if any(tensor.ndim != 4 for tensor in pixel_values_sources):
++                shapes = [tuple(tensor.shape) for tensor in pixel_values_sources]
++                raise ValueError(f"source slot tensors must have shape (B,3,H,W), got {shapes}.")
+         if pixel_values_target.ndim != 4:
+             raise ValueError(
+                 "pixel_values_target must have shape (B,3,H,W), "
+@@ -708,7 +731,15 @@ class FluxKleinTwoFrame(nn.Module):
+                 f"expected C={expected_channels} (or C={expected_channels // 4} before patchify)."
+             )
+ 
+-        bsz, num_sources = pixel_values_sources.shape[:2]
++        if isinstance(pixel_values_sources, list):
++            bsz = pixel_values_target.shape[0]
++            num_sources = len(pixel_values_sources)
++            source_pixel_slots = pixel_values_sources
++            if any(tensor.shape[0] != bsz for tensor in source_pixel_slots):
++                raise ValueError("All source slot tensors must have the same batch size as target.")
++        else:
++            bsz, num_sources = pixel_values_sources.shape[:2]
++            source_pixel_slots = [pixel_values_sources[:, idx] for idx in range(num_sources)]
+         device = pixel_values_target.device
+         dtype = next(self.transformer.parameters()).dtype
+ 
+@@ -716,8 +747,8 @@ class FluxKleinTwoFrame(nn.Module):
+         target_latents = _ensure_transformer_latent_channels(target_latents.to(device=device), "target")
+ 
+         source_latents: list[torch.Tensor] = []
+-        for idx in range(num_sources):
+-            source_latent = self.encode_image_latents(pixel_values_sources[:, idx])
++        for idx, source_pixels in enumerate(source_pixel_slots):
++            source_latent = self.encode_image_latents(source_pixels)
+             source_latent = _ensure_transformer_latent_channels(
+                 source_latent.to(device=device),
+                 f"source[{idx}]",
+@@ -736,12 +767,16 @@ class FluxKleinTwoFrame(nn.Module):
+         packed_parts = [packed_target]
+         img_id_parts = [target_ids]
+         seq_lengths = [packed_target.shape[1]]
+-        source_noise_list: list[torch.Tensor] = []
++        source_noise_list: list[torch.Tensor | None] = []
+ 
+         for idx, source_latent in enumerate(source_latents):
+-            source_noise = torch.randn_like(source_latent)
++            if self.source_input_mode == "condition":
++                source_noise = None
++                source_noisy = source_latent
++            else:
++                source_noise = torch.randn_like(source_latent)
++                source_noisy = (1 - sigma_b) * source_latent + sigma_b * source_noise
+             source_noise_list.append(source_noise)
+-            source_noisy = (1 - sigma_b) * source_latent + sigma_b * source_noise
+             source_t_value = self.source_t + idx * self.source_t_step
+             packed_source, source_ids = pack_latents(source_noisy, t_value=source_t_value)
+             packed_parts.append(packed_source)
+@@ -788,13 +823,16 @@ class FluxKleinTwoFrame(nn.Module):
+         loss_target = torch.mean((pred_target_unpacked - target_vel) ** 2)
+ 
+         source_losses: list[torch.Tensor] = []
+-        for idx, (pred_source, source_ids, source_latent, source_noise) in enumerate(
+-            zip(pred_parts[1:], img_id_parts[1:], source_latents, source_noise_list)
+-        ):
+-            _ = idx
+-            pred_source_unpacked = unpack_latents(pred_source, source_ids)
+-            source_vel = source_noise - source_latent
+-            source_losses.append(torch.mean((pred_source_unpacked - source_vel) ** 2))
++        if self.source_input_mode != "condition":
++            for idx, (pred_source, source_ids, source_latent, source_noise) in enumerate(
++                zip(pred_parts[1:], img_id_parts[1:], source_latents, source_noise_list)
++            ):
++                _ = idx
++                if source_noise is None:
++                    raise RuntimeError("source_noise unexpectedly missing in denoise mode.")
++                pred_source_unpacked = unpack_latents(pred_source, source_ids)
++                source_vel = source_noise - source_latent
++                source_losses.append(torch.mean((pred_source_unpacked - source_vel) ** 2))
+ 
+         if source_losses:
+             source_losses_tensor = torch.stack(source_losses)
+@@ -803,16 +841,68 @@ class FluxKleinTwoFrame(nn.Module):
+             source_losses_tensor = None
+             loss_source = torch.zeros((), device=loss_target.device, dtype=loss_target.dtype)
+ 
+-        weighted_target = self.target_loss_weight * loss_target
+-        weighted_source = (
+-            self.source_loss_weight * source_losses_tensor.sum()
+-            if source_losses_tensor is not None
+-            else torch.zeros((), device=loss_target.device, dtype=loss_target.dtype)
+-        )
+-        normalizer = self.target_loss_weight + self.source_loss_weight * len(source_latents)
+-        loss = (weighted_target + weighted_source) / max(normalizer, 1e-8)
++        if self.multiframe_loss_mode == "block_balanced":
++            loss = self.target_loss_weight * loss_target + self.source_loss_weight * loss_source
++        else:
++            weighted_target = self.target_loss_weight * loss_target
++            weighted_source = (
++                self.source_loss_weight * source_losses_tensor.sum()
++                if source_losses_tensor is not None
++                else torch.zeros((), device=loss_target.device, dtype=loss_target.dtype)
++            )
++            normalizer = self.target_loss_weight + self.source_loss_weight * len(source_latents)
++            loss = (weighted_target + weighted_source) / max(normalizer, 1e-8)
+         return TwoFrameLoss(loss=loss, loss_target=loss_target, loss_source=loss_source)
+ 
++    def load_trainable_checkpoint(self, checkpoint: str | Path, strict: bool = True) -> tuple[int, int]:
++        path = Path(checkpoint).expanduser().resolve()
++        if not path.exists():
++            raise FileNotFoundError(f"Trainable checkpoint not found: {path}")
++        if path.is_dir():
++            candidates = [
++                path / "flow_model.safetensors",
++                path / "flow_model.pt",
++                path / "pytorch_model.bin",
++            ]
++            file_path = next((candidate for candidate in candidates if candidate.exists()), None)
++            if file_path is None:
++                raise FileNotFoundError(
++                    f"No trainable checkpoint found in {path}; expected flow_model.safetensors or flow_model.pt."
++                )
++            base_dir = path
++        else:
++            file_path = path
++            base_dir = path.parent
++
++        if file_path.suffix == ".safetensors":
++            state_dict = load_safetensors(str(file_path), device="cpu")
++        else:
++            raw = torch.load(file_path, map_location="cpu")
++            state_dict = raw.get("state_dict", raw) if isinstance(raw, dict) else raw
++        missing, unexpected = self.transformer.load_state_dict(state_dict, strict=strict)
++
++        aux_path = base_dir / "twoframe_aux.pt"
++        if aux_path.exists():
++            aux = torch.load(aux_path, map_location="cpu")
++            if self.text_segment_embed is not None and "text_segment_embed.weight" in aux:
++                self._copy_embedding_weight(self.text_segment_embed, aux["text_segment_embed.weight"])
++            if self.image_frame_embed is not None and "image_frame_embed.weight" in aux:
++                self._copy_embedding_weight(self.image_frame_embed, aux["image_frame_embed.weight"])
++        return len(missing), len(unexpected)
++
++    @staticmethod
++    def _copy_embedding_weight(module: nn.Embedding, weight: torch.Tensor) -> None:
++        rows = min(module.weight.shape[0], weight.shape[0])
++        cols = min(module.weight.shape[1], weight.shape[1])
++        with torch.no_grad():
++            module.weight[:rows, :cols].copy_(weight[:rows, :cols].to(module.weight.device, module.weight.dtype))
++            if module.weight.shape[0] > rows and rows > 0:
++                for row in range(rows, module.weight.shape[0]):
++                    source_row = min(row, rows - 1)
++                    module.weight[row, :cols].copy_(
++                        weight[source_row, :cols].to(module.weight.device, module.weight.dtype)
++                    )
++
+     def _extra_aux_state(self) -> dict[str, torch.Tensor | str | bool]:
+         state: dict[str, torch.Tensor | str | bool] = {
+             "format_version": "v1",
+@@ -909,11 +999,13 @@ class FluxKleinTwoFrame(nn.Module):
+             "extra_embeddings": {
+                 "mode": self.extra_embed_mode,
+                 "policy": self.extra_embed_joint_policy,
++                "image_frame_embed_slots": self.image_frame_embed_slots,
+                 "enabled_text": self.text_segment_embed is not None,
+                 "enabled_image": self.image_frame_embed is not None,
+                 "strict_template": self.extra_embed_strict_template,
+                 "aux_file": "twoframe_aux.pt" if aux_enabled else None,
+             },
++            "multiframe_loss_mode": self.multiframe_loss_mode,
+         }
+         with Path(output_dir, "twoframe_checkpoint_meta.json").open("w", encoding="utf-8") as f:
+             json.dump(meta, f, ensure_ascii=False, indent=2)
+diff --git a/twoframe/native_inference.py b/twoframe/native_inference.py
+index 8551951..e17122e 100644
+--- a/twoframe/native_inference.py
++++ b/twoframe/native_inference.py
+@@ -122,6 +122,7 @@ class Flux2NativeEngine:
+         policy: str = "binary_full",
+         strict_template: bool = True,
+         zero_init: bool = True,
++        image_slots: int = 2,
+     ) -> None:
+         norm_mode = self._normalize_extra_embed_mode(mode)
+         policy = str(policy).strip().lower()
+@@ -154,7 +155,7 @@ class Flux2NativeEngine:
+             image_dim = int(getattr(self.flow, "in_channels", 0))
+             if image_dim <= 0:
+                 raise ValueError("Failed to infer in_channels for image frame embedding.")
+-            self.image_frame_embed = torch.nn.Embedding(2, image_dim).to(
++            self.image_frame_embed = torch.nn.Embedding(int(image_slots), image_dim).to(
+                 device=self.device,
+                 dtype=self.dtype,
+             )
+@@ -338,12 +339,16 @@ class Flux2NativeEngine:
+         elif "image_frame_embed.weight" in aux_state:
+             if mode == "none":
+                 mode = "image_only"
++        image_slots = 2
++        if "image_frame_embed.weight" in aux_state:
++            image_slots = int(aux_state["image_frame_embed.weight"].shape[0])
+ 
+         self.configure_extra_embeddings(
+             mode=mode,
+             policy=policy,
+             strict_template=strict_template,
+             zero_init=False,
++            image_slots=image_slots,
+         )
+ 
+         if self.text_segment_embed is not None and "text_segment_embed.weight" in aux_state:

model_cache_code_step8000/metadata/TwoFrame.untracked_files.txt

@@ -0,0 +1,40 @@
+configs/accelerate_8gpu_zero2_ga2.yaml
+configs/flux_klein9b_mixed_bucketed_editor_only_ma034235_ma79931_ucsf.yaml
+configs/flux_klein9b_mixed_bucketed_joint_ema_resume_ucsf.yaml
+configs/flux_klein9b_mixed_bucketed_ma034235_ma79931_ucsf.yaml
+docs/TWOFRAME_DATA_ENGINE.md
+docs/UCSF_EVAL_EXPERIMENT_TRACKER.md
+scripts/analyze_ma034235_manifest_filter.py
+scripts/analyze_ma034235_manifest_filter_ucsf.sbatch
+scripts/build_bucket_cache.py
+scripts/build_mixed_bucket_caches_h200_ucsf.sbatch
+scripts/build_mixed_bucket_caches_ucsf.sbatch
+scripts/build_multiref_condition_manifest_from_outputs.py
+scripts/check_bucketed_dataloader.py
+scripts/eval_generate_single_gpu_ucsf.sbatch
+scripts/hold_h200_allocation_ucsf.sbatch
+scripts/infer_multiref_condition_editor.py
+scripts/infer_twoframe_data_engine.py
+scripts/launch_twoframe_data_engine_ctmux_ucsf.sh
+scripts/prepare_ucsf_eval_manifests.py
+scripts/run_multiref_backfill_queue_ucsf.sh
+scripts/run_multiref_condition_editor_inalloc_8g_ucsf.sh
+scripts/run_singleref_condition_baselines_inalloc_8g_ucsf.sh
+scripts/run_singleref_pair_metrics_8gpu_ucsf.sbatch
+scripts/run_singleref_pair_metrics_ucsf.sbatch
+scripts/run_twoframe_data_engine_inalloc_ucsf.sh
+scripts/run_wandb_login_tail_both_loop_ucsf.sh
+scripts/run_wandb_login_tail_both_persistent_ucsf.sh
+scripts/run_wandb_login_tail_loop_ucsf.sh
+scripts/run_wandb_login_tail_ucsf.sh
+scripts/srun_in_h200_allocation_ucsf.sh
+scripts/tail_train_log_to_wandb.py
+scripts/tail_train_log_to_wandb_ucsf.sbatch
+scripts/train_mixed_bucketed_editor_only_ucsf.sbatch
+scripts/train_mixed_bucketed_joint_ema_resume_ucsf.sbatch
+scripts/train_mixed_bucketed_joint_ucsf.sbatch
+scripts/train_mixed_bucketed_ucsf.sbatch
+scripts/verify_mixed_bucket_caches_ucsf.sbatch
+scripts/verify_mixed_bucket_caches_ucsf.sh
+scripts/wait_then_run_multiref_condition_baselines_ucsf.sh
+twoframe/data_bucketed.py

model_cache_code_step8000/metadata/asset_manifest.json

@@ -0,0 +1,31 @@
+{
+  "package": "/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252",
+  "package_type": "model_reproducibility_bundle",
+  "created_or_updated": "2026-05-23 10:25:38 PDT",
+  "training_run": "/scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532",
+  "last_complete_step": 8000,
+  "target_steps": 9000,
+  "status_note": "2-day Slurm allocation ended after step 8016; last complete checkpoint pair is step 8000.",
+  "checkpoints": {
+    "non_ema_consolidated": "checkpoints/checkpoint-8000/transformer/diffusion_pytorch_model.safetensors",
+    "ema": "checkpoints/ema_checkpoint-8000/diffusion_pytorch_model.safetensors",
+    "distributed_resume_state": "checkpoints/checkpoint-8000/distributed_checkpoint/"
+  },
+  "derived_cache": {
+    "source_path": "/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin",
+    "archive_parts": "cache/wan22_pants_v2_softwin.tar.zst.part-*",
+    "source_train_rows": 53784,
+    "contains": [
+      "vae_latents",
+      "text_embeddings",
+      "captions",
+      "embedded_caption_manifests",
+      "manifests"
+    ]
+  },
+  "raw_data_package": "/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_raw_train_test_20260523_102411",
+  "raw_data_source_path": "/scratch/user/yuhwang/dataset/PanTS",
+  "code_snapshot": "code/twoframe_fastvideo_code_snapshot.tar.zst",
+  "base_model_path": "/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged",
+  "base_model_note": "Base model binaries are not duplicated here; symlink map is in metadata/base_model_symlinks.txt."
+}

model_cache_code_step8000/metadata/base_model_symlinks.txt

@@ -0,0 +1,9 @@
+BASE=/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged
+BASE_READLINK=/mnt/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged
+d 4096 /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged -> 
+l 132 /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/vae -> /scratch/user/yuhwang/model/hf-cache/models--Wan-AI--Wan2.2-TI2V-5B-Diffusers/snapshots/b8fff7315c768468a5333511427288870b2e9635/vae
+l 145 /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/model_index.json -> /scratch/user/yuhwang/model/hf-cache/models--Wan-AI--Wan2.2-TI2V-5B-Diffusers/snapshots/b8fff7315c768468a5333511427288870b2e9635/model_index.json
+l 67 /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/scheduler -> /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-text/scheduler
+l 67 /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/tokenizer -> /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-text/tokenizer
+l 70 /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/text_encoder -> /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-text/text_encoder
+l 76 /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged/transformer -> /scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-transformer/transformer

model_cache_code_step8000/metadata/cache_summary.json

@@ -0,0 +1,38 @@
+{
+  "cache_root": "/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin",
+  "source_train_jsonl": "/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin/captions_embedded/source_train.jsonl",
+  "exists": true,
+  "rows": 53784,
+  "keys": {
+    "bucket_id": 53784,
+    "caption": 53784,
+    "caption_key": 53784,
+    "caption_template": 53784,
+    "case_id": 53784,
+    "dit_tokens": 53784,
+    "fov": 53784,
+    "id": 53784,
+    "latent_path": 53784,
+    "latent_shape": 53784,
+    "lesion_present": 53784,
+    "phase": 53784,
+    "pixel_shape_zyx": 53784,
+    "source_split": 53784,
+    "target_spacing_zyx": 53784,
+    "text_embedding_dtype": 53784,
+    "text_embedding_path": 53784,
+    "text_embedding_shape": 53784,
+    "text_token_count": 53784,
+    "view": 53784,
+    "window_hu": 53784,
+    "window_mode": 53784
+  },
+  "bucket_id_counts": {
+    "B-whole": 21690,
+    "B-CA": 11365,
+    "B-CAP": 10980,
+    "P-pan": 8784,
+    "B-abd-pelvis": 490,
+    "B-abd": 475
+  }
+}

model_cache_code_step8000/metadata/package_du.txt

@@ -0,0 +1 @@
+161G	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252

model_cache_code_step8000/metadata/package_filelist.tsv

@@ -0,0 +1,44 @@
+21474836480	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/wan22_pants_v2_softwin.tar.zst.part-002
+21474836480	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/wan22_pants_v2_softwin.tar.zst.part-001
+21474836480	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/wan22_pants_v2_softwin.tar.zst.part-000
+19999235584	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/ema_checkpoint-8000/diffusion_pytorch_model.safetensors
+19999235584	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/transformer/diffusion_pytorch_model.safetensors
+7936917186	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/wan22_pants_v2_softwin.tar.zst.part-003
+7579283472	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/__6_0.distcp
+7579281895	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/__7_0.distcp
+7579280381	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/__0_0.distcp
+7579267765	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/__4_0.distcp
+7427175972	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/__2_0.distcp
+7426960230	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/__5_0.distcp
+7422377654	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/__3_0.distcp
+7421581100	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/__1_0.distcp
+160328081	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/code/twoframe_fastvideo_code_snapshot.tar.zst
+85917696	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/logs/tracker/wandb/offline-run-20260519_215609-2dcsowl9/run-2dcsowl9.wandb
+4289477	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/distributed_checkpoint/.metadata
+2011580	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/logs/train.log
+427900	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/logs/gpu_monitor.log
+74115	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/TwoFrame.uncommitted.diff
+16303	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/logs/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug.log
+9667	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/TwoFrame.git_status.txt
+9446	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/FastVideo.uncommitted.diff
+3933	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/package_tree_depth3.txt
+2674	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/README.md
+2195	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/logs/tracker/wandb/offline-run-20260519_215609-2dcsowl9/files/requirements.txt
+2169	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/CODE_USAGE.md
+1960	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/train_health.json
+1863	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/TwoFrame.untracked_files.txt
+1806	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/DATA_ASSETS.md
+1608	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/asset_manifest.json
+1538	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/HF_UPLOAD.md
+1276	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/train_args.json
+1259	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/logs/tracker/wandb/offline-run-20260519_215609-2dcsowl9/logs/debug-internal.log
+1253	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/base_model_symlinks.txt
+1024	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/cache_summary.json
+503	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/checkpoint-8000/transformer/config.json
+317	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/UPLOAD_NOTES.md
+195	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/FastVideo.git_status.txt
+148	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/RESTORE.txt
+100	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/package_du.txt
+42	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/FastVideo.untracked_files.txt
+0	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/package_filelist.tsv
+0	/scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/PACKAGE_COMPLETE

model_cache_code_step8000/metadata/package_tree_depth3.txt

@@ -0,0 +1,30 @@
+2026-05-21 15:45  19999235584 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/checkpoints/ema_checkpoint-8000/diffusion_pytorch_model.safetensors
+2026-05-21 15:53       427900 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/logs/gpu_monitor.log
+2026-05-21 15:53      2011580 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/logs/train.log
+2026-05-23 10:03           42 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/FastVideo.untracked_files.txt
+2026-05-23 10:03          195 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/FastVideo.git_status.txt
+2026-05-23 10:03         1024 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/cache_summary.json
+2026-05-23 10:03         1253 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/base_model_symlinks.txt
+2026-05-23 10:03         1276 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/train_args.json
+2026-05-23 10:03         1863 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/TwoFrame.untracked_files.txt
+2026-05-23 10:03         1960 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/train_health.json
+2026-05-23 10:03         9446 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/FastVideo.uncommitted.diff
+2026-05-23 10:03         9667 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/TwoFrame.git_status.txt
+2026-05-23 10:03        74115 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/TwoFrame.uncommitted.diff
+2026-05-23 10:03    160328081 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/code/twoframe_fastvideo_code_snapshot.tar.zst
+2026-05-23 10:05  21474836480 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/wan22_pants_v2_softwin.tar.zst.part-000
+2026-05-23 10:06  21474836480 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/wan22_pants_v2_softwin.tar.zst.part-001
+2026-05-23 10:07  21474836480 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/wan22_pants_v2_softwin.tar.zst.part-002
+2026-05-23 10:08          148 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/RESTORE.txt
+2026-05-23 10:08          317 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/UPLOAD_NOTES.md
+2026-05-23 10:08   7936917186 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/cache/wan22_pants_v2_softwin.tar.zst.part-003
+2026-05-23 10:11            0 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/PACKAGE_COMPLETE
+2026-05-23 10:25         1538 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/HF_UPLOAD.md
+2026-05-23 10:25         1608 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/asset_manifest.json
+2026-05-23 10:25         1806 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/DATA_ASSETS.md
+2026-05-23 10:25         2169 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/CODE_USAGE.md
+2026-05-23 10:25         2674 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/README.md
+2026-05-23 10:26         6382 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/package_filelist.tsv
+2026-05-23 10:28            0 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/package_tree_depth3.txt
+2026-05-23 10:28          100 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/metadata/package_du.txt
+2026-05-23 10:28         8971 /scratch/user/yuhwang/artifacts/twoframe/hf_upload/pants_wan22_b16_9k_step8000_20260523_100252/SHA256SUMS.txt

model_cache_code_step8000/metadata/train_args.json

@@ -0,0 +1,38 @@
+{
+  "data_path": "/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin",
+  "dataloader_num_workers": 2,
+  "num_height": 320,
+  "num_width": 288,
+  "num_frames": 153,
+  "train_batch_size": 16,
+  "num_latent_t": 39,
+  "pretrained_model_name_or_path": "/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged",
+  "ema_decay": 0.999,
+  "ema_start_step": 1,
+  "training_cfg_rate": 0.05,
+  "tracker_project_name": "pants_wan22_fullrep",
+  "wandb_run_name": "pants_b16_9k_20260519_215532",
+  "output_dir": "/scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532",
+  "checkpoints_total_limit": 2,
+  "training_state_checkpointing_steps": 4000,
+  "max_train_steps": 9000,
+  "gradient_accumulation_steps": 1,
+  "learning_rate": 1e-06,
+  "lr_scheduler": "constant",
+  "lr_warmup_steps": 0,
+  "max_grad_norm": 1.0,
+  "enable_gradient_checkpointing_type": "full",
+  "mixed_precision": "bf16",
+  "train_sp_batch_size": 1,
+  "num_euler_timesteps": 50,
+  "weight_decay": 0.01,
+  "use_ema": true,
+  "model_path": "/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged",
+  "inference_mode": false,
+  "num_gpus": 8,
+  "tp_size": 1,
+  "sp_size": 1,
+  "hsdp_replicate_dim": 8,
+  "hsdp_shard_dim": 1,
+  "dit_precision": "fp32"
+}

model_cache_code_step8000/metadata/train_health.json

@@ -0,0 +1,22 @@
+{
+  "max_step_seen": 8016,
+  "target_steps_seen": 9000,
+  "traceback_count": 0,
+  "oom_count": 0,
+  "runtime_error_count": 0,
+  "nan_count": 0,
+  "last_checkpoint_lines": [
+    "INFO 05-20 15:26:04.480 [training_pipeline.py:515] Saved EMA transformer weights to /scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532/ema_checkpoint-4000",
+    "INFO 05-21 15:44:03.254 [training_utils.py:144] rank: 0, distributed checkpoint saved in 16.53 seconds",
+    "INFO 05-21 15:44:03.256 [training_utils.py:144] rank: 5, distributed checkpoint saved in 25.37 seconds",
+    "INFO 05-21 15:44:03.258 [training_utils.py:144] rank: 4, distributed checkpoint saved in 25.46 seconds",
+    "INFO 05-21 15:44:03.259 [training_utils.py:144] rank: 1, distributed checkpoint saved in 15.65 seconds",
+    "INFO 05-21 15:44:03.264 [training_utils.py:144] rank: 3, distributed checkpoint saved in 15.38 seconds",
+    "INFO 05-21 15:44:03.265 [training_utils.py:144] rank: 6, distributed checkpoint saved in 25.33 seconds",
+    "INFO 05-21 15:44:04.142 [training_utils.py:144] rank: 7, distributed checkpoint saved in 16.38 seconds",
+    "INFO 05-21 15:44:04.184 [training_utils.py:144] rank: 2, distributed checkpoint saved in 26.32 seconds",
+    "INFO 05-21 15:44:51.122 [training_utils.py:161] rank: 0, consolidated checkpoint saved to /scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532/checkpoint-8000/transformer/diffusion_pytorch_model.safetensors",
+    "INFO 05-21 15:44:51.127 [training_utils.py:171] --> checkpoint saved at step 8000 to /scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532/checkpoint-8000/transformer/diffusion_pytorch_model.safetensors",
+    "INFO 05-21 15:45:42.653 [training_pipeline.py:515] Saved EMA transformer weights to /scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune/pants_b16_9k_20260519_215532/ema_checkpoint-8000"
+  ]
+}

raw_pants_train_test/metadata/pants-captions-ldm/audit/resolution_analysis_20260519_8h200/resolution_report.md

@@ -0,0 +1,66 @@
+# PanTS Raw Resolution Analysis
+
+Generated on `2026-05-19 16:18:46 PDT` inside allocation `524904` on `ggpu3-13`.
+
+## Integrity
+- Cases parsed from metadata: **9901**
+- Split counts: `{'val': 819, 'train': 8181, 'test': 901}`
+- FOV counts: `{'chest_abdomen': 2454, 'chest_abdomen_pelvis': 2624, 'whole_body': 4618, 'abdomen_pelvis': 100, 'abdomen_only': 105}`
+- CT header mismatches vs metadata: **0**
+- Label header mismatches vs CT headers: **0**
+- Header read errors: **0**
+
+## Overall Distributions
+| metric | n | min | p5 | p25 | p50 | p75 | p95 | p99 | max |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| shape_x_vox | 9901 | 29 | 151 | 443 | 497 | 512 | 512 | 589 | 1.06e+03 |
+| shape_y_vox | 9901 | 48 | 164 | 308 | 361 | 403 | 457 | 493 | 547 |
+| shape_z_slices | 9901 | 8 | 61 | 128 | 190 | 222 | 343 | 391 | 1.06e+03 |
+| spacing_x_mm | 9901 | 0.423 | 0.637 | 0.742 | 0.809 | 0.977 | 1.5 | 5 | 5 |
+| spacing_y_mm | 9901 | 0.393 | 0.641 | 0.738 | 0.797 | 0.949 | 1.5 | 1.5 | 5 |
+| spacing_z_mm | 9901 | 0.363 | 0.781 | 0.8 | 1.25 | 2.5 | 5 | 5 | 10 |
+| phys_x_mm | 9901 | 70.5 | 294 | 349 | 380 | 416 | 499 | 512 | 1.42e+03 |
+| phys_y_mm | 9901 | 72 | 217 | 255 | 285 | 320 | 377 | 412 | 500 |
+| phys_z_mm | 9901 | 6.4 | 138 | 172 | 212 | 332 | 505 | 690 | 860 |
+| voxel_count_M | 9901 | 0.379 | 4.69 | 14.4 | 29.3 | 43.2 | 57.6 | 90.5 | 240 |
+
+## FOV Groups
+| fov | n | z slices p50/p95 | z spacing p50/p95 mm | physical Z p50/p95 mm | physical XY p50 mm | voxel count p50/p95 M |
+|---|---:|---:|---:|---:|---:|---:|
+| abdomen_only | 105 | 125/221 | 1.50/1.50 | 153.0/199.2 | 325.5 x 243.9 | 5.1/44.5 |
+| abdomen_pelvis | 100 | 150/228 | 1.50/5.00 | 221.0/329.1 | 357.8 x 247.5 | 5.8/36.4 |
+| chest_abdomen | 2454 | 200/251 | 0.80/5.00 | 180.0/304.5 | 364.5 x 278.7 | 36.0/53.1 |
+| chest_abdomen_pelvis | 2624 | 154/358 | 1.50/5.00 | 250.5/390.0 | 391.0 x 294.4 | 21.4/79.7 |
+| whole_body | 4618 | 204/353 | 1.00/5.00 | 226.1/627.0 | 385.2 x 286.5 | 31.6/57.2 |
+
+## Existing Bucket Coverage If Full-Volume Buckets Are Used
+| bucket | n | crop any % | crop z/y/x % | physical Z p50/p95/max mm | physical Y p95/max mm | physical X p95/max mm | resampled shape p95 z/y/x vox |
+|---|---:|---:|---:|---:|---:|---:|---:|
+| B-CA | 2454 | 6.7 | 6.7/0.0/0.0 | 180.0/304.5/820.0 | 359.9/461.1 | 447.1/512.0 | 87/180/224 |
+| B-CAP | 2624 | 12.2 | 12.2/0.0/0.0 | 250.5/390.0/720.0 | 390.2/499.5 | 472.0/512.0 | 98/195/236 |
+| B-abd | 105 | 8.6 | 8.6/0.0/0.0 | 153.0/199.2/358.5 | 337.5/370.5 | 399.8/480.0 | 66/169/200 |
+| B-abd-pelvis | 100 | 58.0 | 58.0/0.0/0.0 | 221.0/329.1/510.0 | 356.8/394.5 | 459.5/496.1 | 110/178/230 |
+| B-whole | 4618 | 6.0 | 4.4/0.0/1.8 | 226.1/627.0/860.0 | 371.6/498.0 | 512.0/1416.0 | 125/186/256 |
+
+## Pancreas BBox For B-pan
+- Cases with pancreas bbox: **9442**
+- 40 mm padded bbox fit rate into B-pan coverage `(Z,Y,X)=(128,192,256) mm`: **8.2%**
+- Over target by axis X/Y/Z: **8.5% / 2.6% / 87.8%**
+
+| metric | n | min | p5 | p25 | p50 | p75 | p95 | p99 | max |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| bbox_x_mm | 9442 | 0 | 81 | 118 | 136 | 152 | 193 | 468 | 875 |
+| bbox_y_mm | 9442 | 0 | 41.7 | 59.6 | 71.4 | 83.4 | 104 | 123 | 190 |
+| bbox_z_mm | 9442 | 0 | 19.5 | 66 | 80 | 90 | 109 | 146 | 452 |
+| padded_x_mm | 9442 | 80 | 161 | 198 | 216 | 232 | 273 | 548 | 955 |
+| padded_y_mm | 9442 | 80 | 122 | 140 | 151 | 163 | 184 | 203 | 270 |
+| padded_z_mm | 9442 | 80 | 99.5 | 146 | 160 | 170 | 189 | 226 | 532 |
+
+## Initial Read
+- The native in-plane spacing is comparatively tight and less variable than z spacing; z spacing and z slice count carry most of the diversity.
+- A single full-volume grid would either waste memory on thin-slice studies or crop thick-FOV studies. Bucket by physical FOV first, then by z-spacing/coverage within FOV.
+- `B-pan` is a much more stable target than whole-volume buckets, but the current 40 mm pad plus 128 mm Z coverage should be treated as a policy choice, not assumed universal.
+
+## Artifacts
+- CSV: `/scratch/user/yuhwang/dataset/pants-captions-ldm/audit/resolution_analysis_20260519_8h200/resolution_records.csv`
+- JSON: `/scratch/user/yuhwang/dataset/pants-captions-ldm/audit/resolution_analysis_20260519_8h200/resolution_summary.json`

raw_pants_train_test/metadata/pants-captions-ldm/audit/resolution_analysis_20260519_8h200/resolution_summary.json

@@ -0,0 +1,2014 @@
+{
+  "generated_at": "2026-05-19 16:18:46 PDT",
+  "n_records": 9901,
+  "meta_bad_ids": [],
+  "ct_header_mismatch_count": 0,
+  "ct_header_mismatch_examples": [],
+  "label_header_mismatch_count": 0,
+  "label_header_mismatch_examples": [],
+  "header_error_count": 0,
+  "header_error_examples": [],
+  "split_counts": {
+    "val": 819,
+    "train": 8181,
+    "test": 901
+  },
+  "fov_counts": {
+    "chest_abdomen": 2454,
+    "chest_abdomen_pelvis": 2624,
+    "whole_body": 4618,
+    "abdomen_pelvis": 100,
+    "abdomen_only": 105
+  },
+  "phase_counts": {
+    "Non-contrast": 4485,
+    "Venous": 2897,
+    "Arterial": 2450,
+    "unknown": 1,
+    "Delay": 68
+  },
+  "lesion_counts": {
+    "False": 8943,
+    "True": 958
+  },
+  "overall": {
+    "n": 9901,
+    "shape_x": {
+      "n": 9901,
+      "p0": 29.0,
+      "p1": 66.0,
+      "p5": 151.0,
+      "p10": 230.0,
+      "p25": 443.0,
+      "p50": 497.0,
+      "p75": 512.0,
+      "p90": 512.0,
+      "p95": 512.0,
+      "p99": 589.0,
+      "p100": 1059.0,
+      "mean": 442.3113826886173
+    },
+    "shape_y": {
+      "n": 9901,
+      "p0": 48.0,
+      "p1": 120.0,
+      "p5": 164.0,
+      "p10": 200.0,
+      "p25": 308.0,
+      "p50": 361.0,
+      "p75": 403.0,
+      "p90": 437.0,
+      "p95": 457.0,
+      "p99": 493.0,
+      "p100": 547.0,
+      "mean": 345.04029895970103
+    },
+    "shape_z": {
+      "n": 9901,
+      "p0": 8.0,
+      "p1": 38.0,
+      "p5": 61.0,
+      "p10": 89.0,
+      "p25": 128.0,
+      "p50": 190.0,
+      "p75": 222.0,
+      "p90": 268.0,
+      "p95": 343.0,
+      "p99": 391.0,
+      "p100": 1060.0,
+      "mean": 184.45157054842946
+    },
+    "spacing_x_mm": {
+      "n": 9901,
+      "p0": 0.423177,
+      "p1": 0.546875,
+      "p5": 0.63671875,
+      "p10": 0.673828,
+      "p25": 0.7421875,
+      "p50": 0.80859375,
+      "p75": 0.9765625,
+      "p90": 1.5,
+      "p95": 1.5,
+      "p99": 5.0,
+      "p100": 5.0,
+      "mean": 1.0141072157539641
+    },
+    "spacing_y_mm": {
+      "n": 9901,
+      "p0": 0.39257812,
+      "p1": 0.583984,
+      "p5": 0.640625,
+      "p10": 0.673828,
+      "p25": 0.738281,
+      "p50": 0.796875,
+      "p75": 0.94921875,
+      "p90": 1.5,
+      "p95": 1.5,
+      "p99": 1.5,
+      "p100": 5.0,
+      "mean": 0.8918515932542169
+    },
+    "spacing_z_mm": {
+      "n": 9901,
+      "p0": 0.36330372,
+      "p1": 0.625,
+      "p5": 0.78125,
+      "p10": 0.8,
+      "p25": 0.8,
+      "p50": 1.25,
+      "p75": 2.5,
+      "p90": 5.0,
+      "p95": 5.0,
+      "p99": 5.0,
+      "p100": 10.0,
+      "mean": 1.770136743993536
+    },
+    "phys_x_mm": {
+      "n": 9901,
+      "p0": 70.5,
+      "p1": 175.0,
+      "p5": 293.51540400000005,
+      "p10": 318.000128,
+      "p25": 349.184,
+      "p50": 380.000256,
+      "p75": 416.38293200000004,
+      "p90": 470.0,
+      "p95": 499.0,
+      "p99": 512.0,
+      "p100": 1416.0,
+      "mean": 383.5881392455348
+    },
+    "phys_y_mm": {
+      "n": 9901,
+      "p0": 72.0000048,
+      "p1": 180.11731999999998,
+      "p5": 216.5625,
+      "p10": 229.789096,
+      "p25": 255.38276399999998,
+      "p50": 285.46875,
+      "p75": 319.55272510000003,
+      "p90": 357.6406344,
+      "p95": 377.25,
+      "p99": 411.796875,
+      "p100": 499.5,
+      "mean": 289.1432168380719
+    },
+    "phys_z_mm": {
+      "n": 9901,
+      "p0": 6.4,
+      "p1": 100.0,
+      "p5": 137.5,
+      "p10": 152.0,
+      "p25": 171.875,
+      "p50": 212.5,
+      "p75": 332.5,
+      "p90": 440.0,
+      "p95": 505.0,
+      "p99": 690.0,
+      "p100": 860.0,
+      "mean": 259.71209611028786
+    },
+    "voxel_count_m": {
+      "n": 9901,
+      "p0": 0.3792,
+      "p1": 1.658684,
+      "p5": 4.686672,
+      "p10": 6.509118,
+      "p25": 14.44216,
+      "p50": 29.3433,
+      "p75": 43.225875,
+      "p90": 51.67104,
+      "p95": 57.575808,
+      "p99": 90.486784,
+      "p100": 240.28928,
+      "mean": 30.052378630340375
+    }
+  },
+  "by_fov": {
+    "abdomen_only": {
+      "n": 105,
+      "shape_x": {
+        "n": 105,
+        "p0": 29.0,
+        "p1": 36.68,
+        "p5": 86.4,
+        "p10": 106.6,
+        "p25": 127.0,
+        "p50": 245.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 512.0,
+        "p100": 512.0,
+        "mean": 307.95238095238096
+      },
+      "shape_y": {
+        "n": 105,
+        "p0": 89.0,
+        "p1": 94.44,
+        "p5": 111.2,
+        "p10": 124.4,
+        "p25": 143.0,
+        "p50": 271.0,
+        "p75": 372.0,
+        "p90": 392.6,
+        "p95": 428.79999999999995,
+        "p99": 448.88,
+        "p100": 456.0,
+        "mean": 261.74285714285713
+      },
+      "shape_z": {
+        "n": 105,
+        "p0": 33.0,
+        "p1": 40.12,
+        "p5": 51.4,
+        "p10": 60.0,
+        "p25": 100.0,
+        "p50": 125.0,
+        "p75": 204.0,
+        "p90": 214.0,
+        "p95": 221.39999999999998,
+        "p99": 239.95999999999998,
+        "p100": 258.0,
+        "mean": 141.85714285714286
+      },
+      "spacing_x_mm": {
+        "n": 105,
+        "p0": 0.5859375,
+        "p1": 0.603749976,
+        "p5": 0.62617188,
+        "p10": 0.6605466600000001,
+        "p25": 0.703125,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 2.300000019999997,
+        "p99": 4.9199999999999875,
+        "p100": 5.0,
+        "mean": 1.2633782738095238
+      },
+      "spacing_y_mm": {
+        "n": 105,
+        "p0": 0.546875,
+        "p1": 0.586640624,
+        "p5": 0.6218752000000001,
+        "p10": 0.6558594400000001,
+        "p25": 0.703125,
+        "p50": 0.9765625,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.500000096,
+        "p100": 1.5000001,
+        "mean": 1.1105694852380954
+      },
+      "spacing_z_mm": {
+        "n": 105,
+        "p0": 0.546875,
+        "p1": 0.7016874999999999,
+        "p5": 0.79999995,
+        "p10": 0.8,
+        "p25": 0.8,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5000001,
+        "p100": 2.5,
+        "mean": 1.186990442857143
+      },
+      "phys_x_mm": {
+        "n": 105,
+        "p0": 127.5,
+        "p1": 138.28,
+        "p5": 155.1,
+        "p10": 171.0,
+        "p25": 190.5,
+        "p50": 325.5,
+        "p75": 360.0,
+        "p90": 386.21016096,
+        "p95": 399.84375,
+        "p99": 431.82,
+        "p100": 480.0,
+        "mean": 293.3386327304762
+      },
+      "phys_y_mm": {
+        "n": 105,
+        "p0": 133.5,
+        "p1": 141.659990976,
+        "p5": 166.8,
+        "p10": 186.6,
+        "p25": 214.5,
+        "p50": 243.90625,
+        "p75": 273.515625,
+        "p90": 319.5851605600001,
+        "p95": 337.5,
+        "p99": 369.07481856,
+        "p100": 370.5,
+        "mean": 247.89313983761906
+      },
+      "phys_z_mm": {
+        "n": 105,
+        "p0": 49.5,
+        "p1": 54.0,
+        "p5": 80.4,
+        "p10": 91.8,
+        "p25": 128.0,
+        "p50": 153.0,
+        "p75": 169.60000000000002,
+        "p90": 186.90000496000002,
+        "p95": 199.2187296,
+        "p99": 301.97999999999985,
+        "p100": 358.5,
+        "mean": 150.38443630095242
+      },
+      "voxel_count_m": {
+        "n": 105,
+        "p0": 0.6358,
+        "p1": 0.88568352,
+        "p5": 1.1560308,
+        "p10": 1.353142,
+        "p25": 1.851564,
+        "p50": 5.113125,
+        "p75": 36.203328,
+        "p90": 41.514393600000005,
+        "p95": 44.4630016,
+        "p99": 47.63025407999999,
+        "p100": 48.106496,
+        "mean": 16.827736723809526
+      }
+    },
+    "abdomen_pelvis": {
+      "n": 100,
+      "shape_x": {
+        "n": 100,
+        "p0": 50.0,
+        "p1": 92.57,
+        "p5": 114.0,
+        "p10": 128.8,
+        "p25": 217.75,
+        "p50": 250.0,
+        "p75": 390.75,
+        "p90": 506.0,
+        "p95": 510.05,
+        "p99": 514.3100000000012,
+        "p100": 743.0,
+        "mean": 289.02
+      },
+      "shape_y": {
+        "n": 100,
+        "p0": 91.0,
+        "p1": 109.81,
+        "p5": 122.9,
+        "p10": 131.9,
+        "p25": 142.75,
+        "p50": 171.5,
+        "p75": 280.25,
+        "p90": 351.0000000000001,
+        "p95": 374.0,
+        "p99": 427.27000000000015,
+        "p100": 454.0,
+        "mean": 206.57
+      },
+      "shape_z": {
+        "n": 100,
+        "p0": 29.0,
+        "p1": 36.92,
+        "p5": 41.95,
+        "p10": 54.0,
+        "p25": 97.0,
+        "p50": 150.5,
+        "p75": 180.5,
+        "p90": 206.2000000000001,
+        "p95": 228.14999999999998,
+        "p99": 240.07000000000005,
+        "p100": 247.0,
+        "mean": 138.65
+      },
+      "spacing_x_mm": {
+        "n": 100,
+        "p0": 0.5,
+        "p1": 0.598613306,
+        "p5": 0.70306875,
+        "p10": 0.78125,
+        "p25": 0.976562,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.500000001,
+        "p100": 1.5000001,
+        "mean": 1.3225246470000003
+      },
+      "spacing_y_mm": {
+        "n": 100,
+        "p0": 0.5996094,
+        "p1": 0.655436094,
+        "p5": 0.703125,
+        "p10": 0.7882250000000001,
+        "p25": 0.976562,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5000001,
+        "p100": 1.5000001,
+        "mean": 1.3257668365000002
+      },
+      "spacing_z_mm": {
+        "n": 100,
+        "p0": 0.8,
+        "p1": 0.8,
+        "p5": 0.8,
+        "p10": 1.47499991,
+        "p25": 1.5,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 5.0,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 5.0,
+        "mean": 1.9262421885
+      },
+      "phys_x_mm": {
+        "n": 100,
+        "p0": 75.0,
+        "p1": 138.855,
+        "p5": 171.0,
+        "p10": 193.2,
+        "p25": 325.124983725,
+        "p50": 357.7500119,
+        "p75": 395.3612775,
+        "p90": 430.4665443,
+        "p95": 459.525,
+        "p99": 493.19310686,
+        "p100": 496.093496,
+        "mean": 345.712107274
+      },
+      "phys_y_mm": {
+        "n": 100,
+        "p0": 136.5,
+        "p1": 164.715,
+        "p5": 184.350000605,
+        "p10": 196.34998821,
+        "p25": 212.25,
+        "p50": 247.5,
+        "p75": 282.0078125,
+        "p90": 308.79358080000003,
+        "p95": 356.8478735,
+        "p99": 369.39403164000015,
+        "p100": 394.5,
+        "mean": 250.30366472699998
+      },
+      "phys_z_mm": {
+        "n": 100,
+        "p0": 87.0,
+        "p1": 104.82,
+        "p5": 120.0,
+        "p10": 139.8,
+        "p25": 164.625,
+        "p50": 221.0,
+        "p75": 268.5,
+        "p90": 301.65001809000006,
+        "p95": 329.09999999999997,
+        "p99": 371.8950000000007,
+        "p100": 510.0,
+        "mean": 220.05740637399998
+      },
+      "voxel_count_m": {
+        "n": 100,
+        "p0": 0.702429,
+        "p1": 0.81288429,
+        "p5": 1.778685,
+        "p10": 2.0183675,
+        "p25": 4.391208,
+        "p50": 5.8342515,
+        "p75": 8.87931225,
+        "p90": 18.4301856,
+        "p95": 36.44542439999998,
+        "p99": 50.84427834000002,
+        "p100": 54.56592,
+        "mean": 9.1297059
+      }
+    },
+    "chest_abdomen": {
+      "n": 2454,
+      "shape_x": {
+        "n": 2454,
+        "p0": 47.0,
+        "p1": 94.06,
+        "p5": 161.95000000000002,
+        "p10": 220.0,
+        "p25": 434.0,
+        "p50": 502.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 512.0,
+        "p100": 756.0,
+        "mean": 436.69804400977995
+      },
+      "shape_y": {
+        "n": 2454,
+        "p0": 48.0,
+        "p1": 112.53,
+        "p5": 146.0,
+        "p10": 170.0,
+        "p25": 306.25,
+        "p50": 366.0,
+        "p75": 408.0,
+        "p90": 438.0,
+        "p95": 456.3499999999999,
+        "p99": 496.4699999999998,
+        "p100": 512.0,
+        "mean": 339.9413202933985
+      },
+      "shape_z": {
+        "n": 2454,
+        "p0": 24.0,
+        "p1": 33.0,
+        "p5": 46.0,
+        "p10": 82.0,
+        "p25": 137.0,
+        "p50": 200.0,
+        "p75": 222.0,
+        "p90": 241.0,
+        "p95": 251.0,
+        "p99": 287.9399999999996,
+        "p100": 485.0,
+        "mean": 179.15484922575388
+      },
+      "spacing_x_mm": {
+        "n": 2454,
+        "p0": 0.45117188,
+        "p1": 0.580312525,
+        "p5": 0.62236345,
+        "p10": 0.652343825,
+        "p25": 0.703125,
+        "p50": 0.78125,
+        "p75": 0.9375,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5000001,
+        "p100": 5.0,
+        "mean": 0.9198095958109209
+      },
+      "spacing_y_mm": {
+        "n": 2454,
+        "p0": 0.4375,
+        "p1": 0.5859375,
+        "p5": 0.625,
+        "p10": 0.652344,
+        "p25": 0.703125,
+        "p50": 0.78125,
+        "p75": 0.9169921875,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 3.0,
+        "mean": 0.899728540819071
+      },
+      "spacing_z_mm": {
+        "n": 2454,
+        "p0": 0.41847825,
+        "p1": 0.5,
+        "p5": 0.79999995,
+        "p10": 0.8,
+        "p25": 0.8,
+        "p50": 0.8,
+        "p75": 1.5,
+        "p90": 2.5,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 7.5,
+        "mean": 1.387247926271394
+      },
+      "phys_x_mm": {
+        "n": 2454,
+        "p0": 70.5,
+        "p1": 162.0,
+        "p5": 247.5,
+        "p10": 300.0,
+        "p25": 334.63687500000003,
+        "p50": 364.5,
+        "p75": 396.875,
+        "p90": 420.75004789000013,
+        "p95": 447.13250902499993,
+        "p99": 492.67007812499907,
+        "p100": 512.0,
+        "mean": 360.62140536214747
+      },
+      "phys_y_mm": {
+        "n": 2454,
+        "p0": 72.0000048,
+        "p1": 170.29500000000002,
+        "p5": 210.3299751,
+        "p10": 225.08422019999998,
+        "p25": 249.0,
+        "p50": 278.6621138,
+        "p75": 310.5,
+        "p90": 337.8390625000001,
+        "p95": 359.876849245,
+        "p99": 396.58191373999983,
+        "p100": 461.09765625,
+        "mean": 279.88780395224126
+      },
+      "phys_z_mm": {
+        "n": 2454,
+        "p0": 46.5,
+        "p1": 89.64750000000001,
+        "p5": 125.58000000000001,
+        "p10": 147.20000000000002,
+        "p25": 161.60010100000002,
+        "p50": 180.0,
+        "p75": 205.0,
+        "p90": 258.00001204,
+        "p95": 304.5,
+        "p99": 354.7049999999997,
+        "p100": 820.0,
+        "mean": 191.14249572569275
+      },
+      "voxel_count_m": {
+        "n": 2454,
+        "p0": 0.3792,
+        "p1": 1.29924567,
+        "p5": 3.15202185,
+        "p10": 5.0608155,
+        "p25": 9.625077,
+        "p50": 35.96288,
+        "p75": 43.9296,
+        "p90": 49.86544,
+        "p95": 53.1331584,
+        "p99": 59.72250186,
+        "p100": 98.694656,
+        "mean": 29.869590855745727
+      }
+    },
+    "chest_abdomen_pelvis": {
+      "n": 2624,
+      "shape_x": {
+        "n": 2624,
+        "p0": 51.0,
+        "p1": 109.46000000000001,
+        "p5": 219.15,
+        "p10": 236.0,
+        "p25": 420.75,
+        "p50": 488.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 512.0,
+        "p100": 703.0,
+        "mean": 434.2248475609756
+      },
+      "shape_y": {
+        "n": 2624,
+        "p0": 74.0,
+        "p1": 122.23,
+        "p5": 162.0,
+        "p10": 182.0,
+        "p25": 294.0,
+        "p50": 354.0,
+        "p75": 407.0,
+        "p90": 448.0,
+        "p95": 465.0,
+        "p99": 492.0,
+        "p100": 510.0,
+        "mean": 337.5510670731707
+      },
+      "shape_z": {
+        "n": 2624,
+        "p0": 24.0,
+        "p1": 37.0,
+        "p5": 49.0,
+        "p10": 76.0,
+        "p25": 115.0,
+        "p50": 154.0,
+        "p75": 205.0,
+        "p90": 288.0,
+        "p95": 358.0,
+        "p99": 557.0,
+        "p100": 765.0,
+        "mean": 170.44588414634146
+      },
+      "spacing_x_mm": {
+        "n": 2624,
+        "p0": 0.5,
+        "p1": 0.6202004919999999,
+        "p5": 0.685547,
+        "p10": 0.716797,
+        "p25": 0.78125,
+        "p50": 0.85546875,
+        "p75": 0.976562,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 5.0,
+        "mean": 0.9684165514824696
+      },
+      "spacing_y_mm": {
+        "n": 2624,
+        "p0": 0.39257812,
+        "p1": 0.621094,
+        "p5": 0.685546915,
+        "p10": 0.71679693,
+        "p25": 0.78125,
+        "p50": 0.854,
+        "p75": 0.976562,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 1.5000001,
+        "mean": 0.9584938727172256
+      },
+      "spacing_z_mm": {
+        "n": 2624,
+        "p0": 0.36330372,
+        "p1": 0.7,
+        "p5": 0.8,
+        "p10": 0.8,
+        "p25": 1.0,
+        "p50": 1.5,
+        "p75": 2.5,
+        "p90": 2.5,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 8.0,
+        "mean": 1.9893083805678355
+      },
+      "phys_x_mm": {
+        "n": 2624,
+        "p0": 76.5,
+        "p1": 181.5,
+        "p5": 312.0603687,
+        "p10": 331.5,
+        "p25": 359.2245655,
+        "p50": 391.0000128,
+        "p75": 422.34085890000006,
+        "p90": 452.63277455,
+        "p95": 472.0,
+        "p99": 500.0,
+        "p100": 512.0,
+        "mean": 388.83191901838796
+      },
+      "phys_y_mm": {
+        "n": 2624,
+        "p0": 111.0,
+        "p1": 183.000002806,
+        "p5": 225.0,
+        "p10": 239.6992672,
+        "p25": 264.287173125,
+        "p50": 294.4413788,
+        "p75": 341.24279250000006,
+        "p90": 375.16445008000005,
+        "p95": 390.21953284,
+        "p99": 413.987653513,
+        "p100": 499.5,
+        "mean": 301.59654564005336
+      },
+      "phys_z_mm": {
+        "n": 2624,
+        "p0": 55.5,
+        "p1": 113.0,
+        "p5": 143.25112425,
+        "p10": 170.0,
+        "p25": 207.0,
+        "p50": 250.5,
+        "p75": 337.5,
+        "p90": 390.0,
+        "p95": 390.0,
+        "p99": 440.0,
+        "p100": 720.0,
+        "mean": 264.6249014222942
+      },
+      "voxel_count_m": {
+        "n": 2624,
+        "p0": 0.581196,
+        "p1": 1.72530744,
+        "p5": 5.00293935,
+        "p10": 6.1949088,
+        "p25": 9.942108750000001,
+        "p50": 21.448124999999997,
+        "p75": 36.266239999999996,
+        "p90": 54.83162880000004,
+        "p95": 79.70905599999999,
+        "p99": 120.08488007999999,
+        "p100": 150.74304,
+        "mean": 27.927489581935976
+      }
+    },
+    "whole_body": {
+      "n": 4618,
+      "shape_x": {
+        "n": 4618,
+        "p0": 30.0,
+        "p1": 52.0,
+        "p5": 109.0,
+        "p10": 272.0,
+        "p25": 460.0,
+        "p50": 500.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 654.8299999999999,
+        "p100": 1059.0,
+        "mean": 456.26353399740145
+      },
+      "shape_y": {
+        "n": 4618,
+        "p0": 49.0,
+        "p1": 158.17000000000002,
+        "p5": 244.85000000000002,
+        "p10": 279.0,
+        "p25": 319.0,
+        "p50": 364.0,
+        "p75": 400.0,
+        "p90": 432.0,
+        "p95": 453.0,
+        "p99": 493.8299999999999,
+        "p100": 547.0,
+        "mean": 356.8977912516241
+      },
+      "shape_z": {
+        "n": 4618,
+        "p0": 8.0,
+        "p1": 57.0,
+        "p5": 86.0,
+        "p10": 95.0,
+        "p25": 137.0,
+        "p50": 204.0,
+        "p75": 228.0,
+        "p90": 327.0,
+        "p95": 353.0,
+        "p99": 379.8299999999999,
+        "p100": 1060.0,
+        "mean": 197.1847119965353
+      },
+      "spacing_x_mm": {
+        "n": 4618,
+        "p0": 0.423177,
+        "p1": 0.5,
+        "p5": 0.625,
+        "p10": 0.6640625,
+        "p25": 0.7324219,
+        "p50": 0.791016,
+        "p75": 0.9765625,
+        "p90": 1.5,
+        "p95": 3.0,
+        "p99": 5.0,
+        "p100": 5.0,
+        "mean": 1.077832520684279
+      },
+      "spacing_y_mm": {
+        "n": 4618,
+        "p0": 0.423177,
+        "p1": 0.5549088502,
+        "p5": 0.6308594,
+        "p10": 0.6640625,
+        "p25": 0.72265625,
+        "p50": 0.78125,
+        "p75": 0.9199219,
+        "p90": 1.0,
+        "p95": 1.0,
+        "p99": 1.5,
+        "p100": 5.0,
+        "mean": 0.8354297063728886
+      },
+      "spacing_z_mm": {
+        "n": 4618,
+        "p0": 0.3995785,
+        "p1": 0.625,
+        "p5": 0.757519535,
+        "p10": 0.8,
+        "p25": 0.8,
+        "p50": 1.0,
+        "p75": 2.5,
+        "p90": 5.0,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 10.0,
+        "mean": 1.8589463155586832
+      },
+      "phys_x_mm": {
+        "n": 4618,
+        "p0": 76.5,
+        "p1": 225.0,
+        "p5": 303.47166780000003,
+        "p10": 323.3789559,
+        "p25": 351.118,
+        "p50": 385.15625,
+        "p75": 436.1875,
+        "p90": 497.76,
+        "p95": 512.0,
+        "p99": 586.4043329999995,
+        "p100": 1416.0,
+        "mean": 395.6852566572066
+      },
+      "phys_y_mm": {
+        "n": 4618,
+        "p0": 132.8125,
+        "p1": 194.40127227,
+        "p5": 219.1037,
+        "p10": 231.5455401,
+        "p25": 257.05811775,
+        "p50": 286.5234375,
+        "p75": 317.0,
+        "p90": 348.63268755,
+        "p95": 371.577930285,
+        "p99": 412.5199325875,
+        "p100": 498.04662,
+        "mean": 288.764364898181
+      },
+      "phys_z_mm": {
+        "n": 4618,
+        "p0": 6.4,
+        "p1": 109.50816,
+        "p5": 143.03906759999998,
+        "p10": 153.60000000000002,
+        "p25": 172.0,
+        "p50": 226.125,
+        "p75": 410.0,
+        "p90": 510.0,
+        "p95": 627.0,
+        "p99": 732.49661904,
+        "p100": 860.0,
+        "mean": 296.70288681160895
+      },
+      "voxel_count_m": {
+        "n": 4618,
+        "p0": 0.509878,
+        "p1": 3.49021356,
+        "p5": 7.2778326,
+        "p10": 10.878708,
+        "p25": 18.20935,
+        "p50": 31.630336,
+        "p75": 45.031296,
+        "p90": 52.526846400000004,
+        "p95": 57.1898992,
+        "p99": 68.25358278999997,
+        "p100": 240.28928,
+        "mean": 32.11065596578606
+      }
+    }
+  },
+  "by_split": {
+    "test": {
+      "n": 901,
+      "shape_x": {
+        "n": 901,
+        "p0": 29.0,
+        "p1": 63.0,
+        "p5": 167.0,
+        "p10": 240.0,
+        "p25": 434.0,
+        "p50": 495.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 621.0,
+        "p100": 975.0,
+        "mean": 443.18534961154273
+      },
+      "shape_y": {
+        "n": 901,
+        "p0": 79.0,
+        "p1": 150.0,
+        "p5": 192.0,
+        "p10": 232.0,
+        "p25": 315.0,
+        "p50": 364.0,
+        "p75": 406.0,
+        "p90": 443.0,
+        "p95": 468.0,
+        "p99": 496.0,
+        "p100": 512.0,
+        "mean": 352.8834628190899
+      },
+      "shape_z": {
+        "n": 901,
+        "p0": 30.0,
+        "p1": 36.0,
+        "p5": 46.0,
+        "p10": 78.0,
+        "p25": 105.0,
+        "p50": 155.0,
+        "p75": 204.0,
+        "p90": 259.0,
+        "p95": 298.0,
+        "p99": 557.0,
+        "p100": 988.0,
+        "mean": 165.94783573806882
+      },
+      "spacing_x_mm": {
+        "n": 901,
+        "p0": 0.5,
+        "p1": 0.5,
+        "p5": 0.6328125,
+        "p10": 0.677734,
+        "p25": 0.7441406,
+        "p50": 0.830078,
+        "p75": 0.9628906,
+        "p90": 1.5,
+        "p95": 2.5,
+        "p99": 5.0,
+        "p100": 5.0,
+        "mean": 1.0578355869589344
+      },
+      "spacing_y_mm": {
+        "n": 901,
+        "p0": 0.39257812,
+        "p1": 0.5703125,
+        "p5": 0.644531,
+        "p10": 0.679688,
+        "p25": 0.7421875,
+        "p50": 0.816406,
+        "p75": 0.9238281,
+        "p90": 1.022,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 3.0,
+        "mean": 0.8758961606215315
+      },
+      "spacing_z_mm": {
+        "n": 901,
+        "p0": 0.36330372,
+        "p1": 0.5,
+        "p5": 0.7050781,
+        "p10": 0.8,
+        "p25": 1.0,
+        "p50": 2.5,
+        "p75": 2.5,
+        "p90": 5.0,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 7.5,
+        "mean": 2.292832484395116
+      },
+      "phys_x_mm": {
+        "n": 901,
+        "p0": 145.0,
+        "p1": 220.0,
+        "p5": 310.784,
+        "p10": 328.085824,
+        "p25": 358.000128,
+        "p50": 386.0,
+        "p75": 422.0,
+        "p90": 460.0,
+        "p95": 485.0,
+        "p99": 525.0,
+        "p100": 730.0,
+        "mean": 389.952602400677
+      },
+      "phys_y_mm": {
+        "n": 901,
+        "p0": 145.64648251999998,
+        "p1": 204.175748,
+        "p5": 220.0,
+        "p10": 233.527422,
+        "p25": 259.1015724,
+        "p50": 287.05078125,
+        "p75": 330.2109375,
+        "p90": 369.140436,
+        "p95": 388.671875,
+        "p99": 411.796875,
+        "p100": 466.0546752,
+        "mean": 295.80795439814653
+      },
+      "phys_z_mm": {
+        "n": 901,
+        "p0": 80.08593648,
+        "p1": 113.60000000000001,
+        "p5": 142.4,
+        "p10": 159.375,
+        "p25": 188.8,
+        "p50": 250.0,
+        "p75": 389.9,
+        "p90": 500.0,
+        "p95": 620.0,
+        "p99": 732.480112,
+        "p100": 777.5,
+        "mean": 297.108364433829
+      },
+      "voxel_count_m": {
+        "n": 901,
+        "p0": 2.236248,
+        "p1": 3.76584,
+        "p5": 5.54944,
+        "p10": 6.858696,
+        "p25": 12.33486,
+        "p50": 21.891376,
+        "p75": 36.13896,
+        "p90": 51.37944,
+        "p95": 64.299008,
+        "p99": 123.199488,
+        "p100": 232.7728,
+        "mean": 27.39046759045505
+      }
+    },
+    "train": {
+      "n": 8181,
+      "shape_x": {
+        "n": 8181,
+        "p0": 30.0,
+        "p1": 69.8,
+        "p5": 151.0,
+        "p10": 228.0,
+        "p25": 444.0,
+        "p50": 497.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 540.1999999999998,
+        "p100": 1059.0,
+        "mean": 442.1431365358758
+      },
+      "shape_y": {
+        "n": 8181,
+        "p0": 48.0,
+        "p1": 117.8,
+        "p5": 161.0,
+        "p10": 197.0,
+        "p25": 307.0,
+        "p50": 360.0,
+        "p75": 402.0,
+        "p90": 436.0,
+        "p95": 456.0,
+        "p99": 493.0,
+        "p100": 547.0,
+        "mean": 343.92152548588194
+      },
+      "shape_z": {
+        "n": 8181,
+        "p0": 8.0,
+        "p1": 38.0,
+        "p5": 65.0,
+        "p10": 90.0,
+        "p25": 131.0,
+        "p50": 193.0,
+        "p75": 224.0,
+        "p90": 269.0,
+        "p95": 345.0,
+        "p99": 391.0,
+        "p100": 1060.0,
+        "mean": 186.53355335533553
+      },
+      "spacing_x_mm": {
+        "n": 8181,
+        "p0": 0.423177,
+        "p1": 0.55820312,
+        "p5": 0.6386913,
+        "p10": 0.673828,
+        "p25": 0.7421875,
+        "p50": 0.8027344,
+        "p75": 0.9765625,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 5.0,
+        "p100": 5.0,
+        "mean": 1.0087229440080674
+      },
+      "spacing_y_mm": {
+        "n": 8181,
+        "p0": 0.423177,
+        "p1": 0.582025,
+        "p5": 0.640625,
+        "p10": 0.673828,
+        "p25": 0.7363281,
+        "p50": 0.79296875,
+        "p75": 0.953125,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 5.0,
+        "mean": 0.8939099839555067
+      },
+      "spacing_z_mm": {
+        "n": 8181,
+        "p0": 0.3995785,
+        "p1": 0.625,
+        "p5": 0.7988281,
+        "p10": 0.8,
+        "p25": 0.8,
+        "p50": 1.25,
+        "p75": 2.5,
+        "p90": 4.0,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 10.0,
+        "mean": 1.7170758615474881
+      },
+      "phys_x_mm": {
+        "n": 8181,
+        "p0": 70.5,
+        "p1": 172.5,
+        "p5": 291.0,
+        "p10": 316.82422979999996,
+        "p25": 348.0,
+        "p50": 380.0,
+        "p75": 415.0000128,
+        "p90": 470.0,
+        "p95": 499.5,
+        "p99": 512.0,
+        "p100": 1416.0,
+        "mean": 382.826850908906
+      },
+      "phys_y_mm": {
+        "n": 8181,
+        "p0": 72.0000048,
+        "p1": 178.5,
+        "p5": 216.0,
+        "p10": 229.5,
+        "p25": 255.0,
+        "p50": 285.15625,
+        "p75": 318.0,
+        "p90": 354.375,
+        "p95": 375.08203125,
+        "p99": 408.66874999999993,
+        "p100": 499.5,
+        "mean": 288.1627758155898
+      },
+      "phys_z_mm": {
+        "n": 8181,
+        "p0": 6.4,
+        "p1": 100.0,
+        "p5": 137.00181,
+        "p10": 152.0,
+        "p25": 171.20000000000002,
+        "p50": 207.5,
+        "p75": 325.5,
+        "p90": 435.0,
+        "p95": 498.75,
+        "p99": 685.0,
+        "p100": 820.0,
+        "mean": 256.0016739992409
+      },
+      "voxel_count_m": {
+        "n": 8181,
+        "p0": 0.3792,
+        "p1": 1.5893439999999999,
+        "p5": 4.576055,
+        "p10": 6.423903,
+        "p25": 14.683032,
+        "p50": 30.478264,
+        "p75": 43.556864,
+        "p90": 51.678396,
+        "p95": 57.538404,
+        "p99": 88.92528639999996,
+        "p100": 240.28928,
+        "mean": 30.337295745874584
+      }
+    },
+    "val": {
+      "n": 819,
+      "shape_x": {
+        "n": 819,
+        "p0": 43.0,
+        "p1": 61.36,
+        "p5": 139.30000000000004,
+        "p10": 233.0,
+        "p25": 448.0,
+        "p50": 498.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 583.9799999999975,
+        "p100": 756.0,
+        "mean": 443.03052503052504
+      },
+      "shape_y": {
+        "n": 819,
+        "p0": 89.0,
+        "p1": 122.18,
+        "p5": 166.0,
+        "p10": 198.0,
+        "p25": 313.0,
+        "p50": 364.0,
+        "p75": 404.5,
+        "p90": 440.20000000000005,
+        "p95": 458.0999999999999,
+        "p99": 494.9199999999996,
+        "p100": 512.0,
+        "mean": 347.58730158730157
+      },
+      "shape_z": {
+        "n": 819,
+        "p0": 24.0,
+        "p1": 39.36,
+        "p5": 74.80000000000001,
+        "p10": 91.0,
+        "p25": 129.0,
+        "p50": 191.0,
+        "p75": 220.0,
+        "p90": 261.4000000000001,
+        "p95": 340.0,
+        "p99": 380.19999999999936,
+        "p100": 629.0,
+        "mean": 184.01098901098902
+      },
+      "spacing_x_mm": {
+        "n": 819,
+        "p0": 0.45117188,
+        "p1": 0.510546875,
+        "p5": 0.625,
+        "p10": 0.6640625,
+        "p25": 0.7373045,
+        "p50": 0.8105469,
+        "p75": 0.9822815,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 5.0,
+        "p100": 5.0,
+        "mean": 1.0197842178266179
+      },
+      "spacing_y_mm": {
+        "n": 819,
+        "p0": 0.45117188,
+        "p1": 0.5859375,
+        "p5": 0.628515625,
+        "p10": 0.66796875,
+        "p25": 0.7353514999999999,
+        "p50": 0.800781,
+        "p75": 0.9755857,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 1.5,
+        "mean": 0.88884322997558
+      },
+      "spacing_z_mm": {
+        "n": 819,
+        "p0": 0.45,
+        "p1": 0.7,
+        "p5": 0.77910161,
+        "p10": 0.8,
+        "p25": 0.8,
+        "p50": 1.25,
+        "p75": 2.5,
+        "p90": 4.0,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 7.5,
+        "mean": 1.7251333461782663
+      },
+      "phys_x_mm": {
+        "n": 819,
+        "p0": 97.5,
+        "p1": 171.27,
+        "p5": 290.725,
+        "p10": 314.818752576,
+        "p25": 348.635086,
+        "p50": 380.0,
+        "p75": 419.960702,
+        "p90": 475.26876015999994,
+        "p95": 504.0999999999999,
+        "p99": 512.0,
+        "p100": 734.0,
+        "mean": 384.19097023354095
+      },
+      "phys_y_mm": {
+        "n": 819,
+        "p0": 133.4999911,
+        "p1": 183.27,
+        "p5": 215.933203125,
+        "p10": 231.2359248,
+        "p25": 256.77352399999995,
+        "p50": 286.507728,
+        "p75": 324.1660104,
+        "p90": 360.1187176,
+        "p95": 377.27344739999995,
+        "p99": 427.3799539199994,
+        "p100": 498.04662,
+        "mean": 291.6048279043712
+      },
+      "phys_z_mm": {
+        "n": 819,
+        "p0": 80.0,
+        "p1": 105.18,
+        "p5": 142.25,
+        "p10": 152.96,
+        "p25": 171.20000000000002,
+        "p50": 206.4,
+        "p75": 330.0,
+        "p90": 435.0,
+        "p95": 485.0,
+        "p99": 688.3799999999994,
+        "p100": 860.0,
+        "mean": 255.63508210658117
+      },
+      "voxel_count_m": {
+        "n": 819,
+        "p0": 0.704969,
+        "p1": 1.63027998,
+        "p5": 4.5293346,
+        "p10": 6.5034896,
+        "p25": 16.113194999999997,
+        "p50": 30.93504,
+        "p75": 43.4048,
+        "p90": 51.4711712,
+        "p95": 55.81690879999999,
+        "p99": 80.10009679999989,
+        "p100": 126.564864,
+        "mean": 30.134765595848595
+      }
+    }
+  },
+  "bucket_summary": {
+    "B-CA": {
+      "n": 2454,
+      "fov_counts": {
+        "chest_abdomen": 2454
+      },
+      "crop_any_pct": 6.723716381418093,
+      "crop_x_pct": 0.0,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 6.723716381418093,
+      "phys_z_mm": {
+        "n": 2454,
+        "p0": 46.5,
+        "p1": 89.64750000000001,
+        "p5": 125.58000000000001,
+        "p10": 147.20000000000002,
+        "p25": 161.60010100000002,
+        "p50": 180.0,
+        "p75": 205.0,
+        "p90": 258.00001204,
+        "p95": 304.5,
+        "p99": 354.7049999999997,
+        "p100": 820.0,
+        "mean": 191.14249572569275
+      },
+      "phys_y_mm": {
+        "n": 2454,
+        "p0": 72.0000048,
+        "p1": 170.29500000000002,
+        "p5": 210.3299751,
+        "p10": 225.08422019999998,
+        "p25": 249.0,
+        "p50": 278.6621138,
+        "p75": 310.5,
+        "p90": 337.8390625000001,
+        "p95": 359.876849245,
+        "p99": 396.58191373999983,
+        "p100": 461.09765625,
+        "mean": 279.88780395224126
+      },
+      "phys_x_mm": {
+        "n": 2454,
+        "p0": 70.5,
+        "p1": 162.0,
+        "p5": 247.5,
+        "p10": 300.0,
+        "p25": 334.63687500000003,
+        "p50": 364.5,
+        "p75": 396.875,
+        "p90": 420.75004789000013,
+        "p95": 447.13250902499993,
+        "p99": 492.67007812499907,
+        "p100": 512.0,
+        "mean": 360.62140536214747
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 2454,
+        "p0": 13.285714285714286,
+        "p1": 25.61357142857143,
+        "p5": 35.88,
+        "p10": 42.057142857142864,
+        "p25": 46.17145742857143,
+        "p50": 51.42857142857143,
+        "p75": 58.57142857142857,
+        "p90": 73.71428915428572,
+        "p95": 87.0,
+        "p99": 101.34428571428562,
+        "p100": 234.28571428571428,
+        "mean": 54.612141635912224
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 2454,
+        "p0": 36.0000024,
+        "p1": 85.14750000000001,
+        "p5": 105.16498755,
+        "p10": 112.54211009999999,
+        "p25": 124.5,
+        "p50": 139.3310569,
+        "p75": 155.25,
+        "p90": 168.91953125000006,
+        "p95": 179.9384246225,
+        "p99": 198.29095686999992,
+        "p100": 230.548828125,
+        "mean": 139.94390197612063
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 2454,
+        "p0": 35.25,
+        "p1": 81.0,
+        "p5": 123.75,
+        "p10": 150.0,
+        "p25": 167.31843750000002,
+        "p50": 182.25,
+        "p75": 198.4375,
+        "p90": 210.37502394500007,
+        "p95": 223.56625451249997,
+        "p99": 246.33503906249953,
+        "p100": 256.0,
+        "mean": 180.31070268107374
+      }
+    },
+    "B-CAP": {
+      "n": 2624,
+      "fov_counts": {
+        "chest_abdomen_pelvis": 2624
+      },
+      "crop_any_pct": 12.195121951219512,
+      "crop_x_pct": 0.0,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 12.195121951219512,
+      "phys_z_mm": {
+        "n": 2624,
+        "p0": 55.5,
+        "p1": 113.0,
+        "p5": 143.25112425,
+        "p10": 170.0,
+        "p25": 207.0,
+        "p50": 250.5,
+        "p75": 337.5,
+        "p90": 390.0,
+        "p95": 390.0,
+        "p99": 440.0,
+        "p100": 720.0,
+        "mean": 264.6249014222942
+      },
+      "phys_y_mm": {
+        "n": 2624,
+        "p0": 111.0,
+        "p1": 183.000002806,
+        "p5": 225.0,
+        "p10": 239.6992672,
+        "p25": 264.287173125,
+        "p50": 294.4413788,
+        "p75": 341.24279250000006,
+        "p90": 375.16445008000005,
+        "p95": 390.21953284,
+        "p99": 413.987653513,
+        "p100": 499.5,
+        "mean": 301.59654564005336
+      },
+      "phys_x_mm": {
+        "n": 2624,
+        "p0": 76.5,
+        "p1": 181.5,
+        "p5": 312.0603687,
+        "p10": 331.5,
+        "p25": 359.2245655,
+        "p50": 391.0000128,
+        "p75": 422.34085890000006,
+        "p90": 452.63277455,
+        "p95": 472.0,
+        "p99": 500.0,
+        "p100": 512.0,
+        "mean": 388.83191901838796
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 2624,
+        "p0": 13.875,
+        "p1": 28.25,
+        "p5": 35.8127810625,
+        "p10": 42.5,
+        "p25": 51.75,
+        "p50": 62.625,
+        "p75": 84.375,
+        "p90": 97.5,
+        "p95": 97.5,
+        "p99": 110.0,
+        "p100": 180.0,
+        "mean": 66.15622535557355
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 2624,
+        "p0": 55.5,
+        "p1": 91.500001403,
+        "p5": 112.5,
+        "p10": 119.8496336,
+        "p25": 132.1435865625,
+        "p50": 147.2206894,
+        "p75": 170.62139625000003,
+        "p90": 187.58222504000003,
+        "p95": 195.10976642,
+        "p99": 206.9938267565,
+        "p100": 249.75,
+        "mean": 150.79827282002668
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 2624,
+        "p0": 38.25,
+        "p1": 90.75,
+        "p5": 156.03018435,
+        "p10": 165.75,
+        "p25": 179.61228275,
+        "p50": 195.5000064,
+        "p75": 211.17042945000003,
+        "p90": 226.316387275,
+        "p95": 236.0,
+        "p99": 250.0,
+        "p100": 256.0,
+        "mean": 194.41595950919398
+      }
+    },
+    "B-abd": {
+      "n": 105,
+      "fov_counts": {
+        "abdomen_only": 105
+      },
+      "crop_any_pct": 8.571428571428571,
+      "crop_x_pct": 0.0,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 8.571428571428571,
+      "phys_z_mm": {
+        "n": 105,
+        "p0": 49.5,
+        "p1": 54.0,
+        "p5": 80.4,
+        "p10": 91.8,
+        "p25": 128.0,
+        "p50": 153.0,
+        "p75": 169.60000000000002,
+        "p90": 186.90000496000002,
+        "p95": 199.2187296,
+        "p99": 301.97999999999985,
+        "p100": 358.5,
+        "mean": 150.38443630095242
+      },
+      "phys_y_mm": {
+        "n": 105,
+        "p0": 133.5,
+        "p1": 141.659990976,
+        "p5": 166.8,
+        "p10": 186.6,
+        "p25": 214.5,
+        "p50": 243.90625,
+        "p75": 273.515625,
+        "p90": 319.5851605600001,
+        "p95": 337.5,
+        "p99": 369.07481856,
+        "p100": 370.5,
+        "mean": 247.89313983761906
+      },
+      "phys_x_mm": {
+        "n": 105,
+        "p0": 127.5,
+        "p1": 138.28,
+        "p5": 155.1,
+        "p10": 171.0,
+        "p25": 190.5,
+        "p50": 325.5,
+        "p75": 360.0,
+        "p90": 386.21016096,
+        "p95": 399.84375,
+        "p99": 431.82,
+        "p100": 480.0,
+        "mean": 293.3386327304762
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 105,
+        "p0": 16.5,
+        "p1": 18.0,
+        "p5": 26.8,
+        "p10": 30.6,
+        "p25": 42.666666666666664,
+        "p50": 51.0,
+        "p75": 56.53333333333334,
+        "p90": 62.30000165333334,
+        "p95": 66.4062432,
+        "p99": 100.65999999999994,
+        "p100": 119.5,
+        "mean": 50.128145433650786
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 105,
+        "p0": 66.75,
+        "p1": 70.829995488,
+        "p5": 83.4,
+        "p10": 93.3,
+        "p25": 107.25,
+        "p50": 121.953125,
+        "p75": 136.7578125,
+        "p90": 159.79258028000004,
+        "p95": 168.75,
+        "p99": 184.53740928,
+        "p100": 185.25,
+        "mean": 123.94656991880953
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 105,
+        "p0": 63.75,
+        "p1": 69.14,
+        "p5": 77.55,
+        "p10": 85.5,
+        "p25": 95.25,
+        "p50": 162.75,
+        "p75": 180.0,
+        "p90": 193.10508048,
+        "p95": 199.921875,
+        "p99": 215.91,
+        "p100": 240.0,
+        "mean": 146.6693163652381
+      }
+    },
+    "B-abd-pelvis": {
+      "n": 100,
+      "fov_counts": {
+        "abdomen_pelvis": 100
+      },
+      "crop_any_pct": 58.0,
+      "crop_x_pct": 0.0,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 58.0,
+      "phys_z_mm": {
+        "n": 100,
+        "p0": 87.0,
+        "p1": 104.82,
+        "p5": 120.0,
+        "p10": 139.8,
+        "p25": 164.625,
+        "p50": 221.0,
+        "p75": 268.5,
+        "p90": 301.65001809000006,
+        "p95": 329.09999999999997,
+        "p99": 371.8950000000007,
+        "p100": 510.0,
+        "mean": 220.05740637399998
+      },
+      "phys_y_mm": {
+        "n": 100,
+        "p0": 136.5,
+        "p1": 164.715,
+        "p5": 184.350000605,
+        "p10": 196.34998821,
+        "p25": 212.25,
+        "p50": 247.5,
+        "p75": 282.0078125,
+        "p90": 308.79358080000003,
+        "p95": 356.8478735,
+        "p99": 369.39403164000015,
+        "p100": 394.5,
+        "mean": 250.30366472699998
+      },
+      "phys_x_mm": {
+        "n": 100,
+        "p0": 75.0,
+        "p1": 138.855,
+        "p5": 171.0,
+        "p10": 193.2,
+        "p25": 325.124983725,
+        "p50": 357.7500119,
+        "p75": 395.3612775,
+        "p90": 430.4665443,
+        "p95": 459.525,
+        "p99": 493.19310686,
+        "p100": 496.093496,
+        "mean": 345.712107274
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 100,
+        "p0": 29.0,
+        "p1": 34.94,
+        "p5": 40.0,
+        "p10": 46.6,
+        "p25": 54.875,
+        "p50": 73.66666666666666,
+        "p75": 89.5,
+        "p90": 100.55000603000002,
+        "p95": 109.69999999999999,
+        "p99": 123.96500000000023,
+        "p100": 170.0,
+        "mean": 73.35246879133334
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 100,
+        "p0": 68.25,
+        "p1": 82.3575,
+        "p5": 92.1750003025,
+        "p10": 98.174994105,
+        "p25": 106.125,
+        "p50": 123.75,
+        "p75": 141.00390625,
+        "p90": 154.39679040000001,
+        "p95": 178.42393675,
+        "p99": 184.69701582000008,
+        "p100": 197.25,
+        "mean": 125.15183236349999
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 100,
+        "p0": 37.5,
+        "p1": 69.4275,
+        "p5": 85.5,
+        "p10": 96.6,
+        "p25": 162.5624918625,
+        "p50": 178.87500595,
+        "p75": 197.68063875,
+        "p90": 215.23327215,
+        "p95": 229.7625,
+        "p99": 246.59655343,
+        "p100": 248.046748,
+        "mean": 172.856053637
+      }
+    },
+    "B-whole": {
+      "n": 4618,
+      "fov_counts": {
+        "whole_body": 4618
+      },
+      "crop_any_pct": 6.041576440017323,
+      "crop_x_pct": 1.7540060632308359,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 4.4391511476829795,
+      "phys_z_mm": {
+        "n": 4618,
+        "p0": 6.4,
+        "p1": 109.50816,
+        "p5": 143.03906759999998,
+        "p10": 153.60000000000002,
+        "p25": 172.0,
+        "p50": 226.125,
+        "p75": 410.0,
+        "p90": 510.0,
+        "p95": 627.0,
+        "p99": 732.49661904,
+        "p100": 860.0,
+        "mean": 296.70288681160895
+      },
+      "phys_y_mm": {
+        "n": 4618,
+        "p0": 132.8125,
+        "p1": 194.40127227,
+        "p5": 219.1037,
+        "p10": 231.5455401,
+        "p25": 257.05811775,
+        "p50": 286.5234375,
+        "p75": 317.0,
+        "p90": 348.63268755,
+        "p95": 371.577930285,
+        "p99": 412.5199325875,
+        "p100": 498.04662,
+        "mean": 288.764364898181
+      },
+      "phys_x_mm": {
+        "n": 4618,
+        "p0": 76.5,
+        "p1": 225.0,
+        "p5": 303.47166780000003,
+        "p10": 323.3789559,
+        "p25": 351.118,
+        "p50": 385.15625,
+        "p75": 436.1875,
+        "p90": 497.76,
+        "p95": 512.0,
+        "p99": 586.4043329999995,
+        "p100": 1416.0,
+        "mean": 395.6852566572066
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 4618,
+        "p0": 1.28,
+        "p1": 21.901632,
+        "p5": 28.607813519999997,
+        "p10": 30.720000000000006,
+        "p25": 34.4,
+        "p50": 45.225,
+        "p75": 82.0,
+        "p90": 102.0,
+        "p95": 125.4,
+        "p99": 146.49932380799999,
+        "p100": 172.0,
+        "mean": 59.34057736232178
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 4618,
+        "p0": 66.40625,
+        "p1": 97.200636135,
+        "p5": 109.55185,
+        "p10": 115.77277005,
+        "p25": 128.529058875,
+        "p50": 143.26171875,
+        "p75": 158.5,
+        "p90": 174.316343775,
+        "p95": 185.7889651425,
+        "p99": 206.25996629375,
+        "p100": 249.02331,
+        "mean": 144.3821824490905
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 4618,
+        "p0": 38.25,
+        "p1": 112.5,
+        "p5": 151.73583390000002,
+        "p10": 161.68947795,
+        "p25": 175.559,
+        "p50": 192.578125,
+        "p75": 218.09375,
+        "p90": 248.88,
+        "p95": 256.0,
+        "p99": 293.20216649999975,
+        "p100": 708.0,
+        "mean": 197.8426283286033
+      }
+    }
+  },
+  "pancreas_bbox_summary": {
+    "n_with_bbox": 9442,
+    "bbox_x_mm": {
+      "n": 9442,
+      "p0": 0.0,
+      "p1": 31.542968702,
+      "p5": 81.0,
+      "p10": 99.25775420000001,
+      "p25": 118.09273200000001,
+      "p50": 135.6139965,
+      "p75": 152.148440575,
+      "p90": 172.0,
+      "p95": 193.3413121999996,
+      "p99": 467.9500000000007,
+      "p100": 875.0,
+      "mean": 141.87029645111627
+    },
+    "bbox_y_mm": {
+      "n": 9442,
+      "p0": 0.0,
+      "p1": 25.78125,
+      "p5": 41.69921875,
+      "p10": 48.86250014,
+      "p25": 59.5722885,
+      "p50": 71.386729375,
+      "p75": 83.375,
+      "p90": 95.0,
+      "p95": 103.500006555,
+      "p99": 123.30349479200001,
+      "p100": 190.5,
+      "mean": 71.87623691468438
+    },
+    "bbox_z_mm": {
+      "n": 9442,
+      "p0": 0.0,
+      "p1": 7.5,
+      "p5": 19.5,
+      "p10": 41.0,
+      "p25": 66.0,
+      "p50": 80.0,
+      "p75": 90.0,
+      "p90": 100.5,
+      "p95": 109.18999999999977,
+      "p99": 145.89750000000004,
+      "p100": 452.0,
+      "mean": 76.58949473566723
+    },
+    "padded_x_mm": {
+      "n": 9442,
+      "p0": 80.0,
+      "p1": 111.542968702,
+      "p5": 161.0,
+      "p10": 179.25775420000002,
+      "p25": 198.092732,
+      "p50": 215.6139965,
+      "p75": 232.148440575,
+      "p90": 252.0,
+      "p95": 273.3413121999996,
+      "p99": 547.9500000000007,
+      "p100": 955.0,
+      "mean": 221.87029645111627
+    },
+    "padded_y_mm": {
+      "n": 9442,
+      "p0": 80.0,
+      "p1": 105.78125,
+      "p5": 121.69921875,
+      "p10": 128.86250014,
+      "p25": 139.57228849999998,
+      "p50": 151.38672937500002,
+      "p75": 163.375,
+      "p90": 175.0,
+      "p95": 183.50000655500003,
+      "p99": 203.303494792,
+      "p100": 270.5,
+      "mean": 151.8762369146844
+    },
+    "padded_z_mm": {
+      "n": 9442,
+      "p0": 80.0,
+      "p1": 87.5,
+      "p5": 99.5,
+      "p10": 121.0,
+      "p25": 146.0,
+      "p50": 160.0,
+      "p75": 170.0,
+      "p90": 180.5,
+      "p95": 189.18999999999977,
+      "p99": 225.89750000000004,
+      "p100": 532.0,
+      "mean": 156.58949473566722
+    },
+    "fits_Bpan_pct": 8.19741580173692,
+    "over_x_pct": 8.462190213937726,
+    "over_y_pct": 2.5524253336157594,
+    "over_z_pct": 87.75683117983478
+  }
+}

raw_pants_train_test/metadata/pants-captions-ldm/audit/resolution_analysis_20260519_canonical_axes/bucket_spec_v2_proposal.json

@@ -0,0 +1,187 @@
+{
+  "buckets": [
+    {
+      "name": "B-whole-v2",
+      "fov": "whole_body",
+      "shape_dhw": [
+        160,
+        256,
+        256
+      ],
+      "voxel_spacing_mm": [
+        5.0,
+        2.0,
+        2.0
+      ],
+      "coverage_mm": [
+        800,
+        512,
+        512
+      ],
+      "tokens_after_patch": 2624,
+      "fit": "crop_any=0.3%, crop_z=0.1%"
+    },
+    {
+      "name": "B-CAP-v2",
+      "fov": "chest_abdomen_pelvis",
+      "shape_dhw": [
+        112,
+        320,
+        256
+      ],
+      "voxel_spacing_mm": [
+        4.0,
+        2.0,
+        2.0
+      ],
+      "coverage_mm": [
+        448,
+        640,
+        512
+      ],
+      "tokens_after_patch": 2320,
+      "fit": "crop_any=0.6%, crop_z=0.6%"
+    },
+    {
+      "name": "B-CA-v2",
+      "fov": "chest_abdomen",
+      "shape_dhw": [
+        104,
+        320,
+        256
+      ],
+      "voxel_spacing_mm": [
+        3.5,
+        2.0,
+        2.0
+      ],
+      "coverage_mm": [
+        364,
+        640,
+        512
+      ],
+      "tokens_after_patch": 2160,
+      "fit": "crop_any=0.7%, crop_z=0.7%"
+    },
+    {
+      "name": "B-abd-v2",
+      "fov": "abdomen_only",
+      "shape_dhw": [
+        104,
+        256,
+        256
+      ],
+      "voxel_spacing_mm": [
+        3.0,
+        2.0,
+        2.0
+      ],
+      "coverage_mm": [
+        312,
+        512,
+        512
+      ],
+      "tokens_after_patch": 1728,
+      "fit": "crop_any=1.0%, crop_z=1.0%"
+    },
+    {
+      "name": "B-abd-pelvis-v2",
+      "fov": "abdomen_pelvis",
+      "shape_dhw": [
+        112,
+        256,
+        256
+      ],
+      "voxel_spacing_mm": [
+        3.5,
+        2.0,
+        2.0
+      ],
+      "coverage_mm": [
+        392,
+        512,
+        512
+      ],
+      "tokens_after_patch": 1856,
+      "fit": "crop_any=1.0%, crop_z=1.0%"
+    },
+    {
+      "name": "B-pan-p95",
+      "fov": "pan_crop",
+      "shape_dhw": [
+        96,
+        192,
+        256
+      ],
+      "voxel_spacing_mm": [
+        2.0,
+        1.0,
+        1.0
+      ],
+      "coverage_mm": [
+        192,
+        192,
+        256
+      ],
+      "tokens_after_patch": 1200,
+      "fit": "40mm padded pancreas bbox fit=90.7%"
+    },
+    {
+      "name": "B-pan-p99",
+      "fov": "pan_crop",
+      "shape_dhw": [
+        112,
+        224,
+        288
+      ],
+      "voxel_spacing_mm": [
+        2.0,
+        1.0,
+        1.0
+      ],
+      "coverage_mm": [
+        224,
+        224,
+        288
+      ],
+      "tokens_after_patch": 1827,
+      "fit": "40mm padded pancreas bbox fit=98.4%"
+    },
+    {
+      "name": "B-pan-hires-p95",
+      "fov": "pan_crop",
+      "shape_dhw": [
+        128,
+        224,
+        288
+      ],
+      "voxel_spacing_mm": [
+        1.5,
+        1.0,
+        1.0
+      ],
+      "coverage_mm": [
+        192,
+        224,
+        288
+      ],
+      "tokens_after_patch": 2079,
+      "fit": "40mm padded pancreas bbox fit=95.7%"
+    }
+  ],
+  "token_cap": 8192,
+  "vae": {
+    "compression": [
+      4,
+      16,
+      16
+    ],
+    "channels": 48,
+    "family": "wan22"
+  },
+  "dit_patch": [
+    1,
+    2,
+    2
+  ]
+}

raw_pants_train_test/metadata/pants-captions-ldm/audit/resolution_analysis_20260519_canonical_axes/bucket_spec_v2_proposal.md

@@ -0,0 +1,16 @@
+# Bucket Spec v2 Proposal
+
+Derived from canonical-axis PanTS resolution analysis. All token counts are under 8192.
+
+| bucket | fov | shape DHW | spacing ZYX mm | coverage ZYX mm | tokens | empirical fit |
+|---|---|---:|---:|---:|---:|---|
+| B-whole-v2 | whole_body | 160x256x256 | 5.0x2.0x2.0 | 800x512x512 | 2624 | crop_any=0.3%, crop_z=0.1% |
+| B-CAP-v2 | chest_abdomen_pelvis | 112x320x256 | 4.0x2.0x2.0 | 448x640x512 | 2320 | crop_any=0.6%, crop_z=0.6% |
+| B-CA-v2 | chest_abdomen | 104x320x256 | 3.5x2.0x2.0 | 364x640x512 | 2160 | crop_any=0.7%, crop_z=0.7% |
+| B-abd-v2 | abdomen_only | 104x256x256 | 3.0x2.0x2.0 | 312x512x512 | 1728 | crop_any=1.0%, crop_z=1.0% |
+| B-abd-pelvis-v2 | abdomen_pelvis | 112x256x256 | 3.5x2.0x2.0 | 392x512x512 | 1856 | crop_any=1.0%, crop_z=1.0% |
+| B-pan-p95 | pan_crop | 96x192x256 | 2.0x1.0x1.0 | 192x192x256 | 1200 | 40mm padded pancreas bbox fit=90.7% |
+| B-pan-p99 | pan_crop | 112x224x288 | 2.0x1.0x1.0 | 224x224x288 | 1827 | 40mm padded pancreas bbox fit=98.4% |
+| B-pan-hires-p95 | pan_crop | 128x224x288 | 1.5x1.0x1.0 | 192x224x288 | 2079 | 40mm padded pancreas bbox fit=95.7% |
+
+Recommendation: use the full-volume v2 buckets for global captions, and use either `B-pan-p99` as the single pancreas crop bucket or split `B-pan-hires-p95` plus `B-pan-p99` fallback if preserving z detail is more important than a single cache shape.

raw_pants_train_test/metadata/pants-captions-ldm/audit/resolution_analysis_20260519_canonical_axes/resolution_report_canonical_axes.md

@@ -0,0 +1,60 @@
+# PanTS Resolution Analysis - Canonical Axes
+
+Generated on `2026-05-19 16:22:27 PDT` inside allocation `524904` using `--cpus-per-task=208`.
+
+This report uses `canonical/canonical_facts.jsonl` mask shape/spacing after `nib.as_closest_canonical`, not raw NIfTI header axes.
+
+## Integrity
+- Cases: **9901**
+- Split counts: `{'train': 8181, 'val': 819, 'test': 901}`
+- FOV counts: `{'chest_abdomen_pelvis': 2624, 'chest_abdomen': 2454, 'whole_body': 4618, 'abdomen_pelvis': 100, 'abdomen_only': 105}`
+
+## Overall
+| metric | n | min | p5 | p25 | p50 | p75 | p95 | p99 | max |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| shape_x_vox | 9901 | 47 | 204 | 439 | 496 | 512 | 512 | 512 | 768 |
+| shape_y_vox | 9901 | 48 | 164 | 308 | 361 | 403 | 458 | 493 | 547 |
+| shape_z_slices | 9901 | 8 | 56 | 121 | 180 | 224 | 348 | 516 | 1.06e+03 |
+| spacing_x_mm | 9901 | 0.393 | 0.641 | 0.738 | 0.797 | 0.947 | 1.5 | 1.5 | 2.5 |
+| spacing_y_mm | 9901 | 0.393 | 0.641 | 0.738 | 0.797 | 0.949 | 1.5 | 1.5 | 5 |
+| spacing_z_mm | 9901 | 0.363 | 0.8 | 0.8 | 1.25 | 2.5 | 5 | 5 | 10 |
+| phys_x_mm | 9901 | 70.5 | 182 | 344 | 377 | 410 | 492 | 512 | 641 |
+| phys_y_mm | 9901 | 72 | 217 | 255 | 285 | 320 | 377 | 412 | 500 |
+| phys_z_mm | 9901 | 6.4 | 141 | 176 | 225 | 340 | 519 | 700 | 1.42e+03 |
+| voxel_count_M | 9901 | 0.379 | 4.69 | 14.4 | 29.3 | 43.2 | 57.6 | 90.5 | 240 |
+
+## FOV Groups
+| fov | n | z slices p50/p95 | z spacing p50/p95 mm | physical Z p50/p95/max mm | physical XY p50 mm | voxel count p50/p95 M |
+|---|---:|---:|---:|---:|---:|---:|
+| abdomen_only | 105 | 113/221 | 1.50/2.50 | 153.6/203.5/358.5 | 325.5 x 243.9 | 5.1/44.5 |
+| abdomen_pelvis | 100 | 150/231 | 1.50/5.00 | 223.5/340.6/510.0 | 357.0 x 247.5 | 5.8/36.4 |
+| chest_abdomen | 2454 | 200/252 | 0.80/5.00 | 180.0/305.0/820.0 | 364.5 x 278.7 | 36.0/53.1 |
+| chest_abdomen_pelvis | 2624 | 153/363 | 1.50/5.00 | 252.0/390.0/720.0 | 391.0 x 294.4 | 21.4/79.7 |
+| whole_body | 4618 | 193/362 | 1.25/5.00 | 272.5/642.1/1416.0 | 377.3 x 286.5 | 31.6/57.2 |
+
+## Existing Bucket Coverage
+| bucket | n | crop any % | crop z/y/x % | physical Z p50/p95/max mm | physical Y p95/max mm | physical X p95/max mm | resampled shape p95 z/y/x vox |
+|---|---:|---:|---:|---:|---:|---:|---:|
+| B-CA | 2454 | 7.0 | 7.0/0.0/0.0 | 180.0/305.0/820.0 | 359.9/461.1 | 446.9/512.0 | 87/180/223 |
+| B-CAP | 2624 | 12.2 | 12.2/0.0/0.0 | 252.0/390.0/720.0 | 390.2/499.5 | 472.0/512.0 | 98/195/236 |
+| B-abd | 105 | 6.7 | 6.7/0.0/0.0 | 153.6/203.5/358.5 | 337.5/370.5 | 399.8/480.0 | 68/169/200 |
+| B-abd-pelvis | 100 | 60.0 | 60.0/0.0/0.0 | 223.5/340.6/510.0 | 356.8/394.5 | 459.5/496.1 | 114/178/230 |
+| B-whole | 4618 | 5.1 | 5.1/0.0/0.2 | 272.5/642.1/1416.0 | 371.6/498.0 | 510.0/641.2 | 128/186/255 |
+
+## Pancreas BBox For Current B-pan
+- Cases with bbox: **9442**
+- Current B-pan `(Z,Y,X)=(128,192,256) mm` fit rate after 40mm pad: **7.9%**
+- Over target X/Y/Z: **4.7% / 2.6% / 91.8%**
+
+| metric | n | min | p5 | p25 | p50 | p75 | p95 | p99 | max |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| bbox_x_mm | 9442 | 0 | 66.7 | 115 | 133 | 149 | 176 | 199 | 311 |
+| bbox_y_mm | 9442 | 0 | 41.7 | 59.6 | 71.4 | 83.4 | 104 | 123 | 190 |
+| bbox_z_mm | 9442 | 0 | 36 | 69.6 | 80 | 90.3 | 108 | 139 | 452 |
+| padded_x_mm | 9442 | 80 | 147 | 195 | 213 | 229 | 256 | 279 | 391 |
+| padded_y_mm | 9442 | 80 | 122 | 140 | 151 | 163 | 184 | 203 | 270 |
+| padded_z_mm | 9442 | 80 | 116 | 150 | 160 | 170 | 188 | 219 | 532 |
+
+## Artifacts
+- CSV: `/scratch/user/yuhwang/dataset/pants-captions-ldm/audit/resolution_analysis_20260519_canonical_axes/resolution_records_canonical_axes.csv`
+- JSON: `/scratch/user/yuhwang/dataset/pants-captions-ldm/audit/resolution_analysis_20260519_canonical_axes/resolution_summary_canonical_axes.json`

raw_pants_train_test/metadata/pants-captions-ldm/audit/resolution_analysis_20260519_canonical_axes/resolution_summary_canonical_axes.json

@@ -0,0 +1,1548 @@
+{
+  "generated_at": "2026-05-19 16:22:27 PDT",
+  "axis_note": "Uses canonical_facts mask.shape/spacing after nib.as_closest_canonical; this is the axis frame used by the existing caption/canonical pipeline.",
+  "n_records": 9901,
+  "missing": [],
+  "split_counts": {
+    "train": 8181,
+    "val": 819,
+    "test": 901
+  },
+  "fov_counts": {
+    "chest_abdomen_pelvis": 2624,
+    "chest_abdomen": 2454,
+    "whole_body": 4618,
+    "abdomen_pelvis": 100,
+    "abdomen_only": 105
+  },
+  "phase_counts": {
+    "Non-contrast": 4485,
+    "Venous": 2897,
+    "Arterial": 2450,
+    "unknown": 1,
+    "Delay": 68
+  },
+  "lesion_counts": {
+    "False": 8943,
+    "True": 958
+  },
+  "overall": {
+    "n": 9901,
+    "shape_x": {
+      "n": 9901,
+      "p0": 47.0,
+      "p1": 119.0,
+      "p5": 204.0,
+      "p10": 221.0,
+      "p25": 439.0,
+      "p50": 496.0,
+      "p75": 512.0,
+      "p90": 512.0,
+      "p95": 512.0,
+      "p99": 512.0,
+      "p100": 768.0,
+      "mean": 442.78103221896777
+    },
+    "shape_y": {
+      "n": 9901,
+      "p0": 48.0,
+      "p1": 120.0,
+      "p5": 164.0,
+      "p10": 200.0,
+      "p25": 308.0,
+      "p50": 361.0,
+      "p75": 403.0,
+      "p90": 437.0,
+      "p95": 458.0,
+      "p99": 493.0,
+      "p100": 547.0,
+      "mean": 345.05161094838905
+    },
+    "shape_z": {
+      "n": 9901,
+      "p0": 8.0,
+      "p1": 37.0,
+      "p5": 56.0,
+      "p10": 86.0,
+      "p25": 121.0,
+      "p50": 180.0,
+      "p75": 224.0,
+      "p90": 278.0,
+      "p95": 348.0,
+      "p99": 516.0,
+      "p100": 1060.0,
+      "mean": 183.97060902939097
+    },
+    "spacing_x_mm": {
+      "n": 9901,
+      "p0": 0.392578125,
+      "p1": 0.58203125,
+      "p5": 0.640625,
+      "p10": 0.6738280057907104,
+      "p25": 0.7379999756813049,
+      "p50": 0.796875,
+      "p75": 0.947265625,
+      "p90": 1.5,
+      "p95": 1.5,
+      "p99": 1.5,
+      "p100": 2.5000038146972656,
+      "mean": 0.887715601205296
+    },
+    "spacing_y_mm": {
+      "n": 9901,
+      "p0": 0.392578125,
+      "p1": 0.5839840173721313,
+      "p5": 0.640625,
+      "p10": 0.6738280057907104,
+      "p25": 0.7382810115814209,
+      "p50": 0.796875,
+      "p75": 0.94921875,
+      "p90": 1.5,
+      "p95": 1.5,
+      "p99": 1.5,
+      "p100": 5.0,
+      "mean": 0.8918515933714615
+    },
+    "spacing_z_mm": {
+      "n": 9901,
+      "p0": 0.3633037209510803,
+      "p1": 0.5,
+      "p5": 0.800000011920929,
+      "p10": 0.800000011920929,
+      "p25": 0.800000011920929,
+      "p50": 1.25,
+      "p75": 2.5,
+      "p90": 5.0,
+      "p95": 5.0,
+      "p99": 5.0,
+      "p100": 10.0,
+      "mean": 1.8965283615181463
+    },
+    "phys_x_mm": {
+      "n": 9901,
+      "p0": 70.5,
+      "p1": 141.4453125,
+      "p5": 181.6875,
+      "p10": 304.5,
+      "p25": 343.78398990631104,
+      "p50": 377.34375,
+      "p75": 409.693359375,
+      "p90": 460.5,
+      "p95": 492.0,
+      "p99": 512.0,
+      "p100": 641.2111611366272,
+      "mean": 372.02568867086234
+    },
+    "phys_y_mm": {
+      "n": 9901,
+      "p0": 72.0,
+      "p1": 180.11731386184692,
+      "p5": 216.5625,
+      "p10": 229.7890944480896,
+      "p25": 255.38276624679565,
+      "p50": 285.46875,
+      "p75": 319.552734375,
+      "p90": 357.640625,
+      "p95": 377.25,
+      "p99": 411.857421875,
+      "p100": 499.5,
+      "mean": 289.15381416160704
+    },
+    "phys_z_mm": {
+      "n": 9901,
+      "p0": 6.400000095367432,
+      "p1": 102.0,
+      "p5": 140.8000020980835,
+      "p10": 156.00000232458115,
+      "p25": 175.69600248336792,
+      "p50": 225.0,
+      "p75": 340.0,
+      "p90": 460.0,
+      "p95": 519.0,
+      "p99": 700.0,
+      "p100": 1416.0,
+      "mean": 271.2639500448384
+    },
+    "voxel_count_m": {
+      "n": 9901,
+      "p0": 0.3792,
+      "p1": 1.658684,
+      "p5": 4.686672,
+      "p10": 6.509118,
+      "p25": 14.44216,
+      "p50": 29.3433,
+      "p75": 43.225875,
+      "p90": 51.67104,
+      "p95": 57.575808,
+      "p99": 90.486784,
+      "p100": 240.28928,
+      "mean": 30.052378630340367
+    }
+  },
+  "by_fov": {
+    "abdomen_only": {
+      "n": 105,
+      "shape_x": {
+        "n": 105,
+        "p0": 85.0,
+        "p1": 92.4,
+        "p5": 110.2,
+        "p10": 118.4,
+        "p25": 143.0,
+        "p50": 245.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 512.0,
+        "p100": 512.0,
+        "mean": 317.06666666666666
+      },
+      "shape_y": {
+        "n": 105,
+        "p0": 89.0,
+        "p1": 94.44,
+        "p5": 111.2,
+        "p10": 124.4,
+        "p25": 143.0,
+        "p50": 271.0,
+        "p75": 372.0,
+        "p90": 394.8,
+        "p95": 428.79999999999995,
+        "p99": 448.88,
+        "p100": 456.0,
+        "mean": 261.7809523809524
+      },
+      "shape_z": {
+        "n": 105,
+        "p0": 29.0,
+        "p1": 33.12,
+        "p5": 44.6,
+        "p10": 56.4,
+        "p25": 84.0,
+        "p50": 113.0,
+        "p75": 196.0,
+        "p90": 214.0,
+        "p95": 221.39999999999998,
+        "p99": 239.95999999999998,
+        "p100": 258.0,
+        "mean": 132.7047619047619
+      },
+      "spacing_x_mm": {
+        "n": 105,
+        "p0": 0.546875,
+        "p1": 0.586640625,
+        "p5": 0.6218751907348633,
+        "p10": 0.6558594465255737,
+        "p25": 0.703125,
+        "p50": 0.9765625,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5000001192092896,
+        "p100": 1.5000001192092896,
+        "mean": 1.1105694884345645
+      },
+      "spacing_y_mm": {
+        "n": 105,
+        "p0": 0.546875,
+        "p1": 0.586640625,
+        "p5": 0.6218751907348633,
+        "p10": 0.6558594465255737,
+        "p25": 0.703125,
+        "p50": 0.9765625,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.500000114440918,
+        "p100": 1.5000001192092896,
+        "mean": 1.1105694861639113
+      },
+      "spacing_z_mm": {
+        "n": 105,
+        "p0": 0.699999988079071,
+        "p1": 0.7999999523162842,
+        "p5": 0.800000011920929,
+        "p10": 0.800000011920929,
+        "p25": 0.800000011920929,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 2.5,
+        "p99": 4.9199999999999875,
+        "p100": 5.0,
+        "mean": 1.3397992327099755
+      },
+      "phys_x_mm": {
+        "n": 105,
+        "p0": 111.5625,
+        "p1": 127.92,
+        "p5": 155.1,
+        "p10": 173.11404790878296,
+        "p25": 196.5,
+        "p50": 325.5,
+        "p75": 360.0,
+        "p90": 386.21015625,
+        "p95": 399.84375,
+        "p99": 431.82,
+        "p100": 480.0,
+        "mean": 292.9369931096122
+      },
+      "phys_y_mm": {
+        "n": 105,
+        "p0": 133.50001060962677,
+        "p1": 141.6599892425537,
+        "p5": 166.8,
+        "p10": 186.6,
+        "p25": 214.5,
+        "p50": 243.90625,
+        "p75": 273.515625,
+        "p90": 319.5851562500001,
+        "p95": 337.5,
+        "p99": 369.074826965332,
+        "p100": 370.5,
+        "mean": 247.92654960155488
+      },
+      "phys_z_mm": {
+        "n": 105,
+        "p0": 49.5,
+        "p1": 54.0,
+        "p5": 80.4,
+        "p10": 91.79999935626984,
+        "p25": 129.0,
+        "p50": 153.60000228881836,
+        "p75": 169.60000252723694,
+        "p90": 181.22000107765197,
+        "p95": 203.52000589370724,
+        "p99": 301.97999999999985,
+        "p100": 358.5,
+        "mean": 150.75266745260782
+      },
+      "voxel_count_m": {
+        "n": 105,
+        "p0": 0.6358,
+        "p1": 0.88568352,
+        "p5": 1.1560308,
+        "p10": 1.353142,
+        "p25": 1.851564,
+        "p50": 5.113125,
+        "p75": 36.203328,
+        "p90": 41.514393600000005,
+        "p95": 44.4630016,
+        "p99": 47.63025407999999,
+        "p100": 48.106496,
+        "mean": 16.827736723809526
+      }
+    },
+    "abdomen_pelvis": {
+      "n": 100,
+      "shape_x": {
+        "n": 100,
+        "p0": 50.0,
+        "p1": 92.57,
+        "p5": 114.0,
+        "p10": 128.8,
+        "p25": 216.75,
+        "p50": 247.5,
+        "p75": 339.5,
+        "p90": 505.1,
+        "p95": 510.0,
+        "p99": 512.0,
+        "p100": 512.0,
+        "mean": 283.63
+      },
+      "shape_y": {
+        "n": 100,
+        "p0": 91.0,
+        "p1": 109.81,
+        "p5": 122.9,
+        "p10": 131.9,
+        "p25": 142.75,
+        "p50": 171.5,
+        "p75": 280.25,
+        "p90": 351.0000000000001,
+        "p95": 374.0,
+        "p99": 427.27000000000015,
+        "p100": 454.0,
+        "mean": 206.57
+      },
+      "shape_z": {
+        "n": 100,
+        "p0": 29.0,
+        "p1": 36.92,
+        "p5": 41.95,
+        "p10": 54.0,
+        "p25": 97.0,
+        "p50": 150.5,
+        "p75": 180.5,
+        "p90": 217.20000000000002,
+        "p95": 231.2,
+        "p99": 251.96000000000254,
+        "p100": 743.0,
+        "mean": 144.04
+      },
+      "spacing_x_mm": {
+        "n": 100,
+        "p0": 0.599609375,
+        "p1": 0.6554361116886139,
+        "p5": 0.703125,
+        "p10": 0.7882249772548675,
+        "p25": 0.9765620231628418,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5000001192092896,
+        "p100": 1.5000001192092896,
+        "mean": 1.325766835808754
+      },
+      "spacing_y_mm": {
+        "n": 100,
+        "p0": 0.599609375,
+        "p1": 0.6554361116886139,
+        "p5": 0.703125,
+        "p10": 0.7882249772548675,
+        "p25": 0.9765620231628418,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5000001192092896,
+        "p100": 1.5000001192092896,
+        "mean": 1.3257668393850326
+      },
+      "spacing_z_mm": {
+        "n": 100,
+        "p0": 0.5,
+        "p1": 0.7970000118017196,
+        "p5": 0.800000011920929,
+        "p10": 1.4749998927116394,
+        "p25": 1.5,
+        "p50": 1.5,
+        "p75": 1.5,
+        "p90": 5.0,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 5.0,
+        "mean": 1.9230000019073485
+      },
+      "phys_x_mm": {
+        "n": 100,
+        "p0": 75.0,
+        "p1": 138.855,
+        "p5": 170.925,
+        "p10": 190.35,
+        "p25": 324.0,
+        "p50": 357.00001418590546,
+        "p75": 395.36127984523773,
+        "p90": 430.46654695272446,
+        "p95": 459.525,
+        "p99": 493.19311855793,
+        "p100": 496.09350776672363,
+        "mean": 343.67851422190665
+      },
+      "phys_y_mm": {
+        "n": 100,
+        "p0": 136.5,
+        "p1": 164.715,
+        "p5": 184.3500146508217,
+        "p10": 196.34998594522477,
+        "p25": 212.25,
+        "p50": 247.5,
+        "p75": 282.0078125,
+        "p90": 308.7935886383057,
+        "p95": 356.84788153171536,
+        "p99": 369.3940403079988,
+        "p100": 394.5,
+        "mean": 250.3036654114723
+      },
+      "phys_z_mm": {
+        "n": 100,
+        "p0": 87.0,
+        "p1": 104.82,
+        "p5": 120.0,
+        "p10": 139.80000187754632,
+        "p25": 164.625,
+        "p50": 223.5,
+        "p75": 268.5,
+        "p90": 303.0,
+        "p95": 340.575,
+        "p99": 372.88500000000073,
+        "p100": 510.0,
+        "mean": 222.0910002976656
+      },
+      "voxel_count_m": {
+        "n": 100,
+        "p0": 0.702429,
+        "p1": 0.81288429,
+        "p5": 1.778685,
+        "p10": 2.0183675,
+        "p25": 4.391208,
+        "p50": 5.8342515,
+        "p75": 8.87931225,
+        "p90": 18.4301856,
+        "p95": 36.44542439999998,
+        "p99": 50.84427834000002,
+        "p100": 54.56592,
+        "mean": 9.1297059
+      }
+    },
+    "chest_abdomen": {
+      "n": 2454,
+      "shape_x": {
+        "n": 2454,
+        "p0": 47.0,
+        "p1": 108.0,
+        "p5": 177.0,
+        "p10": 218.0,
+        "p25": 433.0,
+        "p50": 502.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 512.0,
+        "p100": 756.0,
+        "mean": 437.27832110839444
+      },
+      "shape_y": {
+        "n": 2454,
+        "p0": 48.0,
+        "p1": 112.53,
+        "p5": 146.0,
+        "p10": 170.0,
+        "p25": 306.25,
+        "p50": 366.0,
+        "p75": 408.0,
+        "p90": 438.0,
+        "p95": 457.0,
+        "p99": 497.9399999999996,
+        "p100": 512.0,
+        "mean": 339.98533007334964
+      },
+      "shape_z": {
+        "n": 2454,
+        "p0": 24.0,
+        "p1": 33.0,
+        "p5": 46.0,
+        "p10": 76.0,
+        "p25": 136.0,
+        "p50": 200.0,
+        "p75": 223.0,
+        "p90": 241.0,
+        "p95": 252.3499999999999,
+        "p99": 293.0,
+        "p100": 615.0,
+        "mean": 178.53056234718827
+      },
+      "spacing_x_mm": {
+        "n": 2454,
+        "p0": 0.4375,
+        "p1": 0.5859375,
+        "p5": 0.6243164479732514,
+        "p10": 0.6523439884185791,
+        "p25": 0.703125,
+        "p50": 0.78125,
+        "p75": 0.91015625,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 1.5000001192092896,
+        "mean": 0.8978438329045716
+      },
+      "spacing_y_mm": {
+        "n": 2454,
+        "p0": 0.4375,
+        "p1": 0.5859375,
+        "p5": 0.625,
+        "p10": 0.6523439884185791,
+        "p25": 0.703125,
+        "p50": 0.78125,
+        "p75": 0.9169921875,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 3.0,
+        "mean": 0.8997285417307657
+      },
+      "spacing_z_mm": {
+        "n": 2454,
+        "p0": 0.41847825050354004,
+        "p1": 0.5,
+        "p5": 0.7999999523162842,
+        "p10": 0.800000011920929,
+        "p25": 0.800000011920929,
+        "p50": 0.800000011920929,
+        "p75": 1.5,
+        "p90": 2.5,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 7.5,
+        "mean": 1.4092136955445824
+      },
+      "phys_x_mm": {
+        "n": 2454,
+        "p0": 70.5,
+        "p1": 146.29500000000002,
+        "p5": 226.5,
+        "p10": 300.0,
+        "p25": 334.61999237537384,
+        "p50": 364.5,
+        "p75": 396.875,
+        "p90": 420.0,
+        "p95": 446.9486328125,
+        "p99": 492.67007812499907,
+        "p100": 512.0,
+        "mean": 359.5424210512259
+      },
+      "phys_y_mm": {
+        "n": 2454,
+        "p0": 72.0,
+        "p1": 170.29500000000002,
+        "p5": 210.32998571395873,
+        "p10": 225.08422737121583,
+        "p25": 249.0,
+        "p50": 278.662109375,
+        "p75": 310.5,
+        "p90": 337.8390625000001,
+        "p95": 359.87685546874997,
+        "p99": 397.5,
+        "p100": 461.09765625,
+        "mean": 279.929130877167
+      },
+      "phys_z_mm": {
+        "n": 2454,
+        "p0": 46.5,
+        "p1": 90.0,
+        "p5": 126.4125,
+        "p10": 147.29000153541566,
+        "p25": 163.2000024318695,
+        "p50": 180.00000268220901,
+        "p75": 206.40000307559967,
+        "p90": 260.0,
+        "p95": 305.0,
+        "p99": 354.7049999999997,
+        "p100": 820.0,
+        "mean": 192.1801549274939
+      },
+      "voxel_count_m": {
+        "n": 2454,
+        "p0": 0.3792,
+        "p1": 1.29924567,
+        "p5": 3.15202185,
+        "p10": 5.0608155,
+        "p25": 9.625077,
+        "p50": 35.96288,
+        "p75": 43.9296,
+        "p90": 49.86544,
+        "p95": 53.1331584,
+        "p99": 59.72250186,
+        "p100": 98.694656,
+        "mean": 29.869590855745727
+      }
+    },
+    "chest_abdomen_pelvis": {
+      "n": 2624,
+      "shape_x": {
+        "n": 2624,
+        "p0": 51.0,
+        "p1": 121.0,
+        "p5": 218.0,
+        "p10": 235.0,
+        "p25": 420.0,
+        "p50": 488.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 512.0,
+        "p100": 703.0,
+        "mean": 434.0655487804878
+      },
+      "shape_y": {
+        "n": 2624,
+        "p0": 74.0,
+        "p1": 122.23,
+        "p5": 162.0,
+        "p10": 182.0,
+        "p25": 294.0,
+        "p50": 354.0,
+        "p75": 407.0,
+        "p90": 448.0,
+        "p95": 465.0,
+        "p99": 492.0,
+        "p100": 510.0,
+        "mean": 337.5510670731707
+      },
+      "shape_z": {
+        "n": 2624,
+        "p0": 24.0,
+        "p1": 37.0,
+        "p5": 49.0,
+        "p10": 75.0,
+        "p25": 114.0,
+        "p50": 153.0,
+        "p75": 206.0,
+        "p90": 293.0,
+        "p95": 363.0,
+        "p99": 557.0,
+        "p100": 765.0,
+        "mean": 170.60518292682926
+      },
+      "spacing_x_mm": {
+        "n": 2624,
+        "p0": 0.392578125,
+        "p1": 0.6219923710823059,
+        "p5": 0.6855469942092896,
+        "p10": 0.7167969942092896,
+        "p25": 0.78125,
+        "p50": 0.8547343611717224,
+        "p75": 0.9765620231628418,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 1.9999998807907104,
+        "mean": 0.9590327689969321
+      },
+      "spacing_y_mm": {
+        "n": 2624,
+        "p0": 0.392578125,
+        "p1": 0.6210939884185791,
+        "p5": 0.6855468928813935,
+        "p10": 0.7167969107627868,
+        "p25": 0.78125,
+        "p50": 0.8539999723434448,
+        "p75": 0.9765620231628418,
+        "p90": 1.5,
+        "p95": 1.5,
+        "p99": 1.5,
+        "p100": 1.500000238418579,
+        "mean": 0.9584938733634062
+      },
+      "spacing_z_mm": {
+        "n": 2624,
+        "p0": 0.3633037209510803,
+        "p1": 0.699999988079071,
+        "p5": 0.800000011920929,
+        "p10": 0.800000011920929,
+        "p25": 1.0,
+        "p50": 1.5,
+        "p75": 2.5,
+        "p90": 3.0,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 8.0,
+        "mean": 1.9986921644928615
+      },
+      "phys_x_mm": {
+        "n": 2624,
+        "p0": 76.5,
+        "p1": 164.19001000523568,
+        "p5": 311.96005816459655,
+        "p10": 331.5,
+        "p25": 359.21478724479675,
+        "p50": 390.9658203125,
+        "p75": 422.16944682598114,
+        "p90": 452.510889530182,
+        "p95": 471.97248722314833,
+        "p99": 500.0,
+        "p100": 512.0,
+        "mean": 388.0579667357137
+      },
+      "phys_y_mm": {
+        "n": 2624,
+        "p0": 110.99999117851257,
+        "p1": 183.00000334501266,
+        "p5": 225.0,
+        "p10": 239.69926495552062,
+        "p25": 264.28717017173767,
+        "p50": 294.44138383865356,
+        "p75": 341.2427870929241,
+        "p90": 375.164453125,
+        "p95": 390.21953125,
+        "p99": 413.98765625,
+        "p100": 499.5,
+        "mean": 301.5965458503584
+      },
+      "phys_z_mm": {
+        "n": 2624,
+        "p0": 55.5,
+        "p1": 113.13800038933753,
+        "p5": 144.0,
+        "p10": 171.2000025510788,
+        "p25": 207.875,
+        "p50": 252.0,
+        "p75": 337.5,
+        "p90": 390.0,
+        "p95": 390.0,
+        "p99": 440.0,
+        "p100": 720.0,
+        "mean": 265.3988541140925
+      },
+      "voxel_count_m": {
+        "n": 2624,
+        "p0": 0.581196,
+        "p1": 1.72530744,
+        "p5": 5.00293935,
+        "p10": 6.1949088,
+        "p25": 9.942108750000001,
+        "p50": 21.448124999999997,
+        "p75": 36.266239999999996,
+        "p90": 54.83162880000004,
+        "p95": 79.70905599999999,
+        "p99": 120.08488007999999,
+        "p100": 150.74304,
+        "mean": 27.927489581935976
+      }
+    },
+    "whole_body": {
+      "n": 4618,
+      "shape_x": {
+        "n": 4618,
+        "p0": 51.0,
+        "p1": 204.0,
+        "p5": 204.0,
+        "p10": 214.0,
+        "p25": 457.0,
+        "p50": 499.0,
+        "p75": 512.0,
+        "p90": 512.0,
+        "p95": 512.0,
+        "p99": 609.3199999999997,
+        "p100": 768.0,
+        "mean": 456.96210480727586
+      },
+      "shape_y": {
+        "n": 4618,
+        "p0": 49.0,
+        "p1": 158.17000000000002,
+        "p5": 244.85000000000002,
+        "p10": 279.0,
+        "p25": 319.0,
+        "p50": 364.0,
+        "p75": 400.0,
+        "p90": 432.0,
+        "p95": 453.0,
+        "p99": 493.8299999999999,
+        "p100": 547.0,
+        "mean": 356.8977912516241
+      },
+      "shape_z": {
+        "n": 4618,
+        "p0": 8.0,
+        "p1": 44.0,
+        "p5": 80.0,
+        "p10": 90.0,
+        "p25": 120.25,
+        "p50": 193.0,
+        "p75": 231.0,
+        "p90": 338.0,
+        "p95": 362.0,
+        "p99": 589.2999999999993,
+        "p100": 1060.0,
+        "mean": 196.4861411866609
+      },
+      "spacing_x_mm": {
+        "n": 4618,
+        "p0": 0.42317700386047363,
+        "p1": 0.5536067873239517,
+        "p5": 0.630859375,
+        "p10": 0.6640625,
+        "p25": 0.72265625,
+        "p50": 0.78125,
+        "p75": 0.91796875,
+        "p90": 1.0,
+        "p95": 1.0,
+        "p99": 1.5,
+        "p100": 2.5000038146972656,
+        "mean": 0.8272574568798966
+      },
+      "spacing_y_mm": {
+        "n": 4618,
+        "p0": 0.42317700386047363,
+        "p1": 0.5549088507890702,
+        "p5": 0.630859375,
+        "p10": 0.6640625,
+        "p25": 0.72265625,
+        "p50": 0.78125,
+        "p75": 0.919921875,
+        "p90": 1.0,
+        "p95": 1.0,
+        "p99": 1.5,
+        "p100": 5.0,
+        "mean": 0.8354297056890969
+      },
+      "spacing_z_mm": {
+        "n": 4618,
+        "p0": 0.3995785117149353,
+        "p1": 0.57296875,
+        "p5": 0.800000011920929,
+        "p10": 0.800000011920929,
+        "p25": 0.800000011920929,
+        "p50": 1.25,
+        "p75": 3.0,
+        "p90": 5.0,
+        "p95": 5.0,
+        "p99": 5.0,
+        "p100": 10.0,
+        "mean": 2.1095213813924234
+      },
+      "phys_x_mm": {
+        "n": 4618,
+        "p0": 76.5,
+        "p1": 138.65625,
+        "p5": 160.0752939105034,
+        "p10": 279.38640136718755,
+        "p25": 342.0,
+        "p50": 377.27053755521774,
+        "p75": 418.0322718024254,
+        "p90": 485.0,
+        "p95": 510.0,
+        "p99": 512.0,
+        "p100": 641.2111611366272,
+        "mean": 371.9616504671474
+      },
+      "phys_y_mm": {
+        "n": 4618,
+        "p0": 132.8125,
+        "p1": 194.401271238327,
+        "p5": 219.10370013415815,
+        "p10": 231.5455386042595,
+        "p25": 257.0581171810627,
+        "p50": 286.5234375,
+        "p75": 317.0,
+        "p90": 348.6326933383942,
+        "p95": 371.57793331146235,
+        "p99": 412.51994140625,
+        "p100": 498.0466318130493,
+        "mean": 288.76436472084293
+      },
+      "phys_z_mm": {
+        "n": 4618,
+        "p0": 6.400000095367432,
+        "p1": 111.89624967575074,
+        "p5": 149.60000222921371,
+        "p10": 160.0000023841858,
+        "p25": 180.80000269412994,
+        "p50": 272.5,
+        "p75": 442.5,
+        "p90": 529.6500000000001,
+        "p95": 642.0749999999998,
+        "p99": 737.4899999999998,
+        "p100": 1416.0,
+        "mean": 320.42649326422816
+      },
+      "voxel_count_m": {
+        "n": 4618,
+        "p0": 0.509878,
+        "p1": 3.49021356,
+        "p5": 7.2778326,
+        "p10": 10.878708,
+        "p25": 18.20935,
+        "p50": 31.630336,
+        "p75": 45.031296,
+        "p90": 52.526846400000004,
+        "p95": 57.1898992,
+        "p99": 68.25358278999997,
+        "p100": 240.28928,
+        "mean": 32.11065596578606
+      }
+    }
+  },
+  "bucket_summary": {
+    "B-CA": {
+      "n": 2454,
+      "fov_counts": {
+        "chest_abdomen": 2454
+      },
+      "crop_any_pct": 7.008964955175224,
+      "crop_x_pct": 0.0,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 7.008964955175224,
+      "phys_z_mm": {
+        "n": 2454,
+        "p0": 46.5,
+        "p1": 90.0,
+        "p5": 126.4125,
+        "p10": 147.29000153541566,
+        "p25": 163.2000024318695,
+        "p50": 180.00000268220901,
+        "p75": 206.40000307559967,
+        "p90": 260.0,
+        "p95": 305.0,
+        "p99": 354.7049999999997,
+        "p100": 820.0,
+        "mean": 192.1801549274939
+      },
+      "phys_y_mm": {
+        "n": 2454,
+        "p0": 72.0,
+        "p1": 170.29500000000002,
+        "p5": 210.32998571395873,
+        "p10": 225.08422737121583,
+        "p25": 249.0,
+        "p50": 278.662109375,
+        "p75": 310.5,
+        "p90": 337.8390625000001,
+        "p95": 359.87685546874997,
+        "p99": 397.5,
+        "p100": 461.09765625,
+        "mean": 279.929130877167
+      },
+      "phys_x_mm": {
+        "n": 2454,
+        "p0": 70.5,
+        "p1": 146.29500000000002,
+        "p5": 226.5,
+        "p10": 300.0,
+        "p25": 334.61999237537384,
+        "p50": 364.5,
+        "p75": 396.875,
+        "p90": 420.0,
+        "p95": 446.9486328125,
+        "p99": 492.67007812499907,
+        "p100": 512.0,
+        "mean": 359.5424210512259
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 2454,
+        "p0": 13.285714285714286,
+        "p1": 25.714285714285715,
+        "p5": 36.11785714285715,
+        "p10": 42.08285758154733,
+        "p25": 46.62857212339129,
+        "p50": 51.42857219491686,
+        "p75": 58.971429450171335,
+        "p90": 74.28571428571429,
+        "p95": 87.14285714285714,
+        "p99": 101.34428571428562,
+        "p100": 234.28571428571428,
+        "mean": 54.908615693569686
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 2454,
+        "p0": 36.0,
+        "p1": 85.14750000000001,
+        "p5": 105.16499285697937,
+        "p10": 112.54211368560792,
+        "p25": 124.5,
+        "p50": 139.3310546875,
+        "p75": 155.25,
+        "p90": 168.91953125000006,
+        "p95": 179.93842773437498,
+        "p99": 198.75,
+        "p100": 230.548828125,
+        "mean": 139.9645654385835
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 2454,
+        "p0": 35.25,
+        "p1": 73.14750000000001,
+        "p5": 113.25,
+        "p10": 150.0,
+        "p25": 167.30999618768692,
+        "p50": 182.25,
+        "p75": 198.4375,
+        "p90": 210.0,
+        "p95": 223.47431640625,
+        "p99": 246.33503906249953,
+        "p100": 256.0,
+        "mean": 179.77121052561296
+      }
+    },
+    "B-CAP": {
+      "n": 2624,
+      "fov_counts": {
+        "chest_abdomen_pelvis": 2624
+      },
+      "crop_any_pct": 12.233231707317072,
+      "crop_x_pct": 0.0,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 12.233231707317072,
+      "phys_z_mm": {
+        "n": 2624,
+        "p0": 55.5,
+        "p1": 113.13800038933753,
+        "p5": 144.0,
+        "p10": 171.2000025510788,
+        "p25": 207.875,
+        "p50": 252.0,
+        "p75": 337.5,
+        "p90": 390.0,
+        "p95": 390.0,
+        "p99": 440.0,
+        "p100": 720.0,
+        "mean": 265.3988541140925
+      },
+      "phys_y_mm": {
+        "n": 2624,
+        "p0": 110.99999117851257,
+        "p1": 183.00000334501266,
+        "p5": 225.0,
+        "p10": 239.69926495552062,
+        "p25": 264.28717017173767,
+        "p50": 294.44138383865356,
+        "p75": 341.2427870929241,
+        "p90": 375.164453125,
+        "p95": 390.21953125,
+        "p99": 413.98765625,
+        "p100": 499.5,
+        "mean": 301.5965458503584
+      },
+      "phys_x_mm": {
+        "n": 2624,
+        "p0": 76.5,
+        "p1": 164.19001000523568,
+        "p5": 311.96005816459655,
+        "p10": 331.5,
+        "p25": 359.21478724479675,
+        "p50": 390.9658203125,
+        "p75": 422.16944682598114,
+        "p90": 452.510889530182,
+        "p95": 471.97248722314833,
+        "p99": 500.0,
+        "p100": 512.0,
+        "mean": 388.0579667357137
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 2624,
+        "p0": 13.875,
+        "p1": 28.284500097334384,
+        "p5": 36.0,
+        "p10": 42.8000006377697,
+        "p25": 51.96875,
+        "p50": 63.0,
+        "p75": 84.375,
+        "p90": 97.5,
+        "p95": 97.5,
+        "p99": 110.0,
+        "p100": 180.0,
+        "mean": 66.34971352852313
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 2624,
+        "p0": 55.49999558925629,
+        "p1": 91.50000167250633,
+        "p5": 112.5,
+        "p10": 119.84963247776031,
+        "p25": 132.14358508586884,
+        "p50": 147.22069191932678,
+        "p75": 170.62139354646206,
+        "p90": 187.5822265625,
+        "p95": 195.109765625,
+        "p99": 206.993828125,
+        "p100": 249.75,
+        "mean": 150.7982729251792
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 2624,
+        "p0": 38.25,
+        "p1": 82.09500500261784,
+        "p5": 155.98002908229827,
+        "p10": 165.75,
+        "p25": 179.60739362239838,
+        "p50": 195.48291015625,
+        "p75": 211.08472341299057,
+        "p90": 226.255444765091,
+        "p95": 235.98624361157417,
+        "p99": 250.0,
+        "p100": 256.0,
+        "mean": 194.02898336785685
+      }
+    },
+    "B-abd": {
+      "n": 105,
+      "fov_counts": {
+        "abdomen_only": 105
+      },
+      "crop_any_pct": 6.666666666666667,
+      "crop_x_pct": 0.0,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 6.666666666666667,
+      "phys_z_mm": {
+        "n": 105,
+        "p0": 49.5,
+        "p1": 54.0,
+        "p5": 80.4,
+        "p10": 91.79999935626984,
+        "p25": 129.0,
+        "p50": 153.60000228881836,
+        "p75": 169.60000252723694,
+        "p90": 181.22000107765197,
+        "p95": 203.52000589370724,
+        "p99": 301.97999999999985,
+        "p100": 358.5,
+        "mean": 150.75266745260782
+      },
+      "phys_y_mm": {
+        "n": 105,
+        "p0": 133.50001060962677,
+        "p1": 141.6599892425537,
+        "p5": 166.8,
+        "p10": 186.6,
+        "p25": 214.5,
+        "p50": 243.90625,
+        "p75": 273.515625,
+        "p90": 319.5851562500001,
+        "p95": 337.5,
+        "p99": 369.074826965332,
+        "p100": 370.5,
+        "mean": 247.92654960155488
+      },
+      "phys_x_mm": {
+        "n": 105,
+        "p0": 111.5625,
+        "p1": 127.92,
+        "p5": 155.1,
+        "p10": 173.11404790878296,
+        "p25": 196.5,
+        "p50": 325.5,
+        "p75": 360.0,
+        "p90": 386.21015625,
+        "p95": 399.84375,
+        "p99": 431.82,
+        "p100": 480.0,
+        "mean": 292.9369931096122
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 105,
+        "p0": 16.5,
+        "p1": 18.0,
+        "p5": 26.8,
+        "p10": 30.59999978542328,
+        "p25": 43.0,
+        "p50": 51.20000076293945,
+        "p75": 56.533334175745644,
+        "p90": 60.406667025884,
+        "p95": 67.84000196456908,
+        "p99": 100.65999999999994,
+        "p100": 119.5,
+        "mean": 50.25088915086928
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 105,
+        "p0": 66.75000530481339,
+        "p1": 70.82999462127685,
+        "p5": 83.4,
+        "p10": 93.3,
+        "p25": 107.25,
+        "p50": 121.953125,
+        "p75": 136.7578125,
+        "p90": 159.79257812500006,
+        "p95": 168.75,
+        "p99": 184.537413482666,
+        "p100": 185.25,
+        "mean": 123.96327480077744
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 105,
+        "p0": 55.78125,
+        "p1": 63.96,
+        "p5": 77.55,
+        "p10": 86.55702395439148,
+        "p25": 98.25,
+        "p50": 162.75,
+        "p75": 180.0,
+        "p90": 193.105078125,
+        "p95": 199.921875,
+        "p99": 215.91,
+        "p100": 240.0,
+        "mean": 146.4684965548061
+      }
+    },
+    "B-abd-pelvis": {
+      "n": 100,
+      "fov_counts": {
+        "abdomen_pelvis": 100
+      },
+      "crop_any_pct": 60.0,
+      "crop_x_pct": 0.0,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 60.0,
+      "phys_z_mm": {
+        "n": 100,
+        "p0": 87.0,
+        "p1": 104.82,
+        "p5": 120.0,
+        "p10": 139.80000187754632,
+        "p25": 164.625,
+        "p50": 223.5,
+        "p75": 268.5,
+        "p90": 303.0,
+        "p95": 340.575,
+        "p99": 372.88500000000073,
+        "p100": 510.0,
+        "mean": 222.0910002976656
+      },
+      "phys_y_mm": {
+        "n": 100,
+        "p0": 136.5,
+        "p1": 164.715,
+        "p5": 184.3500146508217,
+        "p10": 196.34998594522477,
+        "p25": 212.25,
+        "p50": 247.5,
+        "p75": 282.0078125,
+        "p90": 308.7935886383057,
+        "p95": 356.84788153171536,
+        "p99": 369.3940403079988,
+        "p100": 394.5,
+        "mean": 250.3036654114723
+      },
+      "phys_x_mm": {
+        "n": 100,
+        "p0": 75.0,
+        "p1": 138.855,
+        "p5": 170.925,
+        "p10": 190.35,
+        "p25": 324.0,
+        "p50": 357.00001418590546,
+        "p75": 395.36127984523773,
+        "p90": 430.46654695272446,
+        "p95": 459.525,
+        "p99": 493.19311855793,
+        "p100": 496.09350776672363,
+        "mean": 343.67851422190665
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 100,
+        "p0": 29.0,
+        "p1": 34.94,
+        "p5": 40.0,
+        "p10": 46.60000062584877,
+        "p25": 54.875,
+        "p50": 74.5,
+        "p75": 89.5,
+        "p90": 101.0,
+        "p95": 113.525,
+        "p99": 124.29500000000023,
+        "p100": 170.0,
+        "mean": 74.0303334325552
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 100,
+        "p0": 68.25,
+        "p1": 82.3575,
+        "p5": 92.17500732541085,
+        "p10": 98.17499297261239,
+        "p25": 106.125,
+        "p50": 123.75,
+        "p75": 141.00390625,
+        "p90": 154.39679431915286,
+        "p95": 178.42394076585768,
+        "p99": 184.6970201539994,
+        "p100": 197.25,
+        "mean": 125.15183270573615
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 100,
+        "p0": 37.5,
+        "p1": 69.4275,
+        "p5": 85.4625,
+        "p10": 95.175,
+        "p25": 162.0,
+        "p50": 178.50000709295273,
+        "p75": 197.68063992261887,
+        "p90": 215.23327347636223,
+        "p95": 229.7625,
+        "p99": 246.596559278965,
+        "p100": 248.04675388336182,
+        "mean": 171.83925711095333
+      }
+    },
+    "B-whole": {
+      "n": 4618,
+      "fov_counts": {
+        "whole_body": 4618
+      },
+      "crop_any_pct": 5.110437418796016,
+      "crop_x_pct": 0.17323516673884798,
+      "crop_y_pct": 0.0,
+      "crop_z_pct": 5.08878302295366,
+      "phys_z_mm": {
+        "n": 4618,
+        "p0": 6.400000095367432,
+        "p1": 111.89624967575074,
+        "p5": 149.60000222921371,
+        "p10": 160.0000023841858,
+        "p25": 180.80000269412994,
+        "p50": 272.5,
+        "p75": 442.5,
+        "p90": 529.6500000000001,
+        "p95": 642.0749999999998,
+        "p99": 737.4899999999998,
+        "p100": 1416.0,
+        "mean": 320.42649326422816
+      },
+      "phys_y_mm": {
+        "n": 4618,
+        "p0": 132.8125,
+        "p1": 194.401271238327,
+        "p5": 219.10370013415815,
+        "p10": 231.5455386042595,
+        "p25": 257.0581171810627,
+        "p50": 286.5234375,
+        "p75": 317.0,
+        "p90": 348.6326933383942,
+        "p95": 371.57793331146235,
+        "p99": 412.51994140625,
+        "p100": 498.0466318130493,
+        "mean": 288.76436472084293
+      },
+      "phys_x_mm": {
+        "n": 4618,
+        "p0": 76.5,
+        "p1": 138.65625,
+        "p5": 160.0752939105034,
+        "p10": 279.38640136718755,
+        "p25": 342.0,
+        "p50": 377.27053755521774,
+        "p75": 418.0322718024254,
+        "p90": 485.0,
+        "p95": 510.0,
+        "p99": 512.0,
+        "p100": 641.2111611366272,
+        "mean": 371.9616504671474
+      },
+      "resampled_z_vox_at_bucket_sp": {
+        "n": 4618,
+        "p0": 1.2800000190734864,
+        "p1": 22.379249935150145,
+        "p5": 29.920000445842742,
+        "p10": 32.00000047683716,
+        "p25": 36.16000053882599,
+        "p50": 54.5,
+        "p75": 88.5,
+        "p90": 105.93000000000002,
+        "p95": 128.41499999999996,
+        "p99": 147.49799999999996,
+        "p100": 283.2,
+        "mean": 64.08529865284561
+      },
+      "resampled_y_vox_at_bucket_sp": {
+        "n": 4618,
+        "p0": 66.40625,
+        "p1": 97.2006356191635,
+        "p5": 109.55185006707907,
+        "p10": 115.77276930212975,
+        "p25": 128.52905859053135,
+        "p50": 143.26171875,
+        "p75": 158.5,
+        "p90": 174.3163466691971,
+        "p95": 185.78896665573117,
+        "p99": 206.259970703125,
+        "p100": 249.02331590652466,
+        "mean": 144.38218236042147
+      },
+      "resampled_x_vox_at_bucket_sp": {
+        "n": 4618,
+        "p0": 38.25,
+        "p1": 69.328125,
+        "p5": 80.0376469552517,
+        "p10": 139.69320068359377,
+        "p25": 171.0,
+        "p50": 188.63526877760887,
+        "p75": 209.0161359012127,
+        "p90": 242.5,
+        "p95": 255.0,
+        "p99": 256.0,
+        "p100": 320.6055805683136,
+        "mean": 185.9808252335737
+      }
+    }
+  },
+  "pancreas_bbox_summary": {
+    "n_with_bbox": 9442,
+    "bbox_x_mm": {
+      "n": 9442,
+      "p0": 0.0,
+      "p1": 31.5,
+      "p5": 66.6565435230732,
+      "p10": 89.3041875064373,
+      "p25": 114.75,
+      "p50": 133.0458984375,
+      "p75": 149.0625,
+      "p90": 164.93515624999998,
+      "p95": 175.78124570846558,
+      "p99": 199.0,
+      "p100": 310.5467233657837,
+      "mean": 129.76284700164322
+    },
+    "bbox_y_mm": {
+      "n": 9442,
+      "p0": 0.0,
+      "p1": 25.78125,
+      "p5": 41.69921875,
+      "p10": 48.8625,
+      "p25": 59.57228744029999,
+      "p50": 71.38672888278961,
+      "p75": 83.375,
+      "p90": 95.0,
+      "p95": 103.5,
+      "p99": 123.30349609375,
+      "p100": 190.5,
+      "mean": 71.87623691185125
+    },
+    "bbox_z_mm": {
+      "n": 9442,
+      "p0": 0.0,
+      "p1": 9.0,
+      "p5": 36.0,
+      "p10": 53.0,
+      "p25": 69.63494163751602,
+      "p50": 80.0000011920929,
+      "p75": 90.28357948362827,
+      "p90": 100.0,
+      "p95": 108.0,
+      "p99": 138.88500000000022,
+      "p100": 452.0,
+      "mean": 78.97999364715263
+    },
+    "padded_x_mm": {
+      "n": 9442,
+      "p0": 80.0,
+      "p1": 111.5,
+      "p5": 146.6565435230732,
+      "p10": 169.3041875064373,
+      "p25": 194.75,
+      "p50": 213.0458984375,
+      "p75": 229.0625,
+      "p90": 244.93515624999998,
+      "p95": 255.78124570846558,
+      "p99": 279.0,
+      "p100": 390.5467233657837,
+      "mean": 209.76284700164322
+    },
+    "padded_y_mm": {
+      "n": 9442,
+      "p0": 80.0,
+      "p1": 105.78125,
+      "p5": 121.69921875,
+      "p10": 128.8625,
+      "p25": 139.5722874403,
+      "p50": 151.3867288827896,
+      "p75": 163.375,
+      "p90": 175.0,
+      "p95": 183.5,
+      "p99": 203.30349609375,
+      "p100": 270.5,
+      "mean": 151.87623691185127
+    },
+    "padded_z_mm": {
+      "n": 9442,
+      "p0": 80.0,
+      "p1": 89.0,
+      "p5": 116.0,
+      "p10": 133.0,
+      "p25": 149.63494163751602,
+      "p50": 160.0000011920929,
+      "p75": 170.28357948362827,
+      "p90": 180.0,
+      "p95": 188.0,
+      "p99": 218.88500000000022,
+      "p100": 532.0,
+      "mean": 158.97999364715264
+    },
+    "fits_Bpan_pct": 7.8585045541198895,
+    "over_x_pct": 4.744757466638424,
+    "over_y_pct": 2.5524253336157594,
+    "over_z_pct": 91.81317517475111
+  }
+}

raw_pants_train_test/metadata/pants-captions-ldm/canonical/canonical_facts.jsonl

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

raw_pants_train_test/metadata/pants-captions-ldm/captions/captions_final.jsonl

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

raw_pants_train_test/metadata/pants-captions-ldm/captions/captions_v2_after_fusion.jsonl

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

raw_pants_train_test/metadata/pants-captions-ldm/code/cache/pants_wan22_cache.py

@@ -0,0 +1,761 @@
+#!/usr/bin/env python3
+"""Cache PanTS CT volumes as Wan2.2 VAE latents.
+
+The cache is intentionally split into latent tensors and JSONL manifests. Text
+embeddings can be added later without duplicating large VAE latents for every
+caption variant.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import nibabel as nib
+import numpy as np
+import torch
+from scipy import ndimage
+from safetensors.torch import save_file
+
+
+@dataclass(frozen=True)
+class Bucket:
+    bucket_id: str
+    view: str
+    fov: str
+    shape_zyx: tuple[int, int, int]
+    spacing_zyx: tuple[float, float, float]
+
+    @property
+    def latent_shape_cthw(self) -> tuple[int, int, int, int]:
+        d, h, w = self.shape_zyx
+        return (48, 1 + (d - 1) // 4, h // 16, w // 16)
+
+    @property
+    def dit_tokens(self) -> int:
+        _, t, h, w = self.latent_shape_cthw
+        return t * (h // 2) * (w // 2)
+
+
+BUCKETS: dict[str, Bucket] = {
+    "B-whole": Bucket("B-whole", "global", "whole_body", (153, 256, 256), (5.0, 2.0, 2.0)),
+    "B-CAP": Bucket("B-CAP", "global", "chest_abdomen_pelvis", (113, 320, 256), (4.0, 2.0, 2.0)),
+    "B-CA": Bucket("B-CA", "global", "chest_abdomen", (105, 320, 256), (3.5, 2.0, 2.0)),
+    "B-abd": Bucket("B-abd", "global", "abdomen_only", (105, 256, 256), (3.0, 2.0, 2.0)),
+    "B-abd-pelvis": Bucket("B-abd-pelvis", "global", "abdomen_pelvis", (113, 256, 256), (3.5, 2.0, 2.0)),
+    "P-pan": Bucket("P-pan", "pancreas", "pancreas_crop", (145, 224, 288), (1.5, 1.0, 1.0)),
+}
+
+WINDOWS_HU = {
+    # Keeps the broad CT density range, but compresses soft-tissue contrast.
+    "single_full": (-1000.0, 1000.0),
+    # Conventional abdomen / pancreatic soft-tissue display, about WW/WL 400/40.
+    "abdomen_soft": (-160.0, 240.0),
+    # Common pancreas segmentation preprocessing window for parenchyma contrast.
+    "pancreas_soft": (-100.0, 240.0),
+}
+
+FOV_TO_BUCKET = {
+    "whole_body": "B-whole",
+    "chest_abdomen_pelvis": "B-CAP",
+    "chest_abdomen": "B-CA",
+    "abdomen_only": "B-abd",
+    "abdomen_pelvis": "B-abd-pelvis",
+}
+
+GLOBAL_CAPTION_KEYS = (
+    "V1_long_narrative",
+    "V2_terse_impression",
+    "V3_organ_bullet",
+    "V4_tag_string",
+    "V5_layered_findings",
+)
+
+PANCREAS_CAPTION_KEYS = (
+    "V7_pancreas_only",
+    "V6_qa_pair",
+)
+
+VIEW_TEXT = {
+    "whole_body": "Whole-body CT volume.",
+    "chest_abdomen_pelvis": "Chest-abdomen-pelvis CT volume.",
+    "chest_abdomen": "Chest-abdomen CT volume.",
+    "abdomen_only": "Abdomen-only CT volume.",
+    "abdomen_pelvis": "Abdomen-pelvis CT volume.",
+    "pancreas_crop": "Pancreas-focused CT crop.",
+}
+
+WINDOW_TEXT = {
+    "single_full": "Broad CT HU window.",
+    "abdomen_soft": "Soft-tissue abdomen CT HU window.",
+    "pancreas_soft": "Soft-tissue pancreas CT HU window.",
+    "tri_window": "Multi-window CT input.",
+}
+
+FINAL_CAPTION_TEMPLATES = {
+    "whole_body": (
+        "A 3D CT volume with whole-body coverage.",
+        "Whole-body CT volume.",
+        "CT volume covering the whole body.",
+        "Wide-field whole-body CT scan.",
+    ),
+    "chest_abdomen_pelvis": (
+        "A 3D CT volume covering the chest, abdomen, and pelvis.",
+        "Chest-abdomen-pelvis CT volume.",
+        "CT scan with chest-to-pelvis coverage.",
+        "3D CT volume spanning chest, abdomen, and pelvis.",
+    ),
+    "chest_abdomen": (
+        "A 3D CT volume covering the chest and abdomen.",
+        "Chest-abdomen CT volume.",
+        "CT scan with chest-to-abdomen coverage.",
+        "3D CT volume spanning chest and abdomen.",
+    ),
+    "abdomen_only": (
+        "A 3D abdomen CT volume.",
+        "Abdomen-only CT volume.",
+        "CT scan focused on the abdomen.",
+        "3D CT volume with abdominal coverage.",
+    ),
+    "abdomen_pelvis": (
+        "A 3D CT volume covering the abdomen and pelvis.",
+        "Abdomen-pelvis CT volume.",
+        "CT scan with abdomen-to-pelvis coverage.",
+        "3D CT volume spanning abdomen and pelvis.",
+    ),
+    "pancreas_crop": (
+        "Pancreas-focused CT crop.",
+        "Cropped 3D CT volume centered on the pancreas.",
+        "Focused pancreatic-region CT view.",
+        "CT crop showing the pancreas region.",
+    ),
+}
+
+
+def load_jsonl(path: Path) -> dict[str, dict[str, Any]]:
+    out: dict[str, dict[str, Any]] = {}
+    with path.open() as f:
+        for line in f:
+            if not line.strip():
+                continue
+            item = json.loads(line)
+            out[item["id"]] = item
+    return out
+
+
+def load_splits(path: Path) -> dict[str, list[str]]:
+    with path.open() as f:
+        splits = json.load(f)
+    return {k: list(v) for k, v in splits.items()}
+
+
+def find_ct_path(pants_root: Path, case_id: str) -> Path | None:
+    for image_dir in ("ImageTr", "ImageTe"):
+        p = pants_root / image_dir / case_id / "ct.nii.gz"
+        if p.exists():
+            return p
+    return None
+
+
+def canonical_ct_zyx(path: Path) -> tuple[np.ndarray, tuple[float, float, float]]:
+    img = nib.as_closest_canonical(nib.load(str(path)))
+    data = np.asarray(img.get_fdata(dtype=np.float32), dtype=np.float32)
+    spacing_xyz = tuple(float(x) for x in img.header.get_zooms()[:3])
+    vol_zyx = np.transpose(data, (2, 1, 0))
+    spacing_zyx = (spacing_xyz[2], spacing_xyz[1], spacing_xyz[0])
+    return vol_zyx, spacing_zyx
+
+
+def bbox_center_zyx(fact: dict[str, Any], src_spacing_zyx: tuple[float, float, float],
+                    target_spacing_zyx: tuple[float, float, float]) -> tuple[float, float, float] | None:
+    bbox = fact.get("mask", {}).get("pancreas_bbox")
+    if not bbox:
+        return None
+    try:
+        center_xyz = (
+            0.5 * (float(bbox["x"][0]) + float(bbox["x"][1])),
+            0.5 * (float(bbox["y"][0]) + float(bbox["y"][1])),
+            0.5 * (float(bbox["z"][0]) + float(bbox["z"][1])),
+        )
+    except (KeyError, TypeError, ValueError):
+        return None
+    center_zyx_src = (center_xyz[2], center_xyz[1], center_xyz[0])
+    return tuple(
+        center_zyx_src[i] * src_spacing_zyx[i] / target_spacing_zyx[i]
+        for i in range(3)
+    )
+
+
+def resample_to_spacing(
+    vol_zyx: np.ndarray,
+    src_spacing_zyx: tuple[float, float, float],
+    dst_spacing_zyx: tuple[float, float, float],
+) -> np.ndarray:
+    zoom = tuple(src_spacing_zyx[i] / dst_spacing_zyx[i] for i in range(3))
+    return ndimage.zoom(vol_zyx, zoom=zoom, order=1, mode="nearest", prefilter=False).astype(np.float32, copy=False)
+
+
+def crop_or_pad(
+    vol: np.ndarray,
+    out_shape: tuple[int, int, int],
+    center: tuple[float, float, float] | None,
+    fill_value: float = -1000.0,
+) -> tuple[np.ndarray, tuple[int, int, int]]:
+    if center is None:
+        center = tuple((s - 1) / 2.0 for s in vol.shape)
+
+    starts = tuple(int(round(center[i] - (out_shape[i] - 1) / 2.0)) for i in range(3))
+    out = np.full(out_shape, fill_value, dtype=np.float32)
+
+    src_slices = []
+    dst_slices = []
+    for axis, start in enumerate(starts):
+        end = start + out_shape[axis]
+        src0 = max(start, 0)
+        src1 = min(end, vol.shape[axis])
+        dst0 = max(-start, 0)
+        dst1 = dst0 + max(src1 - src0, 0)
+        src_slices.append(slice(src0, src1))
+        dst_slices.append(slice(dst0, dst1))
+
+    if all(s.stop > s.start for s in src_slices):
+        out[tuple(dst_slices)] = vol[tuple(src_slices)]
+    return out, starts
+
+
+def window_to_model_input(vol_hu: np.ndarray, mode: str) -> np.ndarray:
+    if mode in WINDOWS_HU:
+        lo, hi = WINDOWS_HU[mode]
+        x = np.clip(vol_hu, lo, hi)
+        x = (x - lo) / (hi - lo) * 2.0 - 1.0
+        return np.repeat(x[None, ...], 3, axis=0).astype(np.float32, copy=False)
+
+    if mode == "tri_window":
+        windows = [(-1000.0, 400.0), (-160.0, 240.0), (-500.0, 1000.0)]
+        channels = []
+        for lo, hi in windows:
+            y = np.clip(vol_hu, lo, hi)
+            y = (y - lo) / (hi - lo) * 2.0 - 1.0
+            channels.append(y.astype(np.float32, copy=False))
+        return np.stack(channels, axis=0)
+
+    raise ValueError(f"unknown window mode: {mode}")
+
+
+def window_mode_for_bucket(bucket: Bucket, global_window_mode: str, pancreas_window_mode: str) -> str:
+    return pancreas_window_mode if bucket.view == "pancreas" else global_window_mode
+
+
+def available_captions(caption_row: dict[str, Any], keys: tuple[str, ...]) -> dict[str, str]:
+    captions = caption_row.get("captions", {})
+    return {k: captions[k] for k in keys if k in captions and captions[k]}
+
+
+def fallback_pancreas_caption(caption_row: dict[str, Any], fact: dict[str, Any]) -> str:
+    cond = caption_row.get("cond", {})
+    canonical = fact.get("canonical", {})
+    phase = cond.get("phase") or canonical.get("phase") or "CT"
+    volume = cond.get("pancreas_volume_cc") or canonical.get("pancreas_volume_cc")
+    lesion_present = bool(cond.get("lesion_present") or canonical.get("lesion_present"))
+    if lesion_present:
+        return f"{phase} pancreas-focused CT crop with a reported pancreatic lesion."
+    if volume is not None:
+        return f"{phase} pancreas-focused CT crop without a reported focal pancreatic lesion; pancreas volume is about {volume:.1f} cc."
+    return f"{phase} pancreas-focused CT crop without a reported focal pancreatic lesion."
+
+
+def text_conditioning_for_row(row: dict[str, Any], bucket: Bucket) -> dict[str, str]:
+    view_text = VIEW_TEXT.get(bucket.fov, f"{bucket.fov.replace('_', '-')} CT volume.")
+    window_mode = str(row.get("window_mode") or "")
+    window_text = WINDOW_TEXT.get(window_mode, "")
+    return {
+        "view_text": view_text,
+        "window_text": window_text,
+        "default_prefix": view_text,
+        "with_window_prefix": " ".join(x for x in (view_text, window_text) if x),
+    }
+
+
+def stable_index(parts: tuple[str, ...], n: int) -> int:
+    key = "||".join(parts).encode("utf-8")
+    digest = hashlib.blake2b(key, digest_size=4).digest()
+    return int.from_bytes(digest, "little") % n
+
+
+def normalize_caption_text(text: str) -> str:
+    text = " ".join(str(text).split())
+    if text and text[-1] not in ".!?":
+        text += "."
+    return text
+
+
+def render_final_caption(row: dict[str, Any], bucket: Bucket, caption_key: str, caption: str) -> tuple[str, str]:
+    templates = FINAL_CAPTION_TEMPLATES.get(bucket.fov, (VIEW_TEXT.get(bucket.fov, "3D CT volume."),))
+    template = templates[stable_index((row["case_id"], row["bucket_id"], caption_key), len(templates))]
+    body = normalize_caption_text(caption)
+    lower_body = body.lower()
+    if body.startswith(template):
+        return body, template
+    if bucket.view == "pancreas" and "pancreas-focused ct crop" in lower_body[:120]:
+        return body, template
+    return f"{template} {body}".strip(), template
+
+
+def build_caption_rows(rows: list[dict[str, Any]], source_split: str) -> list[dict[str, Any]]:
+    caption_rows: list[dict[str, Any]] = []
+    for row in rows:
+        if row.get("status") not in ("ok", "exists"):
+            continue
+        bucket = BUCKETS.get(row.get("bucket_id", ""))
+        if bucket is None:
+            continue
+        captions = row.get("captions") or {}
+        for caption_key, caption in captions.items():
+            final_caption, template = render_final_caption(row, bucket, caption_key, caption)
+            caption_rows.append({
+                "id": f"{row['case_id']}__{row['bucket_id']}__{caption_key}",
+                "source_split": source_split,
+                "case_id": row["case_id"],
+                "bucket_id": row["bucket_id"],
+                "view": row.get("view"),
+                "fov": row.get("fov"),
+                "phase": row.get("phase"),
+                "lesion_present": row.get("lesion_present"),
+                "latent_path": row.get("latent_path"),
+                "latent_shape": row.get("latent_shape"),
+                "pixel_shape_zyx": row.get("pixel_shape_zyx"),
+                "target_spacing_zyx": row.get("target_spacing_zyx"),
+                "window_mode": row.get("window_mode"),
+                "window_hu": row.get("window_hu"),
+                "dit_tokens": row.get("dit_tokens"),
+                "caption_key": caption_key,
+                "caption_template": template,
+                "caption": final_caption,
+            })
+    caption_rows.sort(key=lambda r: (r["case_id"], r["bucket_id"], r["caption_key"]))
+    return caption_rows
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w") as f:
+        for row in rows:
+            f.write(json.dumps(row, sort_keys=True) + "\n")
+
+
+def iter_tasks(
+    split_names: list[str],
+    splits: dict[str, list[str]],
+    facts: dict[str, dict[str, Any]],
+    captions: dict[str, dict[str, Any]],
+    pants_root: Path,
+    include_global: bool,
+    include_pancreas: bool,
+) -> list[dict[str, Any]]:
+    tasks: list[dict[str, Any]] = []
+    for split in split_names:
+        for case_id in splits[split]:
+            fact = facts.get(case_id)
+            cap = captions.get(case_id)
+            if fact is None or cap is None:
+                continue
+            ct_path = find_ct_path(pants_root, case_id)
+            if ct_path is None:
+                continue
+
+            canonical = fact.get("canonical", {})
+            mask = fact.get("mask", {})
+            fov = canonical.get("fov") or mask.get("fov")
+            if include_global and fov in FOV_TO_BUCKET:
+                bucket = BUCKETS[FOV_TO_BUCKET[fov]]
+                tasks.append({"split": split, "case_id": case_id, "bucket": bucket, "ct_path": ct_path})
+
+            if include_pancreas and mask.get("pancreas_bbox"):
+                tasks.append({"split": split, "case_id": case_id, "bucket": BUCKETS["P-pan"], "ct_path": ct_path})
+    return tasks
+
+
+def load_vae(model_path: str, dtype: torch.dtype, device: torch.device):
+    from diffusers import AutoencoderKLWan
+
+    vae = AutoencoderKLWan.from_pretrained(
+        model_path,
+        subfolder="vae",
+        torch_dtype=dtype,
+        local_files_only=True,
+    )
+    vae.eval().to(device)
+    vae.requires_grad_(False)
+    return vae
+
+
+def dtype_from_name(name: str) -> torch.dtype:
+    if name == "bf16":
+        return torch.bfloat16
+    if name == "fp16":
+        return torch.float16
+    if name == "fp32":
+        return torch.float32
+    raise ValueError(name)
+
+
+def relpath(path: Path, root: Path) -> str:
+    return str(path.relative_to(root))
+
+
+def encode_one(
+    task: dict[str, Any],
+    fact: dict[str, Any],
+    caption_row: dict[str, Any],
+    vae,
+    device: torch.device,
+    vae_dtype: torch.dtype,
+    store_dtype: torch.dtype,
+    output_root: Path,
+    global_window_mode: str,
+    pancreas_window_mode: str,
+    overwrite: bool,
+) -> dict[str, Any]:
+    bucket: Bucket = task["bucket"]
+    split = task["split"]
+    case_id = task["case_id"]
+    out_dir = output_root / "latents" / split / bucket.bucket_id
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / f"{case_id}__{bucket.bucket_id}.safetensors"
+    if out_path.exists() and not overwrite:
+        return {
+            "split": split,
+            "case_id": case_id,
+            "bucket_id": bucket.bucket_id,
+            "view": bucket.view,
+            "latent_path": relpath(out_path, output_root),
+            "status": "exists",
+        }
+
+    vol, src_spacing = canonical_ct_zyx(task["ct_path"])
+    resampled = resample_to_spacing(vol, src_spacing, bucket.spacing_zyx)
+    center = bbox_center_zyx(fact, src_spacing, bucket.spacing_zyx)
+    crop, crop_origin = crop_or_pad(resampled, bucket.shape_zyx, center=center)
+    window_mode = window_mode_for_bucket(bucket, global_window_mode, pancreas_window_mode)
+    channels = window_to_model_input(crop, window_mode)
+
+    x = torch.from_numpy(channels).unsqueeze(0).to(device=device, dtype=vae_dtype)
+    with torch.inference_mode():
+        if vae_dtype == torch.float32:
+            posterior = vae.encode(x).latent_dist
+        else:
+            with torch.autocast(device_type="cuda", dtype=vae_dtype):
+                posterior = vae.encode(x).latent_dist
+        latent = posterior.mean.squeeze(0).detach().to(dtype=store_dtype, device="cpu")
+
+    tmp_path = out_path.with_suffix(".tmp.safetensors")
+    save_file(
+        {"latent": latent.contiguous()},
+        str(tmp_path),
+        metadata={
+            "case_id": case_id,
+            "bucket_id": bucket.bucket_id,
+            "split": split,
+            "latent_kind": "wan22_vae_raw_mean_unscaled",
+            "window_mode": window_mode,
+        },
+    )
+    os.replace(tmp_path, out_path)
+
+    if bucket.view == "pancreas":
+        caps = available_captions(caption_row, PANCREAS_CAPTION_KEYS)
+        if not caps:
+            caps = {"V7_pancreas_only_fallback": fallback_pancreas_caption(caption_row, fact)}
+    else:
+        caps = available_captions(caption_row, GLOBAL_CAPTION_KEYS)
+
+    canonical = fact.get("canonical", {})
+    mask = fact.get("mask", {})
+    row = {
+        "split": split,
+        "case_id": case_id,
+        "bucket_id": bucket.bucket_id,
+        "view": bucket.view,
+        "fov": canonical.get("fov") or mask.get("fov"),
+        "phase": canonical.get("phase"),
+        "lesion_present": bool(canonical.get("lesion_present")),
+        "ct_path": str(task["ct_path"]),
+        "latent_path": relpath(out_path, output_root),
+        "latent_shape": list(latent.shape),
+        "latent_dtype": str(latent.dtype).replace("torch.", ""),
+        "pixel_shape_zyx": list(bucket.shape_zyx),
+        "target_spacing_zyx": list(bucket.spacing_zyx),
+        "source_spacing_zyx": list(src_spacing),
+        "resampled_shape_zyx": list(resampled.shape),
+        "crop_origin_zyx": list(crop_origin),
+        "window_mode": window_mode,
+        "window_hu": list(WINDOWS_HU.get(window_mode, (math.nan, math.nan))),
+        "dit_tokens": bucket.dit_tokens,
+        "caption_keys": list(caps.keys()),
+        "captions": caps,
+        "status": "ok",
+    }
+    row["text_conditioning"] = text_conditioning_for_row(row, bucket)
+    return row
+
+
+def refresh_caption_fields(
+    row: dict[str, Any],
+    facts: dict[str, dict[str, Any]] | None,
+    captions: dict[str, dict[str, Any]] | None,
+) -> dict[str, Any]:
+    if row.get("status") not in ("ok", "exists"):
+        return row
+    if facts is None or captions is None:
+        return row
+    case_id = row.get("case_id")
+    bucket_id = row.get("bucket_id")
+    if not case_id or not bucket_id or case_id not in facts or case_id not in captions:
+        return row
+    bucket = BUCKETS.get(bucket_id)
+    if bucket is None:
+        return row
+    if bucket.view == "pancreas":
+        caps = available_captions(captions[case_id], PANCREAS_CAPTION_KEYS)
+        if not caps:
+            caps = {"V7_pancreas_only_fallback": fallback_pancreas_caption(captions[case_id], facts[case_id])}
+    else:
+        caps = available_captions(captions[case_id], GLOBAL_CAPTION_KEYS)
+    row["caption_keys"] = list(caps.keys())
+    row["captions"] = caps
+    row["text_conditioning"] = text_conditioning_for_row(row, bucket)
+    return row
+
+
+def merge_manifests(output_root: Path) -> None:
+    parts_dir = output_root / "manifests" / "parts"
+    merged_dir = output_root / "manifests"
+    merged_dir.mkdir(parents=True, exist_ok=True)
+    project_root = output_root.parent.parent
+    facts = captions = None
+    try:
+        facts = load_jsonl(project_root / "canonical" / "canonical_facts.jsonl")
+        captions = load_jsonl(project_root / "captions" / "captions_final.jsonl")
+    except FileNotFoundError:
+        pass
+    merged_by_split: dict[str, list[dict[str, Any]]] = {}
+    for split in ("train", "val", "test"):
+        part_files = sorted(parts_dir.glob(f"{split}.rank*.jsonl"))
+        if not part_files:
+            continue
+        rows: list[dict[str, Any]] = []
+        for p in part_files:
+            with p.open() as f:
+                for line in f:
+                    if line.strip():
+                        rows.append(refresh_caption_fields(json.loads(line), facts, captions))
+        rows.sort(key=lambda r: (r.get("case_id", ""), r.get("bucket_id", "")))
+        merged_by_split[split] = rows
+        out = merged_dir / f"{split}.jsonl"
+        write_jsonl(out, rows)
+        print(f"merged {len(rows)} rows -> {out}", flush=True)
+
+    source_splits = {
+        "source_train": merged_by_split.get("train", []) + merged_by_split.get("val", []),
+        "source_test": merged_by_split.get("test", []),
+    }
+    caption_dir = output_root / "captions"
+    for source_split, rows in source_splits.items():
+        if not rows:
+            continue
+        rows = sorted(rows, key=lambda r: (r.get("case_id", ""), r.get("bucket_id", "")))
+        manifest_out = merged_dir / f"{source_split}.jsonl"
+        write_jsonl(manifest_out, rows)
+        print(f"merged {len(rows)} rows -> {manifest_out}", flush=True)
+
+        caption_rows = build_caption_rows(rows, source_split)
+        caption_out = caption_dir / f"{source_split}.jsonl"
+        write_jsonl(caption_out, caption_rows)
+        print(f"wrote {len(caption_rows)} caption rows -> {caption_out}", flush=True)
+
+
+def write_cache_config(output_root: Path, args: argparse.Namespace) -> None:
+    cfg = {
+        "created_unix": time.time(),
+        "model_path": args.model_path,
+        "window_mode": args.window_mode,
+        "global_window_mode": args.global_window_mode,
+        "pancreas_window_mode": args.pancreas_window_mode,
+        "store_dtype": args.store_dtype,
+        "vae_dtype": args.vae_dtype,
+        "buckets": {
+            k: {
+                "shape_zyx": list(v.shape_zyx),
+                "spacing_zyx": list(v.spacing_zyx),
+                "latent_shape_cthw": list(v.latent_shape_cthw),
+                "dit_tokens": v.dit_tokens,
+                "view": v.view,
+                "fov": v.fov,
+            }
+            for k, v in BUCKETS.items()
+        },
+    }
+    with (output_root / "cache_config.json").open("w") as f:
+        json.dump(cfg, f, indent=2, sort_keys=True)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pants-root", type=Path, required=True)
+    parser.add_argument("--project-root", type=Path, required=True)
+    parser.add_argument("--model-path", type=str, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--splits", default="train,val,test")
+    parser.add_argument("--include-global", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--include-pancreas", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument(
+        "--window-mode",
+        choices=["single_full", "abdomen_soft", "pancreas_soft", "tri_window"],
+        default=None,
+        help="Legacy override: use the same window for all buckets.",
+    )
+    parser.add_argument(
+        "--global-window-mode",
+        choices=["single_full", "abdomen_soft", "pancreas_soft", "tri_window"],
+        default="abdomen_soft",
+    )
+    parser.add_argument(
+        "--pancreas-window-mode",
+        choices=["single_full", "abdomen_soft", "pancreas_soft", "tri_window"],
+        default="pancreas_soft",
+    )
+    parser.add_argument("--vae-dtype", choices=["bf16", "fp16", "fp32"], default="bf16")
+    parser.add_argument("--store-dtype", choices=["bf16", "fp16", "fp32"], default="bf16")
+    parser.add_argument("--rank", type=int, default=None)
+    parser.add_argument("--world-size", type=int, default=None)
+    parser.add_argument("--limit", type=int, default=0)
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--merge-only", action="store_true")
+    parser.add_argument("--num-threads", type=int, default=8)
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    if args.window_mode is not None:
+        args.global_window_mode = args.window_mode
+        args.pancreas_window_mode = args.window_mode
+    args.output_root.mkdir(parents=True, exist_ok=True)
+    if args.merge_only:
+        merge_manifests(args.output_root)
+        return 0
+
+    rank = args.rank
+    if rank is None:
+        rank = int(os.environ.get("SLURM_PROCID", os.environ.get("RANK", "0")))
+    world_size = args.world_size
+    if world_size is None:
+        world_size = int(os.environ.get("SLURM_NTASKS", os.environ.get("WORLD_SIZE", "1")))
+
+    torch.set_num_threads(max(1, args.num_threads))
+    if torch.cuda.is_available():
+        device = torch.device("cuda")
+        torch.cuda.set_device(0)
+    else:
+        device = torch.device("cpu")
+
+    facts = load_jsonl(args.project_root / "canonical" / "canonical_facts.jsonl")
+    captions = load_jsonl(args.project_root / "captions" / "captions_final.jsonl")
+    splits = load_splits(args.project_root / "splits" / "splits.json")
+    split_names = [x for x in args.splits.split(",") if x]
+
+    tasks = iter_tasks(
+        split_names=split_names,
+        splits=splits,
+        facts=facts,
+        captions=captions,
+        pants_root=args.pants_root,
+        include_global=args.include_global,
+        include_pancreas=args.include_pancreas,
+    )
+    tasks = [task for i, task in enumerate(tasks) if i % world_size == rank]
+    if args.limit > 0:
+        tasks = tasks[: args.limit]
+
+    if rank == 0:
+        write_cache_config(args.output_root, args)
+
+    parts_dir = args.output_root / "manifests" / "parts"
+    parts_dir.mkdir(parents=True, exist_ok=True)
+    part_paths = {split: parts_dir / f"{split}.rank{rank:04d}.jsonl" for split in split_names}
+    part_handles = {split: part_paths[split].open("w") for split in split_names}
+
+    vae = load_vae(args.model_path, dtype_from_name(args.vae_dtype), device)
+    store_dtype = dtype_from_name(args.store_dtype)
+    vae_dtype = dtype_from_name(args.vae_dtype)
+
+    print(
+        f"rank {rank}/{world_size}: {len(tasks)} tasks, device={device}, "
+        f"vae_dtype={args.vae_dtype}, store_dtype={args.store_dtype}",
+        flush=True,
+    )
+
+    started = time.time()
+    ok = 0
+    failed = 0
+    try:
+        for idx, task in enumerate(tasks, start=1):
+            case_id = task["case_id"]
+            split = task["split"]
+            bucket: Bucket = task["bucket"]
+            try:
+                row = encode_one(
+                    task=task,
+                    fact=facts[case_id],
+                    caption_row=captions[case_id],
+                    vae=vae,
+                    device=device,
+                    vae_dtype=vae_dtype,
+                    store_dtype=store_dtype,
+                    output_root=args.output_root,
+                    global_window_mode=args.global_window_mode,
+                    pancreas_window_mode=args.pancreas_window_mode,
+                    overwrite=args.overwrite,
+                )
+                ok += 1
+            except Exception as exc:  # keep the long cache job moving
+                failed += 1
+                row = {
+                    "split": split,
+                    "case_id": case_id,
+                    "bucket_id": bucket.bucket_id,
+                    "status": "error",
+                    "error": repr(exc),
+                }
+                print(f"rank {rank}: ERROR {case_id} {bucket.bucket_id}: {exc!r}", file=sys.stderr, flush=True)
+
+            part_handles[split].write(json.dumps(row, sort_keys=True) + "\n")
+            part_handles[split].flush()
+
+            if idx == 1 or idx % 25 == 0:
+                elapsed = max(time.time() - started, 1e-6)
+                rate = idx / elapsed
+                remaining = (len(tasks) - idx) / max(rate, 1e-6)
+                print(
+                    f"rank {rank}: {idx}/{len(tasks)} done "
+                    f"ok={ok} failed={failed} rate={rate:.3f}/s eta={remaining/60:.1f}m",
+                    flush=True,
+                )
+    finally:
+        for handle in part_handles.values():
+            handle.close()
+
+    print(f"rank {rank}: finished ok={ok} failed={failed}", flush=True)
+    return 0 if failed == 0 else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

raw_pants_train_test/metadata/pants-captions-ldm/code/cache/pants_wan22_decode_check.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Decode-check one PanTS Wan2.2 latent against its preprocessed CT crop."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+from PIL import Image, ImageDraw
+from safetensors.torch import load_file
+
+
+def load_cache_module(path: Path):
+    spec = importlib.util.spec_from_file_location("pants_wan22_cache", path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot import {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cache-script", type=Path, required=True)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--model-path", type=str, required=True)
+    parser.add_argument("--case-id", default="")
+    parser.add_argument("--bucket-id", default="")
+    parser.add_argument("--out-png", type=Path, required=True)
+    parser.add_argument("--vae-dtype", choices=["bf16", "fp16", "fp32"], default="bf16")
+    return parser.parse_args()
+
+
+def read_row(path: Path, case_id: str, bucket_id: str):
+    with path.open() as f:
+        for line in f:
+            if not line.strip():
+                continue
+            row = json.loads(line)
+            if case_id and row.get("case_id") != case_id:
+                continue
+            if bucket_id and row.get("bucket_id") != bucket_id:
+                continue
+            if row.get("status") in ("ok", "exists"):
+                return row
+    raise RuntimeError(f"no matching row in {path}")
+
+
+def to_u8(x: np.ndarray) -> np.ndarray:
+    x = np.asarray(x, dtype=np.float32)
+    x = np.clip((x + 1.0) * 0.5, 0.0, 1.0)
+    return (x * 255.0 + 0.5).astype(np.uint8)
+
+
+def diff_u8(x: np.ndarray, scale: float = 4.0) -> np.ndarray:
+    x = np.clip(np.abs(x) * scale, 0.0, 1.0)
+    return (x * 255.0 + 0.5).astype(np.uint8)
+
+
+def save_panel(input_vol: np.ndarray, decoded_vol: np.ndarray, out_png: Path, title: str):
+    z = input_vol.shape[0] // 2
+    panels = [
+        ("input", to_u8(input_vol[z])),
+        ("decode_avg", to_u8(decoded_vol[z])),
+        ("abs_diff_x4", diff_u8(decoded_vol[z] - input_vol[z])),
+    ]
+    h, w = panels[0][1].shape
+    label_h = 28
+    canvas = Image.new("RGB", (w * len(panels), h + label_h), "white")
+    draw = ImageDraw.Draw(canvas)
+    for i, (label, arr) in enumerate(panels):
+        img = Image.fromarray(arr, mode="L").convert("RGB")
+        canvas.paste(img, (i * w, label_h))
+        draw.text((i * w + 8, 8), label, fill=(0, 0, 0))
+    draw.text((8, h + label_h - 18), title, fill=(255, 255, 255))
+    out_png.parent.mkdir(parents=True, exist_ok=True)
+    canvas.save(out_png)
+
+
+def main() -> int:
+    args = parse_args()
+    cache = load_cache_module(args.cache_script)
+    row = read_row(args.manifest, args.case_id, args.bucket_id)
+
+    bucket = cache.BUCKETS[row["bucket_id"]]
+    vol, src_spacing = cache.canonical_ct_zyx(Path(row["ct_path"]))
+    facts = cache.load_jsonl(args.cache_script.parents[2] / "canonical" / "canonical_facts.jsonl")
+    center = cache.bbox_center_zyx(facts[row["case_id"]], src_spacing, bucket.spacing_zyx)
+    resampled = cache.resample_to_spacing(vol, src_spacing, bucket.spacing_zyx)
+    crop, _ = cache.crop_or_pad(resampled, bucket.shape_zyx, center=center)
+    window_mode = row.get("window_mode", "single_full")
+    input_chw = cache.window_to_model_input(crop, window_mode)
+    input_vol = input_chw[0]
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    vae_dtype = cache.dtype_from_name(args.vae_dtype)
+    vae = cache.load_vae(args.model_path, vae_dtype, device)
+    latent = load_file(str(args.output_root / row["latent_path"]))["latent"].unsqueeze(0).to(device=device, dtype=vae_dtype)
+    with torch.inference_mode():
+        with torch.autocast(device_type="cuda", dtype=vae_dtype, enabled=(device.type == "cuda" and vae_dtype != torch.float32)):
+            decoded = vae.decode(latent).sample
+    decoded = decoded.squeeze(0).float().cpu().numpy()
+    decoded_avg = decoded.mean(axis=0)
+
+    if decoded_avg.shape != input_vol.shape:
+        raise RuntimeError(f"decoded shape {decoded_avg.shape} != input shape {input_vol.shape}")
+
+    err = decoded_avg - input_vol
+    ch_std = decoded.std(axis=0)
+    corr = float(np.corrcoef(input_vol.reshape(-1), decoded_avg.reshape(-1))[0, 1])
+    stats = {
+        "case_id": row["case_id"],
+        "bucket_id": row["bucket_id"],
+        "latent_shape": row["latent_shape"],
+        "window_mode": window_mode,
+        "window_hu": row.get("window_hu"),
+        "input_shape": list(input_vol.shape),
+        "decoded_shape_3ch": list(decoded.shape),
+        "decoded_avg_shape": list(decoded_avg.shape),
+        "mae": float(np.mean(np.abs(err))),
+        "rmse": float(np.sqrt(np.mean(err * err))),
+        "corr": corr,
+        "decoded_channel_std_mean": float(ch_std.mean()),
+        "decoded_channel_std_p99": float(np.quantile(ch_std, 0.99)),
+        "png": str(args.out_png),
+    }
+    save_panel(
+        input_vol=input_vol,
+        decoded_vol=decoded_avg,
+        out_png=args.out_png,
+        title=f"{row['case_id']} {row['bucket_id']} z={input_vol.shape[0] // 2}",
+    )
+    print(json.dumps(stats, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

raw_pants_train_test/metadata/pants-captions-ldm/code/cache/pants_wan22_text_cache.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""Cache Wan2.2 text embeddings for PanTS caption rows."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import torch
+from safetensors.torch import save_file
+from tqdm import tqdm
+
+
+def load_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open() as f:
+        for line in f:
+            if line.strip():
+                rows.append(json.loads(line))
+    return rows
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w") as f:
+        for row in rows:
+            f.write(json.dumps(row, sort_keys=True) + "\n")
+
+
+def dtype_from_name(name: str) -> torch.dtype:
+    if name == "bf16":
+        return torch.bfloat16
+    if name == "fp16":
+        return torch.float16
+    if name == "fp32":
+        return torch.float32
+    raise ValueError(name)
+
+
+def relpath(path: Path, root: Path) -> str:
+    return str(path.relative_to(root))
+
+
+def encode_caption(
+    caption: str,
+    tokenizer,
+    text_encoder,
+    device: torch.device,
+    max_length: int,
+    store_dtype: torch.dtype,
+) -> tuple[torch.Tensor, int]:
+    inputs = tokenizer(
+        caption,
+        padding="max_length",
+        max_length=max_length,
+        truncation=True,
+        add_special_tokens=True,
+        return_attention_mask=True,
+        return_tensors="pt",
+    )
+    attention_mask = inputs["attention_mask"][0]
+    seq_len = int(attention_mask.gt(0).sum().item())
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    with torch.inference_mode():
+        hidden = text_encoder(**inputs).last_hidden_state[0, :seq_len]
+    return hidden.detach().to(dtype=store_dtype, device="cpu").contiguous(), seq_len
+
+
+def process_split(args: argparse.Namespace, split: str, tokenizer, text_encoder, device: torch.device) -> None:
+    src_path = args.cache_root / "captions" / f"{split}.jsonl"
+    rows = load_jsonl(src_path)
+    if args.limit:
+        rows = rows[: args.limit]
+
+    part_path = args.cache_root / "captions_embedded" / "parts" / f"{split}.rank{args.rank:03d}.jsonl"
+    part_path.parent.mkdir(parents=True, exist_ok=True)
+
+    store_dtype = dtype_from_name(args.store_dtype)
+    my_rows = [row for i, row in enumerate(rows) if i % args.world_size == args.rank]
+    out_rows: list[dict[str, Any]] = []
+
+    iterator = tqdm(my_rows, disable=args.rank != 0, desc=f"{split} rank {args.rank}")
+    for row in iterator:
+        out_dir = args.cache_root / "text_embeddings" / split / row["bucket_id"]
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / f"{row['id']}.safetensors"
+
+        if out_path.exists() and not args.overwrite:
+            emb_shape = row.get("text_embedding_shape")
+            token_count = row.get("text_token_count")
+        else:
+            emb, token_count = encode_caption(
+                row["caption"],
+                tokenizer,
+                text_encoder,
+                device,
+                args.max_length,
+                store_dtype,
+            )
+            emb_shape = list(emb.shape)
+            tmp_path = out_path.with_suffix(".tmp.safetensors")
+            save_file(
+                {"text_embedding": emb},
+                str(tmp_path),
+                metadata={
+                    "id": row["id"],
+                    "case_id": row["case_id"],
+                    "bucket_id": row["bucket_id"],
+                    "caption_key": row["caption_key"],
+                    "embedding_kind": "wan22_umt5_last_hidden_state_unpadded",
+                    "store_dtype": args.store_dtype,
+                    "max_length": str(args.max_length),
+                },
+            )
+            os.replace(tmp_path, out_path)
+
+        new_row = dict(row)
+        new_row["text_embedding_path"] = relpath(out_path, args.cache_root)
+        new_row["text_embedding_shape"] = emb_shape
+        new_row["text_embedding_dtype"] = args.store_dtype
+        new_row["text_token_count"] = token_count
+        out_rows.append(new_row)
+
+    write_jsonl(part_path, out_rows)
+    print(f"rank {args.rank}: wrote {len(out_rows)} rows -> {part_path}", flush=True)
+
+
+def merge_splits(cache_root: Path, splits: list[str]) -> None:
+    parts_dir = cache_root / "captions_embedded" / "parts"
+    out_dir = cache_root / "captions_embedded"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for split in splits:
+        rows: list[dict[str, Any]] = []
+        for part_path in sorted(parts_dir.glob(f"{split}.rank*.jsonl")):
+            rows.extend(load_jsonl(part_path))
+        rows.sort(key=lambda r: (r["case_id"], r["bucket_id"], r["caption_key"]))
+        out_path = out_dir / f"{split}.jsonl"
+        write_jsonl(out_path, rows)
+        print(f"merged {len(rows)} rows -> {out_path}", flush=True)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cache-root", type=Path, required=True)
+    parser.add_argument("--text-model-root", type=Path, required=True)
+    parser.add_argument("--splits", nargs="+", default=["source_train", "source_test"])
+    parser.add_argument("--rank", type=int, default=0)
+    parser.add_argument("--world-size", type=int, default=1)
+    parser.add_argument("--max-length", type=int, default=512)
+    parser.add_argument("--text-dtype", choices=["bf16", "fp16", "fp32"], default="bf16")
+    parser.add_argument("--store-dtype", choices=["bf16", "fp16", "fp32"], default="bf16")
+    parser.add_argument("--limit", type=int, default=0)
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--merge-only", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    if args.merge_only:
+        merge_splits(args.cache_root, args.splits)
+        return
+
+    from transformers import T5TokenizerFast, UMT5EncoderModel
+
+    torch.set_num_threads(max(1, int(os.environ.get("OMP_NUM_THREADS", "1"))))
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    text_dtype = dtype_from_name(args.text_dtype)
+    tokenizer = T5TokenizerFast.from_pretrained(args.text_model_root / "tokenizer", local_files_only=True)
+    text_encoder = UMT5EncoderModel.from_pretrained(
+        args.text_model_root / "text_encoder",
+        torch_dtype=text_dtype,
+        local_files_only=True,
+    ).eval().to(device)
+    text_encoder.requires_grad_(False)
+
+    for split in args.splits:
+        process_split(args, split, tokenizer, text_encoder, device)
+
+
+if __name__ == "__main__":
+    main()

raw_pants_train_test/metadata/pants-captions-ldm/code/cache/run_pants_wan22_cache_8gpu.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PROJECT_ROOT=/scratch/user/yuhwang/dataset/pants-captions-ldm
+PANTS_ROOT=/scratch/user/yuhwang/dataset/PanTS/data
+MODEL_PATH=/scratch/user/yuhwang/model/hf-cache/models--Wan-AI--Wan2.2-TI2V-5B-Diffusers/snapshots/b8fff7315c768468a5333511427288870b2e9635
+OUTPUT_ROOT=${PROJECT_ROOT}/cache/wan22_pants_v2_softwin
+SCRIPT=${PROJECT_ROOT}/code/cache/pants_wan22_cache.py
+LOG_DIR=${PROJECT_ROOT}/cache/logs
+LOG=${LOG_DIR}/wan22_pants_v2_softwin_$(date +%Y%m%d_%H%M%S).log
+
+mkdir -p "${LOG_DIR}"
+cd "${PROJECT_ROOT}"
+
+set +e
+srun --jobid=524904 --overlap \
+  --nodes=1 --ntasks=8 --cpus-per-task=20 \
+  bash -lc '
+    source ~/.twoframe_env.sh >/dev/null 2>&1 || true
+    conda activate /scratch/user/yuhwang/envs/twoframe >/dev/null 2>&1 || true
+    export CUDA_VISIBLE_DEVICES=${SLURM_LOCALID}
+    export OMP_NUM_THREADS=8
+    export HF_HOME=/scratch/user/yuhwang/model/hf-cache
+    python '"${SCRIPT}"' \
+      --pants-root '"${PANTS_ROOT}"' \
+      --project-root '"${PROJECT_ROOT}"' \
+      --model-path '"${MODEL_PATH}"' \
+      --output-root '"${OUTPUT_ROOT}"' \
+      --splits train,val,test \
+      --rank ${SLURM_PROCID} \
+      --world-size ${SLURM_NTASKS} \
+      --num-threads 8
+  ' 2>&1 | tee -a "${LOG}"
+status=${PIPESTATUS[0]}
+set -e
+
+source ~/.twoframe_env.sh >/dev/null 2>&1 || true
+conda activate /scratch/user/yuhwang/envs/twoframe >/dev/null 2>&1 || true
+python "${SCRIPT}" --output-root "${OUTPUT_ROOT}" --merge-only 2>&1 | tee -a "${LOG}"
+
+echo "cache run finished with status ${status}; log=${LOG}" | tee -a "${LOG}"
+exit "${status}"

raw_pants_train_test/metadata/pants-captions-ldm/code/cache/run_pants_wan22_finetune_fullrep_8gpu.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+JOB_ID=${JOB_ID:-524904}
+NUM_GPUS=${NUM_GPUS:-8}
+CODE_DIR=${CODE_DIR:-/scratch/user/yuhwang/code/FastVideo}
+MODEL_PATH=${MODEL_PATH:-/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged}
+DATA_DIR=${DATA_DIR:-/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin}
+OUT_ROOT=${OUT_ROOT:-/scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune}
+RUN_NAME=${RUN_NAME:-pants_wan22_fullrep_b16_$(date +%Y%m%d_%H%M%S)}
+OUTPUT_DIR=${OUTPUT_DIR:-${OUT_ROOT}/${RUN_NAME}}
+
+TRAIN_BATCH_SIZE=${TRAIN_BATCH_SIZE:-16}
+MAX_TRAIN_STEPS=${MAX_TRAIN_STEPS:-3300}
+CHECKPOINT_STEPS=${CHECKPOINT_STEPS:-1650}
+LEARNING_RATE=${LEARNING_RATE:-1e-6}
+DATALOADER_NUM_WORKERS=${DATALOADER_NUM_WORKERS:-2}
+GRADIENT_ACCUMULATION_STEPS=${GRADIENT_ACCUMULATION_STEPS:-1}
+EMA_DECAY=${EMA_DECAY:-0.999}
+TRAINING_CFG_RATE=${TRAINING_CFG_RATE:-0.05}
+MAX_GRAD_NORM=${MAX_GRAD_NORM:-1.0}
+
+mkdir -p "${OUTPUT_DIR}"
+
+srun --jobid="${JOB_ID}" --overlap \
+  --nodes=1 --ntasks=1 --cpus-per-task=96 \
+  --gres=gpu:nvidia_h200:${NUM_GPUS} \
+  bash -lc '
+    set -euo pipefail
+    source ~/.twoframe_env.sh >/dev/null 2>&1 || true
+    ENV_DIR=${ENV_DIR:-/scratch/user/yuhwang/envs/twoframe}
+    export PATH="${ENV_DIR}/bin:${PATH}"
+    TORCHRUN_BIN=${TORCHRUN_BIN:-${ENV_DIR}/bin/torchrun}
+    cd '"${CODE_DIR}"'
+
+    export PYTHONPATH='"${CODE_DIR}"':${PYTHONPATH:-}
+    export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+    export TOKENIZERS_PARALLELISM=false
+    export WANDB_MODE=offline
+    export FASTVIDEO_ATTENTION_BACKEND=TORCH_SDPA
+    unset FASTVIDEO_SKIP_FINAL_CHECKPOINT
+
+    export TMPDIR=${TMPDIR:-/tmp/fv_'"${JOB_ID}"'}
+    mkdir -p "${TMPDIR}" '"${OUTPUT_DIR}"'
+
+    (
+      while true; do
+        date "+MEM_TS %Y-%m-%d %H:%M:%S"
+        nvidia-smi --query-gpu=index,memory.used,utilization.gpu --format=csv,noheader,nounits | sed "s/^/GPU /"
+        sleep 60
+      done
+    ) > '"${OUTPUT_DIR}"'/gpu_monitor.log 2>&1 &
+    MONITOR_PID=$!
+    trap "kill ${MONITOR_PID} >/dev/null 2>&1 || true" EXIT
+
+    "${TORCHRUN_BIN}" --standalone --nnodes 1 --nproc_per_node '"${NUM_GPUS}"' \
+      fastvideo/training/wan_training_pipeline.py \
+      --model_path '"${MODEL_PATH}"' \
+      --pretrained_model_name_or_path '"${MODEL_PATH}"' \
+      --inference_mode False \
+      --data_path '"${DATA_DIR}"' \
+      --train_batch_size '"${TRAIN_BATCH_SIZE}"' \
+      --num_latent_t 39 \
+      --sp_size 1 \
+      --tp_size 1 \
+      --hsdp_replicate_dim 8 \
+      --hsdp_shard_dim 1 \
+      --num_gpus '"${NUM_GPUS}"' \
+      --train_sp_batch_size 1 \
+      --dataloader_num_workers '"${DATALOADER_NUM_WORKERS}"' \
+      --gradient_accumulation_steps '"${GRADIENT_ACCUMULATION_STEPS}"' \
+      --max_train_steps '"${MAX_TRAIN_STEPS}"' \
+      --learning_rate '"${LEARNING_RATE}"' \
+      --lr_scheduler constant \
+      --lr_warmup_steps 0 \
+      --mixed_precision bf16 \
+      --training_state_checkpointing_steps '"${CHECKPOINT_STEPS}"' \
+      --checkpoints_total_limit 2 \
+      --ema_decay '"${EMA_DECAY}"' \
+      --ema_start_step 1 \
+      --use_ema True \
+      --training_cfg_rate '"${TRAINING_CFG_RATE}"' \
+      --output_dir '"${OUTPUT_DIR}"' \
+      --tracker_project_name pants_wan22_fullrep \
+      --wandb_run_name '"${RUN_NAME}"' \
+      --num_height 320 \
+      --num_width 288 \
+      --num_frames 153 \
+      --num_euler_timesteps 50 \
+      --weight_decay 0.01 \
+      --dit_precision fp32 \
+      --max_grad_norm '"${MAX_GRAD_NORM}"' \
+      --enable_gradient_checkpointing_type full
+  '
+
+echo "${OUTPUT_DIR}"

raw_pants_train_test/metadata/pants-captions-ldm/code/cache/run_pants_wan22_finetune_fullrep_8gpu_node.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+JOB_ID=${JOB_ID:-524904}
+NUM_GPUS=${NUM_GPUS:-8}
+CODE_DIR=${CODE_DIR:-/scratch/user/yuhwang/code/FastVideo}
+MODEL_PATH=${MODEL_PATH:-/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged}
+DATA_DIR=${DATA_DIR:-/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin}
+OUT_ROOT=${OUT_ROOT:-/scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune}
+RUN_NAME=${RUN_NAME:-pants_wan22_fullrep_b16_node_$(date +%Y%m%d_%H%M%S)}
+OUTPUT_DIR=${OUTPUT_DIR:-${OUT_ROOT}/${RUN_NAME}}
+
+TRAIN_BATCH_SIZE=${TRAIN_BATCH_SIZE:-16}
+MAX_TRAIN_STEPS=${MAX_TRAIN_STEPS:-3300}
+CHECKPOINT_STEPS=${CHECKPOINT_STEPS:-1650}
+LEARNING_RATE=${LEARNING_RATE:-1e-6}
+DATALOADER_NUM_WORKERS=${DATALOADER_NUM_WORKERS:-2}
+GRADIENT_ACCUMULATION_STEPS=${GRADIENT_ACCUMULATION_STEPS:-1}
+EMA_DECAY=${EMA_DECAY:-0.999}
+TRAINING_CFG_RATE=${TRAINING_CFG_RATE:-0.05}
+MAX_GRAD_NORM=${MAX_GRAD_NORM:-1.0}
+
+source ~/.twoframe_env.sh >/dev/null 2>&1 || true
+ENV_DIR=${ENV_DIR:-/scratch/user/yuhwang/envs/twoframe}
+export PATH="${ENV_DIR}/bin:${PATH}"
+TORCHRUN_BIN=${TORCHRUN_BIN:-${ENV_DIR}/bin/torchrun}
+
+cd "${CODE_DIR}"
+mkdir -p "${OUTPUT_DIR}"
+
+export PYTHONPATH="${CODE_DIR}:${PYTHONPATH:-}"
+export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+export TOKENIZERS_PARALLELISM=false
+export WANDB_MODE=offline
+export FASTVIDEO_ATTENTION_BACKEND=TORCH_SDPA
+unset FASTVIDEO_SKIP_FINAL_CHECKPOINT
+
+export TMPDIR=${TMPDIR:-/tmp/fv_${JOB_ID}}
+mkdir -p "${TMPDIR}"
+
+echo "HOSTNAME=$(hostname)"
+echo "RUN_NAME=${RUN_NAME}"
+echo "OUTPUT_DIR=${OUTPUT_DIR}"
+echo "TRAIN_BATCH_SIZE=${TRAIN_BATCH_SIZE}"
+echo "MAX_TRAIN_STEPS=${MAX_TRAIN_STEPS}"
+echo "CHECKPOINT_STEPS=${CHECKPOINT_STEPS}"
+echo "LEARNING_RATE=${LEARNING_RATE}"
+nvidia-smi
+
+(
+  while true; do
+    date "+MEM_TS %Y-%m-%d %H:%M:%S"
+    nvidia-smi --query-gpu=index,memory.used,utilization.gpu --format=csv,noheader,nounits | sed "s/^/GPU /"
+    sleep 60
+  done
+) > "${OUTPUT_DIR}/gpu_monitor.log" 2>&1 &
+MONITOR_PID=$!
+trap 'kill "${MONITOR_PID}" >/dev/null 2>&1 || true' EXIT
+
+"${TORCHRUN_BIN}" --standalone --nnodes 1 --nproc_per_node "${NUM_GPUS}" \
+  fastvideo/training/wan_training_pipeline.py \
+  --model_path "${MODEL_PATH}" \
+  --pretrained_model_name_or_path "${MODEL_PATH}" \
+  --inference_mode False \
+  --data_path "${DATA_DIR}" \
+  --train_batch_size "${TRAIN_BATCH_SIZE}" \
+  --num_latent_t 39 \
+  --sp_size 1 \
+  --tp_size 1 \
+  --hsdp_replicate_dim 8 \
+  --hsdp_shard_dim 1 \
+  --num_gpus "${NUM_GPUS}" \
+  --train_sp_batch_size 1 \
+  --dataloader_num_workers "${DATALOADER_NUM_WORKERS}" \
+  --gradient_accumulation_steps "${GRADIENT_ACCUMULATION_STEPS}" \
+  --max_train_steps "${MAX_TRAIN_STEPS}" \
+  --learning_rate "${LEARNING_RATE}" \
+  --lr_scheduler constant \
+  --lr_warmup_steps 0 \
+  --mixed_precision bf16 \
+  --training_state_checkpointing_steps "${CHECKPOINT_STEPS}" \
+  --checkpoints_total_limit 2 \
+  --ema_decay "${EMA_DECAY}" \
+  --ema_start_step 1 \
+  --use_ema True \
+  --training_cfg_rate "${TRAINING_CFG_RATE}" \
+  --output_dir "${OUTPUT_DIR}" \
+  --tracker_project_name pants_wan22_fullrep \
+  --wandb_run_name "${RUN_NAME}" \
+  --num_height 320 \
+  --num_width 288 \
+  --num_frames 153 \
+  --num_euler_timesteps 50 \
+  --weight_decay 0.01 \
+  --dit_precision fp32 \
+  --max_grad_norm "${MAX_GRAD_NORM}" \
+  --enable_gradient_checkpointing_type full
+
+echo "${OUTPUT_DIR}"

raw_pants_train_test/metadata/pants-captions-ldm/code/cache/run_pants_wan22_finetune_smoke_8gpu.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+JOB_ID=${JOB_ID:-524904}
+NUM_GPUS=${NUM_GPUS:-8}
+CODE_DIR=${CODE_DIR:-/scratch/user/yuhwang/code/FastVideo}
+MODEL_PATH=${MODEL_PATH:-/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-merged}
+DATA_DIR=${DATA_DIR:-/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin}
+OUT_ROOT=${OUT_ROOT:-/scratch/user/yuhwang/artifacts/twoframe/pants_wan22_finetune}
+RUN_NAME=${RUN_NAME:-smoke_$(date +%Y%m%d_%H%M%S)}
+OUTPUT_DIR=${OUTPUT_DIR:-${OUT_ROOT}/${RUN_NAME}}
+
+srun --jobid="${JOB_ID}" --overlap \
+  --nodes=1 --ntasks=1 --cpus-per-task=64 \
+  --gres=gpu:nvidia_h200:${NUM_GPUS} \
+  bash -lc '
+    set -euo pipefail
+    source ~/.twoframe_env.sh >/dev/null 2>&1 || true
+    conda activate /scratch/user/yuhwang/envs/twoframe
+    cd '"${CODE_DIR}"'
+    export PYTHONPATH='"${CODE_DIR}"':${PYTHONPATH:-}
+    export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+    export TOKENIZERS_PARALLELISM=false
+    export WANDB_MODE=offline
+    export FASTVIDEO_ATTENTION_BACKEND=TORCH_SDPA
+    mkdir -p '"${OUTPUT_DIR}"'
+
+    torchrun --standalone --nnodes 1 --nproc_per_node '"${NUM_GPUS}"' \
+      fastvideo/training/wan_training_pipeline.py \
+      --model_path '"${MODEL_PATH}"' \
+      --pretrained_model_name_or_path '"${MODEL_PATH}"' \
+      --inference_mode False \
+      --data_path '"${DATA_DIR}"' \
+      --train_batch_size 1 \
+      --num_latent_t 39 \
+      --sp_size 8 \
+      --tp_size 1 \
+      --hsdp_replicate_dim 1 \
+      --hsdp_shard_dim 8 \
+      --num_gpus '"${NUM_GPUS}"' \
+      --train_sp_batch_size 1 \
+      --dataloader_num_workers 2 \
+      --gradient_accumulation_steps 1 \
+      --max_train_steps 1 \
+      --learning_rate 1e-6 \
+      --mixed_precision bf16 \
+      --training_state_checkpointing_steps 1000000 \
+      --checkpoints_total_limit 2 \
+      --ema_decay 0.999 \
+      --ema_start_step 1 \
+      --use_ema True \
+      --training_cfg_rate 0.05 \
+      --output_dir '"${OUTPUT_DIR}"' \
+      --tracker_project_name pants_wan22_smoke \
+      --num_height 320 \
+      --num_width 288 \
+      --num_frames 153 \
+      --num_euler_timesteps 50 \
+      --weight_decay 0.01 \
+      --dit_precision fp32 \
+      --max_grad_norm 1.0 \
+      --enable_gradient_checkpointing_type full
+  '
+
+echo "${OUTPUT_DIR}"

raw_pants_train_test/metadata/pants-captions-ldm/code/cache/run_pants_wan22_text_cache_8gpu.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+CACHE_ROOT=${CACHE_ROOT:-/scratch/user/yuhwang/dataset/pants-captions-ldm/cache/wan22_pants_v2_softwin}
+TEXT_MODEL_ROOT=${TEXT_MODEL_ROOT:-/scratch/user/yuhwang/model/Wan2.2-TI2V-5B-Diffusers-text}
+SCRIPT=${SCRIPT:-/scratch/user/yuhwang/dataset/pants-captions-ldm/code/cache/pants_wan22_text_cache.py}
+PYTHON_BIN=${PYTHON_BIN:-/scratch/user/yuhwang/envs/twoframe/bin/python}
+JOB_ID=${JOB_ID:-524904}
+NTASKS=${NTASKS:-8}
+CPUS_PER_TASK=${CPUS_PER_TASK:-12}
+
+srun --jobid="${JOB_ID}" --overlap \
+  --nodes=1 --ntasks="${NTASKS}" --cpus-per-task="${CPUS_PER_TASK}" \
+  --gres=gpu:nvidia_h200:${NTASKS} \
+  bash -lc '
+    source ~/.twoframe_env.sh >/dev/null 2>&1 || true
+    conda activate /scratch/user/yuhwang/envs/twoframe
+    export CUDA_VISIBLE_DEVICES=${SLURM_LOCALID}
+    export OMP_NUM_THREADS='"${CPUS_PER_TASK}"'
+    '"${PYTHON_BIN}"' '"${SCRIPT}"' \
+      --cache-root '"${CACHE_ROOT}"' \
+      --text-model-root '"${TEXT_MODEL_ROOT}"' \
+      --splits source_train source_test \
+      --rank ${SLURM_PROCID} \
+      --world-size ${SLURM_NTASKS} \
+      --text-dtype bf16 \
+      --store-dtype bf16
+  '
+
+"${PYTHON_BIN}" "${SCRIPT}" \
+  --cache-root "${CACHE_ROOT}" \
+  --text-model-root "${TEXT_MODEL_ROOT}" \
+  --splits source_train source_test \
+  --merge-only

raw_pants_train_test/metadata/pants-captions-ldm/code/caption_generation/canonical_facts.py

@@ -0,0 +1,376 @@
+"""
+Canonical facts extractor for PanTS.
+
+For each case we produce a deterministic structured-fact dict from:
+  (1) metadata.xlsx  — structured report + phase + demographics (ground truth, already curated by PanTS authors)
+  (2) 28-class mask geometry — lesion count / subregion / vessel contact / FOV / physical extents
+       things that the report text does not state explicitly.
+
+Output: canonical_facts/{pid}.json  (or one big jsonl)
+
+This is the "ground truth" layer of the fusion pipeline:
+  canonical_facts  +  VLM visual phrases  ->  text LLM  ->  5 caption variants
+
+Run with:
+  python3 canonical_facts.py --ids all_ids.json --out canonical_facts.jsonl --workers 24
+"""
+import os, io, json, re, time, argparse, traceback
+import numpy as np, nibabel as nib, pandas as pd
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+
+METADATA_XLSX = os.environ.get("PANTS_METADATA_XLSX", "./PanTS_data/metadata.xlsx")
+DATA_ROOT = os.environ.get("PANTS_DATA_ROOT", "./PanTS_data")
+
+# PanTS 28 class map
+CLASS_MAP = {
+    1: 'adrenal_gland_left', 2: 'adrenal_gland_right', 3: 'aorta',
+    4: 'bladder', 5: 'celiac_artery', 6: 'colon', 7: 'common_bile_duct',
+    8: 'duodenum', 9: 'femur_left', 10: 'femur_right', 11: 'gall_bladder',
+    12: 'kidney_left', 13: 'kidney_right', 14: 'liver',
+    15: 'lung_left', 16: 'lung_right',
+    17: 'pancreas', 18: 'pancreas_body', 19: 'pancreas_head', 20: 'pancreas_tail',
+    21: 'pancreatic_duct', 22: 'postcava', 23: 'prostate', 24: 'spleen',
+    25: 'stomach', 26: 'superior_mesenteric_artery', 27: 'veins',
+    28: 'pancreatic_lesion',
+}
+
+
+# ---------- report parsing ----------
+
+def _clean(txt):
+    if txt is None:
+        return ""
+    return str(txt).replace('_x000D_', '').replace('\r', '').strip()
+
+
+_FLOAT = r"(-?\d+(?:\.\d+)?)"
+
+_LESION_BLOCK = re.compile(
+    r"Pancreas lesion\s*\d+:\s*\n"
+    r"Location:\s*([^\n\.]+)\.\s*\n"
+    r"Size:\s*" + _FLOAT + r"\s*x\s*" + _FLOAT + r"\s*cm\s*\(image\s*(\d+)\)\.\s*Volume:\s*" + _FLOAT + r"\s*cc\.\s*\n"
+    r"Enhancement relative to pancreas:\s*([^\s\(]+)\s*\(HU value is\s*" + _FLOAT + r"\+/-\s*" + _FLOAT + r"\)\.",
+    re.IGNORECASE,
+)
+
+_ORGAN_NORMALCY = re.compile(
+    r"^([A-Z][a-z]+):\s*\n(Normal size|[A-Z][a-z]+ is\s+[a-z ]+)\s*\(volume:\s*" + _FLOAT + r"\s*cc\)",
+    re.MULTILINE,
+)
+
+_HU = re.compile(r"Mean HU value:\s*" + _FLOAT + r"\s*\+/-\s*" + _FLOAT)
+
+
+def parse_structured_report(raw):
+    """Parse the PanTS structured report text into a dict of canonical facts.
+    Returns None if not parseable."""
+    txt = _clean(raw)
+    if not txt:
+        return None
+
+    out = {"raw_report": txt}
+    # organ sizes
+    for m in re.finditer(
+            r"^(Spleen|Liver|Pancreas|Kidney):\s*\n([^\n]+)\s*\n", txt, re.MULTILINE):
+        organ = m.group(1).lower()
+        line = m.group(2).strip()
+        size_word = None
+        if line.startswith("Normal size"):
+            size_word = "normal"
+        elif "massively enlarged" in line.lower():
+            size_word = "massively_enlarged"
+        elif "enlarged" in line.lower():
+            size_word = "enlarged"
+        elif "atrophic" in line.lower():
+            size_word = "atrophic"
+        elif "small" in line.lower():
+            size_word = "small"
+        vol_m = re.search(r"volume:\s*" + _FLOAT + r"\s*cc", line)
+        out.setdefault("organ_status", {})[organ] = {
+            "size": size_word,
+            "volume_cc": float(vol_m.group(1)) if vol_m else None,
+        }
+
+    # HU per organ (look for Mean HU value after each organ heading)
+    out.setdefault("organ_status", {})
+    for organ_key in ("Spleen", "Liver", "Pancreas", "Kidney"):
+        sec = re.search(
+            rf"{organ_key}:\s*\n[\s\S]+?Mean HU value:\s*" + _FLOAT + r"\s*\+/-\s*" + _FLOAT,
+            txt,
+        )
+        if sec:
+            st = out["organ_status"].setdefault(organ_key.lower(), {})
+            st["hu_mean"] = float(sec.group(1))
+            st["hu_sd"] = float(sec.group(2))
+
+    # lesions
+    lesions = []
+    for m in _LESION_BLOCK.finditer(txt):
+        loc, sx, sy, img_no, vol, enh, hu_m, hu_sd = m.groups()
+        lesions.append({
+            "location": loc.strip().lower(),   # "pancreas head", "pancreas body/tail", etc
+            "size_cm": [float(sx), float(sy)],
+            "image_no": int(img_no),
+            "volume_cc": float(vol),
+            "enhancement": enh.strip().lower(),  # hypo/iso/hyper-attenuating
+            "hu_mean": float(hu_m),
+            "hu_sd": float(hu_sd),
+        })
+    out["lesions"] = lesions
+    out["lesion_present"] = len(lesions) > 0
+
+    # impression
+    imp = re.search(r"IMPRESSION:\s*\n([\s\S]+?)$", txt)
+    if imp:
+        out["impression"] = imp.group(1).strip()
+    return out
+
+
+# ---------- mask geometry ----------
+
+def _canon(path):
+    img = nib.as_closest_canonical(nib.load(path))
+    return img.get_fdata(), img.header.get_zooms()[:3], img.affine
+
+
+def _bbox(mask):
+    if not mask.any():
+        return None
+    xs, ys, zs = np.where(mask)
+    return {
+        "x": [int(xs.min()), int(xs.max())],
+        "y": [int(ys.min()), int(ys.max())],
+        "z": [int(zs.min()), int(zs.max())],
+    }
+
+
+def _dilate_one(mask):
+    """Dilate by 1 voxel in all 6 axial neighbors."""
+    out = mask.copy()
+    for ax in range(3):
+        out |= np.roll(mask, 1, ax)
+        out |= np.roll(mask, -1, ax)
+    return out
+
+
+def connected_components_3d(mask):
+    """Return N, labeled array (simple 6-connected)."""
+    from scipy.ndimage import label
+    lab, n = label(mask, structure=np.ones((3, 3, 3), dtype=np.uint8))
+    return n, lab
+
+
+def _fov_class(lbl, sp):
+    """Classify scan FOV: chest / abdomen / abdomen-pelvis / whole-body.
+    Use presence of lung (15,16) and femur (9,10)."""
+    has_lung = ((lbl == 15) | (lbl == 16)).any()
+    has_femur = ((lbl == 9) | (lbl == 10)).any()
+    has_pelvis = ((lbl == 4) | (lbl == 23)).any()
+    z_mm = lbl.shape[2] * sp[2]
+    if has_lung and has_femur:
+        return "whole_body"
+    if has_lung and has_pelvis:
+        return "chest_abdomen_pelvis"
+    if has_lung:
+        return "chest_abdomen"
+    if has_pelvis:
+        return "abdomen_pelvis"
+    return "abdomen_only"
+
+
+def mask_facts(pid):
+    """Load combined_labels, produce mask-derived facts (things the report doesn't list)."""
+    for split in ("LabelTr", "LabelTe"):
+        p = f"{DATA_ROOT}/{split}/{pid}/combined_labels.nii.gz"
+        if os.path.exists(p):
+            lbl, sp, _ = _canon(p)
+            break
+    else:
+        return {"error": f"labels not found for {pid}"}
+
+    lbl = lbl.astype(np.int16)
+    sp = tuple(float(x) for x in sp)
+    vox_cc = float(sp[0] * sp[1] * sp[2]) / 1000.0  # mm^3 -> cc
+
+    out = {"spacing": list(sp), "shape": list(lbl.shape), "voxel_cc": round(vox_cc, 4)}
+
+    # Organ presence / volume
+    organ_vol = {}
+    for cid, name in CLASS_MAP.items():
+        if cid == 28:
+            continue  # lesion handled separately
+        m = (lbl == cid)
+        if m.any():
+            organ_vol[name] = round(float(m.sum()) * vox_cc, 1)
+    out["organ_volume_cc"] = organ_vol
+
+    # FOV
+    out["fov"] = _fov_class(lbl, sp)
+    out["z_physical_mm"] = round(lbl.shape[2] * sp[2], 1)
+
+    # Pancreas + lesion geometry (union of class 17 and 18/19/20 subregions)
+    pan = (lbl == 17) | (lbl == 18) | (lbl == 19) | (lbl == 20)
+    out["pancreas_present"] = bool(pan.any())
+    if pan.any():
+        out["pancreas_bbox"] = _bbox(pan)
+        out["organ_volume_cc"]["pancreas"] = round(float(pan.sum()) * vox_cc, 1)
+
+    lesion = (lbl == 28)
+    out["mask_lesion_present"] = bool(lesion.any())
+    if lesion.any():
+        n_cc, lab_arr = connected_components_3d(lesion)
+        out["lesion_count"] = int(n_cc)
+        # per-component
+        comps = []
+        for cid in range(1, n_cc + 1):
+            m = (lab_arr == cid)
+            vol = float(m.sum()) * vox_cc
+            if vol < 0.05:   # <0.05 cc, ignore
+                continue
+            bb = _bbox(m)
+            # which pancreas subregion dominates this lesion
+            sub_overlap = {}
+            for sid in (18, 19, 20):
+                dil = _dilate_one(m)
+                v = int(((lbl == sid) & dil).sum())
+                sub_overlap[CLASS_MAP[sid]] = v
+            dom = max(sub_overlap, key=sub_overlap.get) if sum(sub_overlap.values()) > 0 else None
+            # vessel contact (1-voxel dilated lesion ∩ vessels)
+            dil = _dilate_one(m)
+            vessel_contact = {}
+            for vid in (3, 5, 22, 26, 27):  # aorta, celiac, postcava, SMA, veins
+                touch = int(((lbl == vid) & dil).sum())
+                if touch > 0:
+                    vessel_contact[CLASS_MAP[vid]] = touch
+            # bile duct contact
+            for vid in (7, 21):
+                touch = int(((lbl == vid) & dil).sum())
+                if touch > 0:
+                    vessel_contact[CLASS_MAP[vid]] = touch
+            comps.append({
+                "volume_cc": round(vol, 2),
+                "bbox": bb,
+                "subregion_dominant": dom,
+                "subregion_overlap_vox": sub_overlap,
+                "contact": vessel_contact,
+            })
+        comps.sort(key=lambda c: -c["volume_cc"])
+        out["lesion_components"] = comps
+    else:
+        out["lesion_count"] = 0
+
+    # Post-op heuristic: total label volume check + stomach/colon bbox check
+    # (too crude without report; we just record gall_bladder / spleen / prostate presence)
+    out["gallbladder_present"] = bool((lbl == 11).any())
+
+    return out
+
+
+# ---------- main extractor ----------
+
+def extract_one(pid, report_df):
+    try:
+        row = report_df.loc[report_df["PanTS ID"] == pid]
+        if len(row) == 0:
+            return {"id": pid, "error": "not in metadata"}
+        r = row.iloc[0]
+
+        fact = {
+            "id": pid,
+            "phase": str(r.get("ct phase")) if pd.notna(r.get("ct phase")) else None,
+            "sex": str(r.get("sex")) if pd.notna(r.get("sex")) else None,
+            "age": float(r["age"]) if pd.notna(r.get("age")) else None,
+            "manufacturer": str(r.get("manufacturer")) if pd.notna(r.get("manufacturer")) else None,
+            "model": str(r.get("manufacturer model")) if pd.notna(r.get("manufacturer model")) else None,
+            "study_type": str(r.get("study type")) if pd.notna(r.get("study type")) else None,
+            "tumor_flag": int(r["tumor?"]) if pd.notna(r.get("tumor?")) else None,
+        }
+        fact["report"] = parse_structured_report(r.get("structured report"))
+        fact["mask"] = mask_facts(pid)
+
+        # consolidated top-level flags (the ones V1-V5 fusion prompts will read)
+        rep = fact["report"] or {}
+        msk = fact["mask"] or {}
+        # Report is authoritative for lesion_present (determines caption content).
+        # Mask-only (report says no lesion but class 28 has voxels) is flagged but NOT treated
+        # as lesion+ because we lack size/subregion/enhancement to put in the caption.
+        rep_has_lesion = bool(rep.get("lesion_present"))
+        msk_has_lesion = bool(msk.get("mask_lesion_present", False))
+        fact["canonical"] = {
+            "lesion_present": rep_has_lesion,  # authoritative from report
+            "lesion_present_mask_only": (not rep_has_lesion) and msk_has_lesion,
+            "lesion_present_report_only": rep_has_lesion and not msk_has_lesion,
+            "lesion_count_mask": msk.get("lesion_count", 0),
+            "lesion_count_report": len(rep.get("lesions") or []),
+            "lesion_list": rep.get("lesions") or [],
+            "lesion_components_mask": msk.get("lesion_components") or [],
+            "organ_status_report": rep.get("organ_status") or {},
+            "impression": rep.get("impression") or "",
+            "fov": msk.get("fov"),
+            "phase": fact["phase"],
+            "sex": fact["sex"],
+            "age": fact["age"],
+            "manufacturer": fact["manufacturer"],
+            "model": fact["model"],
+            "study_type": fact["study_type"],
+            "pancreas_volume_cc": msk.get("organ_volume_cc", {}).get("pancreas"),
+            "gallbladder_present": msk.get("gallbladder_present", None),
+            "z_physical_mm": msk.get("z_physical_mm"),
+        }
+        return fact
+    except Exception as e:
+        return {"id": pid, "error": f"{type(e).__name__}: {e}", "tb": traceback.format_exc()[-400:]}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ids", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--workers", type=int, default=16)
+    ap.add_argument("--resume", action="store_true", default=True)
+    args = ap.parse_args()
+
+    ids = json.load(open(args.ids))
+    df = pd.read_excel(METADATA_XLSX)
+
+    done = set()
+    if args.resume and os.path.exists(args.out):
+        with open(args.out) as f:
+            for line in f:
+                try:
+                    d = json.loads(line)
+                    if "error" not in d:
+                        done.add(d["id"])
+                except Exception:
+                    pass
+        print(f"resume: {len(done)} already done")
+    todo = [i for i in ids if i not in done]
+    print(f"total={len(ids)} todo={len(todo)} workers={args.workers}")
+
+    os.makedirs(os.path.dirname(args.out) or ".", exist_ok=True)
+    fp = open(args.out, "a", buffering=1)
+
+    t0 = time.time()
+    ok = err = 0
+    with ProcessPoolExecutor(max_workers=args.workers) as ex:
+        # pass df via initializer — but df is only 9901 rows so cheap to pickle per task
+        futs = {ex.submit(extract_one, pid, df): pid for pid in todo}
+        for i, fut in enumerate(as_completed(futs)):
+            r = fut.result()
+            fp.write(json.dumps(r, ensure_ascii=False) + "\n")
+            if "error" in r:
+                err += 1
+            else:
+                ok += 1
+            if (i + 1) % 200 == 0 or i == len(todo) - 1:
+                dt = time.time() - t0
+                rate = (i + 1) / max(dt, 1e-3)
+                eta = (len(todo) - i - 1) / max(rate, 1e-3)
+                print(f"  {i+1}/{len(todo)}  rate={rate:.1f}/s  eta={eta/60:.1f}min  ok={ok} err={err}")
+    fp.close()
+    print(f"done. ok={ok} err={err} wall={(time.time()-t0)/60:.1f}min")
+
+
+if __name__ == "__main__":
+    main()

raw_pants_train_test/metadata/pants-captions-ldm/code/caption_generation/f5_audit.py

@@ -0,0 +1,333 @@
+"""
+F5-QA: full-corpus audit of captions_full_v2.jsonl against canonical_facts.jsonl.
+
+Checks per variant:
+  - fill: text non-empty
+  - length band: variant-specific word-count window
+  - banned words (adenocarcinoma / TNM / stage / unresectable / etc.)
+  - lesion consistency:
+      canon lesion+ → text must contain a lesion word AND all canonical sizes should appear
+      canon lesion- → text must NOT contain an un-negated lesion word
+  - V6_negative: text must contain zero lesion tokens (even negated) — design contract
+  - number hallucination: any cm/mm dimension in text must exist in canonical sizes
+  - subregion echo: if canonical lesion has subregion (head/body/tail), text should mention it
+  - FOV echo (long variants only)
+
+Outputs:
+  audit_report.md   — human summary (per-variant pass rate, histogram, top issues)
+  qa_flagged.jsonl  — one row per flagged (case, variant) with violations
+"""
+import os
+import json, re, os, sys, statistics, collections
+
+CAP = f"{os.environ.get('REPO_ROOT', '.')}/captions/captions_full_v2.jsonl"
+CAN = f"{os.environ.get('REPO_ROOT', '.')}/canonical/canonical_facts.jsonl"
+OUT_MD = f"{os.environ.get('REPO_ROOT', '.')}/audit_report.md"
+OUT_FLAG = f"{os.environ.get('REPO_ROOT', '.')}/qa_flagged.jsonl"
+
+
+BANNED = [
+    r"\badenocarcinoma\b", r"\bmalignan(t|cy|cies)\b", r"\bmetasta(sis|ses|tic)\b",
+    r"\bT[1-4][a-c]?\b", r"\bN[0-3]\b", r"\bM[01]\b",
+    r"\bunresectable\b", r"\bresectable\b",
+    r"\bstage\s*(I{1,3}V?|IV|[1-4])\b",
+    r"\bperineural invasion\b",
+    r"\bchemotherap(y|ies)\b",
+]
+BANNED_RE = re.compile("|".join(BANNED), re.IGNORECASE)
+
+LESION_WORDS = re.compile(
+    r"\b(lesion|mass|tumor|tumou?r|nodule|cyst|neoplasm)s?\b", re.IGNORECASE)
+# Pancreas-specific lesion mention: the canonical lesion_list is pancreas-only,
+# so only flag hallucinations when the lesion word is bound to pancreas context.
+PANC_LESION_RE = re.compile(
+    r"\b(pancreatic|pancreas|peripancreatic|ductal|intraductal|IPMN)\b[^\.]{0,80}?"
+    r"\b(lesion|mass|tumor|tumou?r|nodule|cyst|neoplasm)s?\b",
+    re.IGNORECASE)
+# "X cyst" incidentals that must NOT count as hallucinated pancreas lesion
+INCIDENTAL_CYST_RE = re.compile(
+    r"\b(renal|kidney|cortical|hepatic|liver|splenic|ovarian|bosniak|"
+    r"simple|parenchymal|adrenal)\b[^\.]{0,30}?\bcysts?\b",
+    re.IGNORECASE)
+# Sentence-level negation cues. Must over-match to avoid false positives
+# on "hallucinated" detector. Include morphological variants: absent/absence,
+# negative/negativity, devoid, free_of, without, no/none, neither/nor, lack/lacking.
+NEG_CUE = re.compile(
+    r"\b(no|none|without|free\s+of|devoid|absent|absence|lack|lacking|"
+    r"negativ\w*|no\s+evidence\s+of|no\s+sign\w*\s+of|unremarkable|neither|nor|"
+    r"not\s+\w+|rule[ds]?\s+out|exclud\w+)\b", re.IGNORECASE)
+
+# match "1.2 x 3.4" or "2.4cm" or "14 mm"
+DIM_RE = re.compile(
+    r"(?<![\d\.])(\d{1,3}(?:\.\d)?)\s*(?:x\s*\d{1,3}(?:\.\d)?\s*)?(cm|mm)\b",
+    re.IGNORECASE)
+
+# permissible length bands (word count)
+WORD_BAND = {
+    "V1_long_narrative":        (120, 320),
+    "V2_terse_impression":      (10, 50),
+    "V3_organ_bullet":          (60, 180),
+    "V4_tag_string":            (6, 35),
+    "V5_layered_findings":      (80, 220),
+    "V6_negative_descriptive":  (40, 150),
+    "V6_qa_pair":               (20, 110),
+}
+
+
+def has_unnegated_lesion(text):
+    """True iff a pancreatic lesion word appears un-negated in some sentence.
+    Excludes incidental renal/hepatic/splenic cysts (those are VLM-reported,
+    not canonical_facts, but allowed to be mentioned since the caption is
+    descriptive, not a closed-set diagnosis)."""
+    sents = re.split(r"(?<=[\.\?!])\s+", text.strip())
+    for s in sents:
+        # explicit pancreatic lesion claim
+        if PANC_LESION_RE.search(s) and not NEG_CUE.search(s):
+            return True
+    # Also flag generic lesion/mass/tumor mention without any organ binding
+    # (i.e. "A large hypoattenuating mass is seen") but ignore incidental cysts
+    for s in sents:
+        if NEG_CUE.search(s):
+            continue
+        # strip out incidental-cyst phrases first
+        s_stripped = INCIDENTAL_CYST_RE.sub("", s)
+        m = LESION_WORDS.search(s_stripped)
+        if not m:
+            continue
+        # only flag if word is lesion/mass/tumor/neoplasm (strong claim),
+        # not a lone "cyst" without organ anchoring
+        if m.group(0).lower() in ("cyst", "cysts"):
+            continue
+        return True
+    return False
+
+
+def parse_dims_cm(text):
+    """Return list of dims in cm (converting mm → cm)."""
+    out = []
+    for m in DIM_RE.finditer(text):
+        val = float(m.group(1))
+        unit = m.group(2).lower()
+        if unit == "mm":
+            val = val / 10.0
+        out.append(round(val, 1))
+    return out
+
+
+def load_canonical():
+    c = {}
+    with open(CAN) as f:
+        for line in f:
+            d = json.loads(line)
+            c[d["id"]] = d["canonical"]
+    return c
+
+
+def audit_variant(pid, vname, text, canon):
+    v = []
+    if not text or not text.strip():
+        return ["empty"]
+    text_s = text.strip()
+    n_words = len(text_s.split())
+
+    # length
+    if vname == "V4_tag_string":
+        # tag string: count comma-separated tags, not words
+        n_tags = len([t for t in text_s.split(",") if t.strip()])
+        lo, hi = 6, 30
+        if n_tags < lo:
+            v.append(f"too_short:{n_tags}<{lo}tags")
+        elif n_tags > hi:
+            v.append(f"too_long:{n_tags}>{hi}tags")
+    else:
+        lo, hi = WORD_BAND.get(vname, (1, 10_000))
+        if n_words < lo:
+            v.append(f"too_short:{n_words}<{lo}")
+        elif n_words > hi:
+            v.append(f"too_long:{n_words}>{hi}")
+
+    # banned words
+    m = BANNED_RE.search(text_s)
+    if m:
+        v.append(f"banned:{m.group(0).lower()}")
+
+    canon_pos = bool(canon.get("lesion_present"))
+    # Strip incidental cysts before the lesion-word test so V4 tag strings don't
+    # get flagged for "renal cyst" etc.
+    text_for_lesion = INCIDENTAL_CYST_RE.sub("", text_s)
+    # V4 is comma-separated — treat commas as sentence terminators for neg detection
+    if vname == "V4_tag_string":
+        text_for_lesion_neg_split = re.sub(r",\s*", ". ", text_for_lesion)
+    else:
+        text_for_lesion_neg_split = text_for_lesion
+    any_lesion_word = bool(LESION_WORDS.search(text_for_lesion))
+
+    if vname == "V6_negative_descriptive":
+        # User decision 2026-04-20: V6_negative deprecated — don't ship it.
+        # Skip lesion-token contract; only keep length/banned checks.
+        pass
+    else:
+        if canon_pos:
+            if not any_lesion_word:
+                v.append("missing_lesion_mention")
+            # size echo: canonical sizes should appear at least once
+            canon_sizes = []
+            for L in canon.get("lesion_list", []):
+                sz = L.get("size_cm") or []
+                for s in sz:
+                    canon_sizes.append(round(float(s), 1))
+            text_dims = parse_dims_cm(text_s)
+            # V4/V2 may only cite the largest dim; accept if any canonical max-adjacent size appears
+            if canon_sizes and not any(abs(d - cs) < 0.2 for d in text_dims for cs in canon_sizes):
+                v.append("size_not_echoed")
+            # subregion
+            subs = set()
+            for L in canon.get("lesion_list", []):
+                loc = (L.get("location") or "").lower()
+                for key in ("head", "body", "tail", "uncinate"):
+                    if key in loc:
+                        subs.add(key)
+            if subs and vname in ("V1_long_narrative", "V3_organ_bullet", "V5_layered_findings"):
+                if not any(k in text_s.lower() for k in subs):
+                    v.append("missing_subregion")
+        else:
+            # lesion negative case — no un-negated pancreatic lesion word
+            if has_unnegated_lesion(text_for_lesion_neg_split):
+                v.append("hallucinated_lesion_mention")
+
+    # number hallucination: any cm dimension in text not matching canonical
+    if canon_pos:
+        canon_sizes = []
+        for L in canon.get("lesion_list", []):
+            for s in (L.get("size_cm") or []):
+                canon_sizes.append(round(float(s), 1))
+        text_dims = parse_dims_cm(text_s)
+        extras = [d for d in text_dims
+                  if not any(abs(d - cs) < 0.2 for cs in canon_sizes)
+                  and 0.3 <= d <= 20]  # ignore very large or tiny numbers (HU refs, percents)
+        if len(extras) > 2:
+            v.append(f"extra_dims:{extras[:3]}")
+    else:
+        # negative case: any dim > 0.5 cm flagged as potential halluc
+        text_dims = parse_dims_cm(text_s)
+        # allow typical kidney/liver/spleen mention like "12 cm liver" — too noisy; skip
+        pass
+
+    return v
+
+
+def main():
+    print("loading canonical...")
+    canon = load_canonical()
+    print(f"  canonical n={len(canon)}")
+
+    per_variant = collections.defaultdict(lambda: {
+        "total": 0, "ok": 0, "violations": collections.Counter(),
+        "lens_words": [],
+    })
+    flagged = []
+
+    total_cases = 0
+    missing_variants = 0
+    with open(CAP) as f:
+        for line in f:
+            d = json.loads(line)
+            pid = d["id"]
+            total_cases += 1
+            if pid not in canon:
+                missing_variants += 1
+                continue
+            c = canon[pid]
+            seen = set()
+            for v in d.get("variants", []):
+                vname = v.get("variant", "?")
+                seen.add(vname)
+                text = v.get("text") or ""
+                violations = audit_variant(pid, vname, text, c)
+                stat = per_variant[vname]
+                stat["total"] += 1
+                stat["lens_words"].append(len(text.split()))
+                if not violations:
+                    stat["ok"] += 1
+                else:
+                    for x in violations:
+                        stat["violations"][x.split(":")[0]] += 1
+                    flagged.append({
+                        "id": pid, "variant": vname,
+                        "violations": violations,
+                        "lesion_present": bool(c.get("lesion_present")),
+                        "text": text[:400],
+                    })
+            # missing variants?
+            expected = {"V1_long_narrative", "V2_terse_impression", "V3_organ_bullet",
+                        "V4_tag_string", "V5_layered_findings"}
+            expected.add("V6_qa_pair" if c.get("lesion_present") else "V6_negative_descriptive")
+            for ev in expected - seen:
+                stat = per_variant[ev]
+                stat["total"] += 1
+                stat["violations"]["missing"] += 1
+                flagged.append({
+                    "id": pid, "variant": ev, "violations": ["missing"],
+                    "lesion_present": bool(c.get("lesion_present")), "text": "",
+                })
+
+    # write flagged jsonl
+    with open(OUT_FLAG, "w") as f:
+        for r in flagged:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    # write markdown
+    with open(OUT_MD, "w") as f:
+        f.write("# F5 Caption Audit Report\n\n")
+        f.write(f"- Cases audited: {total_cases}\n")
+        f.write(f"- Canonical intersection misses: {missing_variants}\n")
+        f.write(f"- Total flagged (case, variant) rows: {len(flagged)}\n\n")
+        f.write("## Per-variant pass rate\n\n")
+        f.write("| Variant | Total | OK | Pass % | P50 words | P95 words |\n")
+        f.write("|---|---|---|---|---|---|\n")
+        for vname in sorted(per_variant):
+            s = per_variant[vname]
+            lens = s["lens_words"] or [0]
+            p50 = int(statistics.median(lens))
+            p95 = int(sorted(lens)[int(len(lens)*0.95)-1])
+            f.write(f"| {vname} | {s['total']} | {s['ok']} | "
+                    f"{100*s['ok']/max(1,s['total']):.1f}% | {p50} | {p95} |\n")
+        f.write("\n## Violation breakdown\n\n")
+        for vname in sorted(per_variant):
+            s = per_variant[vname]
+            if not s["violations"]:
+                continue
+            f.write(f"### {vname}\n\n")
+            for k, c in s["violations"].most_common():
+                f.write(f"- `{k}`: {c}\n")
+            f.write("\n")
+        # top 20 flagged samples
+        f.write("## Sample flagged rows (first 20)\n\n")
+        for r in flagged[:20]:
+            f.write(f"- `{r['id']}` / `{r['variant']}` / lesion+={r['lesion_present']} / "
+                    f"viol={r['violations']}\n")
+            if r["text"]:
+                f.write(f"  - text: {r['text'][:180]}...\n")
+        f.write("\n")
+
+    # print summary
+    print(f"cases audited: {total_cases}")
+    print(f"flagged rows:  {len(flagged)}")
+    print(f"\nPer-variant pass rate:")
+    for vname in sorted(per_variant):
+        s = per_variant[vname]
+        lens = s["lens_words"] or [0]
+        p50 = int(statistics.median(lens))
+        print(f"  {vname:28s}  total={s['total']:>5}  ok={s['ok']:>5}  "
+              f"pass={100*s['ok']/max(1,s['total']):5.1f}%  p50_words={p50}")
+    print(f"\nTop violations overall:")
+    overall = collections.Counter()
+    for s in per_variant.values():
+        overall.update(s["violations"])
+    for k, c in overall.most_common(10):
+        print(f"  {k}: {c}")
+    print(f"\nWrote: {OUT_MD}\n       {OUT_FLAG}")
+
+
+if __name__ == "__main__":
+    main()

raw_pants_train_test/metadata/pants-captions-ldm/code/caption_generation/f5b_v7.py

@@ -0,0 +1,232 @@
+"""
+F5b: V7 pancreas-only captions, gated on canonical lesion_present AND mask component presence.
+
+Per v4 §8.4 whitelist:
+  - Describe pancreas and lesion ONLY
+  - Use subregion from mask (pancreas_head/body/tail/uncinate)
+  - Use size_cm from canonical
+  - Use enhancement (hypo/iso/hyper-attenuating) from canonical
+  - Include vessel/duct contact only from mask.contact keys
+  - BANNED upgrades: invasion, encasement, stage, resectability, adenocarcinoma
+  - No liver/spleen/kidney content (reserved for B-pan crop supervision)
+
+Output: captions_out/captions_v7.jsonl
+"""
+import os, json, re, sys, argparse, threading, time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+sys.path.insert(0, f"{os.environ.get('REPO_ROOT', '.')}")
+from fusion_run import (
+    call_text_llm, load_jsonl, BANNED_RE, KEYPOOL,
+)
+
+
+# Additional banned for V7 (upgrades over baseline banned list)
+V7_EXTRA_BAN = re.compile(
+    r"\b(invasion|encasement|encases?|infiltrates?|tumou?r|"
+    r"resectability|operable|staging|staged)\b",
+    re.IGNORECASE,
+)
+
+# Allowed contact phrases (whitelist) — only descriptive "abuts/contacts/touches/adjacent to"
+ALLOWED_CONTACT_VERBS = ("abuts", "contacts", "touches", "adjacent to", "in contact with")
+
+CONTACT_LABEL_MAP = {
+    "pancreatic_duct": "pancreatic duct",
+    "common_bile_duct": "common bile duct",
+    "celiac_artery": "celiac artery",
+    "sma": "superior mesenteric artery",
+    "smv": "superior mesenteric vein",
+    "aorta": "abdominal aorta",
+    "portal_vein": "portal vein",
+    "splenic_vein": "splenic vein",
+    "splenic_artery": "splenic artery",
+    "hepatic_artery": "hepatic artery",
+    "ivc": "inferior vena cava",
+    "duodenum": "duodenum",
+    "stomach": "stomach",
+}
+
+
+def format_facts_for_v7(canonical_core):
+    lesions = canonical_core.get("lesion_list", [])
+    mask_comps = canonical_core.get("lesion_components_mask", [])
+    out = {
+        "phase": canonical_core.get("phase"),
+        "pancreas_volume_cc": canonical_core.get("pancreas_volume_cc"),
+        "pancreas_status": (canonical_core.get("organ_status_report") or {}).get("pancreas", {}),
+        "lesions": [],
+    }
+    # Pair lesions with mask components by order (both produced in canonical build)
+    for i, L in enumerate(lesions):
+        mc = mask_comps[i] if i < len(mask_comps) else {}
+        contacts_kv = mc.get("contact", {}) or {}
+        # keep only contacts with substantive voxel count (>=5 voxels)
+        contacts_clean = []
+        for k, v in contacts_kv.items():
+            label = CONTACT_LABEL_MAP.get(k, k.replace("_", " "))
+            if isinstance(v, (int, float)) and v >= 5:
+                contacts_clean.append(label)
+        out["lesions"].append({
+            "subregion": mc.get("subregion_dominant", L.get("location", "pancreas")),
+            "size_cm": L.get("size_cm"),
+            "volume_cc": L.get("volume_cc"),
+            "enhancement": L.get("enhancement"),
+            "hu_mean": L.get("hu_mean"),
+            "contacts": contacts_clean,
+        })
+    return out
+
+
+V7_PROMPT_TEMPLATE = """You are writing a PANCREAS-ONLY descriptive caption for training a text-to-image 3D medical diffusion model on a pancreas crop.
+
+FACTS (use ONLY these values):
+{facts}
+
+HARD RULES:
+- Describe the PANCREAS and its lesion ONLY. Do NOT mention liver, spleen, kidneys, habitus, bowel, bone, skin, or any extra-pancreatic finding.
+- Size values (cm) must be taken verbatim from FACTS.lesions[].size_cm.
+- Subregion must be one of: pancreatic head, pancreatic body, pancreatic tail, uncinate process. Use ONLY the subregion from FACTS.lesions[].subregion (strip any 'pancreas_' prefix and render with spaces).
+- Enhancement: use ONLY the value from FACTS.lesions[].enhancement (e.g., 'isoattenuating', 'hypoattenuating', 'hyperattenuating'). Do not upgrade to 'avidly enhancing' or similar.
+- Vessel / duct contact: use only the labels listed in FACTS.lesions[].contacts. Describe with neutral verbs like 'abuts', 'contacts', 'is adjacent to'. Do not write 'invades', 'encases', 'infiltrates', or any staging term.
+- No diagnosis, no prognosis, no treatment. No adenocarcinoma, TNM stage, resectability.
+
+STYLE: 50-120 words, 2-4 sentences. Flow:
+  (1) One sentence on the scan phase and pancreas morphology/volume.
+  (2) One or two sentences describing the lesion(s): subregion, size (cm), enhancement, any vessel/duct contact.
+  (3) Optionally close with a short observation on pancreatic duct or parenchyma if FACTS provides it.
+
+Output only the caption. No markdown, no 'CAPTION:' prefix.
+"""
+
+
+def _strip_prefix(t):
+    t = re.sub(r"^CAPTION:\s*", "", t, flags=re.IGNORECASE)
+    t = re.sub(r"^```[a-z]*\s*", "", t)
+    t = re.sub(r"\s*```$", "", t).strip()
+    return t
+
+
+def qc_v7(text, facts):
+    v = []
+    if not text or len(text.split()) < 20:
+        v.append("too_short")
+    if BANNED_RE.search(text) or V7_EXTRA_BAN.search(text):
+        v.append("banned_word")
+    # extra-pancreatic content check
+    extra = re.search(
+        r"\b(liver|hepatic|spleen|splenic|kidney|renal|bowel|habitus|subcutaneous|rib|bone|skin|bladder)\b",
+        text, re.IGNORECASE)
+    if extra:
+        v.append(f"extra_pancreatic:{extra.group(0).lower()}")
+    # subregion echo
+    subs = set()
+    for L in facts.get("lesions", []):
+        sub = (L.get("subregion") or "").lower()
+        for key in ("head", "body", "tail", "uncinate"):
+            if key in sub:
+                subs.add(key)
+    if subs and not any(k in text.lower() for k in subs):
+        v.append("missing_subregion")
+    # size echo
+    sizes = []
+    for L in facts.get("lesions", []):
+        for s in (L.get("size_cm") or []):
+            sizes.append(round(float(s), 1))
+    if sizes:
+        size_str_ok = any(f"{s:.1f}" in text or f"{s}" in text for s in sizes)
+        if not size_str_ok:
+            v.append("missing_size")
+    return (len(v) == 0), v
+
+
+def run_one(pid, canonical):
+    canonical_core = canonical["canonical"]
+    facts = format_facts_for_v7(canonical_core)
+    facts_str = json.dumps(facts, ensure_ascii=False, indent=2)
+    prompt = V7_PROMPT_TEMPLATE.format(facts=facts_str)
+    best_text, best_ok, best_v = "", False, []
+    for attempt in range(3):
+        resp = call_text_llm(prompt, max_tokens=500, temperature=0.4 if attempt == 0 else 0.3)
+        text = _strip_prefix(resp.get("content") or "")
+        if not text:
+            continue
+        ok, viol = qc_v7(text, facts)
+        if ok:
+            return {"id": pid, "variant": "V7_pancreas_only",
+                    "text": text, "ok": True, "violations": [], "dt": resp.get("dt", 0)}
+        if (len(viol) < len(best_v)) or (not best_text and not best_v):
+            best_text, best_ok, best_v = text, ok, viol
+        # on failure, append violation hints to prompt for next attempt
+        prompt = V7_PROMPT_TEMPLATE.format(facts=facts_str) + \
+            "\n\nPREVIOUS ATTEMPT FAILED these checks: " + ",".join(viol) + \
+            ". Regenerate correcting them exactly.\n"
+    return {"id": pid, "variant": "V7_pancreas_only",
+            "text": best_text, "ok": best_ok, "violations": best_v, "dt": 0}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--canonical", default=f"{os.environ.get('REPO_ROOT', '.')}/canonical/canonical_facts.jsonl")
+    ap.add_argument("--out", default=f"{os.environ.get('REPO_ROOT', '.')}/captions/captions_v7.jsonl")
+    ap.add_argument("--workers", type=int, default=16)
+    ap.add_argument("--limit", type=int, default=0)
+    args = ap.parse_args()
+
+    print("loading canonical...", flush=True)
+    canonical_map = load_jsonl(args.canonical)
+    print(f"  canonical={len(canonical_map)}", flush=True)
+
+    # Eligibility: lesion_present=true AND has lesion_components_mask entries
+    eligible = []
+    for pid, d in canonical_map.items():
+        c = d["canonical"]
+        if c.get("lesion_present") and c.get("lesion_components_mask"):
+            eligible.append(pid)
+    eligible.sort()
+    print(f"  V7-eligible cases: {len(eligible)}", flush=True)
+
+    # resume
+    done = set()
+    if os.path.exists(args.out):
+        with open(args.out) as f:
+            for line in f:
+                try:
+                    d = json.loads(line)
+                    done.add(d["id"])
+                except: pass
+        print(f"  resume: {len(done)} already written", flush=True)
+    todo = [i for i in eligible if i not in done]
+    if args.limit:
+        todo = todo[:args.limit]
+    print(f"  todo: {len(todo)}  workers={args.workers}", flush=True)
+
+    fp = open(args.out, "a", buffering=1)
+    lock = threading.Lock()
+    t0 = time.time()
+    ok_ct = 0
+    with ThreadPoolExecutor(max_workers=args.workers) as ex:
+        futs = {ex.submit(run_one, pid, canonical_map[pid]): pid for pid in todo}
+        for i, fut in enumerate(as_completed(futs)):
+            pid = futs[fut]
+            try:
+                r = fut.result()
+            except Exception as e:
+                r = {"id": pid, "error": str(e)}
+            with lock:
+                fp.write(json.dumps(r, ensure_ascii=False) + "\n")
+            if "error" not in r and r.get("ok"):
+                ok_ct += 1
+            if (i + 1) % 25 == 0 or i == len(todo) - 1:
+                dt = time.time() - t0
+                rate = (i + 1) / max(dt, 1e-3)
+                eta = (len(todo) - i - 1) / max(rate, 1e-3)
+                print(f"  v7 {i+1}/{len(todo)}  ok={ok_ct}  rate={rate:.2f}/s  eta={eta/60:.1f}min",
+                      flush=True)
+    fp.close()
+    print(f"done. wall={(time.time()-t0)/60:.1f}min  ok={ok_ct}/{len(todo)}  out={args.out}",
+          flush=True)
+
+
+if __name__ == "__main__":
+    main()

raw_pants_train_test/metadata/pants-captions-ldm/code/caption_generation/f5d_regen.py

@@ -0,0 +1,177 @@
+"""
+F5d: regenerate truncated / banned-word captions from f5_regen_list.json.
+
+Strategy:
+  - Load previous captions_full_v2.jsonl + f5_regen_list.json
+  - For each (id, variant) in regen list, re-call LLM with HIGHER max_tokens
+    so the long-form variants (V1/V3/V5) don't truncate mid-sentence.
+  - Re-QC; accept if non-truncated AND no banned word.
+  - If regen still truncated after 2 tries, keep the original (mark regen_failed).
+  - Emit captions_full_v3.jsonl (all cases, only touched variants replaced).
+"""
+import os, json, re, sys, argparse, threading, time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+sys.path.insert(0, f"{os.environ.get('REPO_ROOT', '.')}")
+from fusion_run import (
+    V_PROMPTS, build_facts_block, filter_vlm_a, filter_b_prose,
+    call_text_llm, load_jsonl, BANNED_RE,
+)
+
+
+# Higher budgets than the original run to eliminate truncation.
+MAX_TOK = {
+    "V1_long_narrative":        1024,
+    "V2_terse_impression":      140,
+    "V3_organ_bullet":          700,
+    "V4_tag_string":            160,
+    "V5_layered_findings":      700,
+    "V6_qa_pair":               240,
+    "V6_negative_descriptive":  400,  # will be dropped later, but keep consistent
+}
+
+
+def is_truncated(text, vname):
+    if not text:
+        return True
+    t = text.strip()
+    if vname == "V4_tag_string":
+        # tags: accept if >=6 tags AND doesn't end with a stray comma or fragment
+        tags = [x.strip() for x in t.split(",") if x.strip()]
+        return len(tags) < 6
+    if len(t.split()) < 5:
+        return True
+    # ends without terminal punctuation → likely truncated
+    return not re.search(r"[.!?]\"?\)?\s*$", t)
+
+
+def regen_variant(canonical_core, vlm_a, vlm_b, vname, attempts=2):
+    facts = build_facts_block(canonical_core, vlm_a, vlm_b)
+    facts_str = json.dumps(facts, ensure_ascii=False, indent=2)
+    prompt = V_PROMPTS[vname].format(facts=facts_str)
+    mt = MAX_TOK.get(vname, 800)
+
+    best_text = ""
+    best_ok = False
+    for i in range(attempts):
+        resp = call_text_llm(prompt, max_tokens=mt, temperature=0.4)
+        text = (resp.get("content") or "").strip()
+        text = re.sub(r"^```[a-z]*\s*", "", text)
+        text = re.sub(r"\s*```$", "", text).strip()
+        if not text:
+            continue
+        banned = bool(BANNED_RE.search(text))
+        trunc = is_truncated(text, vname)
+        ok = (not banned) and (not trunc)
+        if ok:
+            return {"variant": vname, "text": text, "ok": True, "violations": [],
+                    "dt": resp.get("dt", 0), "regen": True}
+        # keep longest non-banned attempt as fallback
+        if (not banned) and len(text) > len(best_text):
+            best_text, best_ok = text, False
+    # fallback: return best candidate we have (may still be truncated)
+    return {"variant": vname, "text": best_text, "ok": best_ok,
+            "violations": ["regen_failed_still_trunc"] if not best_ok else [],
+            "dt": 0, "regen": True}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--canonical", default=f"{os.environ.get('REPO_ROOT', '.')}/canonical/canonical_facts.jsonl")
+    ap.add_argument("--vlm",       default=f"{os.environ.get('REPO_ROOT', '.')}/vlm_out/vlm_results.jsonl")
+    ap.add_argument("--prev",      default=f"{os.environ.get('REPO_ROOT', '.')}/captions/captions_full_v2.jsonl")
+    ap.add_argument("--regen",     default=f"{os.environ.get('REPO_ROOT', '.')}/f5_regen_list.json")
+    ap.add_argument("--out",       default=f"{os.environ.get('REPO_ROOT', '.')}/captions/captions_full_v3.jsonl")
+    ap.add_argument("--workers",   type=int, default=16)
+    args = ap.parse_args()
+
+    print("loading canonical + vlm...", flush=True)
+    canonical_map = load_jsonl(args.canonical)
+    vlm_map = load_jsonl(args.vlm)
+    print(f"  canonical={len(canonical_map)}  vlm={len(vlm_map)}", flush=True)
+
+    print("loading prev captions...", flush=True)
+    prev = {}
+    with open(args.prev) as f:
+        for line in f:
+            d = json.loads(line)
+            prev[d["id"]] = d
+    print(f"  prev cases={len(prev)}", flush=True)
+
+    print("loading regen list...", flush=True)
+    with open(args.regen) as f:
+        regen_list = json.load(f)
+    # group by id
+    by_id = {}
+    for (pid, vname, reasons) in regen_list:
+        by_id.setdefault(pid, []).append(vname)
+    print(f"  regen cases={len(by_id)} items={len(regen_list)}", flush=True)
+
+    # resume: skip ids already in out
+    done = set()
+    if os.path.exists(args.out):
+        with open(args.out) as f:
+            for line in f:
+                try:
+                    d = json.loads(line)
+                    done.add(d["id"])
+                except: pass
+        print(f"  resume: {len(done)} already written", flush=True)
+
+    todo_ids = [i for i in prev.keys() if i not in done]
+    regen_ids = [i for i in todo_ids if i in by_id]
+    passthrough_ids = [i for i in todo_ids if i not in by_id]
+    print(f"  regen todo: {len(regen_ids)}   passthrough: {len(passthrough_ids)}", flush=True)
+
+    fp = open(args.out, "a", buffering=1)
+    lock = threading.Lock()
+
+    # 1) passthrough: copy cases that don't need regen
+    for pid in passthrough_ids:
+        fp.write(json.dumps(prev[pid], ensure_ascii=False) + "\n")
+    print(f"  wrote {len(passthrough_ids)} passthrough cases", flush=True)
+
+    def work(pid):
+        prev_case = prev[pid]
+        canonical = canonical_map.get(pid)
+        vlm = vlm_map.get(pid)
+        if not canonical or not vlm:
+            return {"id": pid, "variants": prev_case.get("variants", [])}
+        canonical_core = canonical["canonical"]
+        vlm_a = filter_vlm_a((vlm or {}).get("A_json", {}).get("parsed") or {},
+                             bool(canonical_core.get("lesion_present")))
+        vlm_b = filter_b_prose((vlm or {}).get("B_prose", {}).get("content") or "")
+        want = set(by_id.get(pid, []))
+        out_vars = []
+        for v in prev_case.get("variants", []):
+            vname = v.get("variant")
+            if vname in want:
+                nv = regen_variant(canonical_core, vlm_a, vlm_b, vname)
+                out_vars.append(nv)
+            else:
+                out_vars.append(v)
+        return {"id": pid, "variants": out_vars}
+
+    t0 = time.time()
+    with ThreadPoolExecutor(max_workers=args.workers) as ex:
+        futs = {ex.submit(work, pid): pid for pid in regen_ids}
+        for i, fut in enumerate(as_completed(futs)):
+            pid = futs[fut]
+            try:
+                r = fut.result()
+            except Exception as e:
+                r = {"id": pid, "variants": prev[pid].get("variants", []), "error": str(e)}
+            with lock:
+                fp.write(json.dumps(r, ensure_ascii=False) + "\n")
+            if (i + 1) % 25 == 0 or i == len(regen_ids) - 1:
+                dt = time.time() - t0
+                rate = (i + 1) / max(dt, 1e-3)
+                eta = (len(regen_ids) - i - 1) / max(rate, 1e-3)
+                print(f"  regen {i+1}/{len(regen_ids)}  rate={rate:.2f}/s  eta={eta/60:.1f}min",
+                      flush=True)
+    fp.close()
+    print(f"done. wall={(time.time()-t0)/60:.1f}min  out={args.out}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

raw_pants_train_test/metadata/pants-captions-ldm/code/caption_generation/f6_audit_final.py

@@ -0,0 +1,152 @@
+"""
+F6 final corpus audit — reads captions_final.jsonl (post-merge, post-drop).
+
+This is a thin wrapper that adapts the structure (captions dict keyed by variant name)
+to the same audit logic as f5_audit.py.
+"""
+import os
+import json, re, os, sys, statistics, collections
+
+FINAL = f"{os.environ.get('REPO_ROOT', '.')}/captions/captions_final.jsonl"
+OUT_MD = f"{os.environ.get('REPO_ROOT', '.')}/audit_final.md"
+
+# Reuse the main audit definitions
+sys.path.insert(0, f"{os.environ.get('REPO_ROOT', '.')}")
+from f5_audit import (
+    BANNED_RE, LESION_WORDS, NEG_CUE, PANC_LESION_RE, INCIDENTAL_CYST_RE,
+    WORD_BAND, has_unnegated_lesion, parse_dims_cm,
+)
+
+# V7-specific extras
+V7_BAN_EXTRA = re.compile(
+    r"\b(invasion|encasement|encases?|infiltrates?|resectability|"
+    r"operable|staging|staged)\b", re.IGNORECASE)
+
+
+def audit_one(pid, vname, text, cond):
+    v = []
+    if not text or not text.strip():
+        return ["empty"]
+    t = text.strip()
+    n_words = len(t.split())
+    if vname == "V4_tag_string":
+        n_tags = len([x for x in t.split(",") if x.strip()])
+        if n_tags < 6:
+            v.append(f"too_short:{n_tags}<6tags")
+        elif n_tags > 30:
+            v.append(f"too_long:{n_tags}>30tags")
+    else:
+        band = {
+            "V7_pancreas_only": (40, 140),
+            **WORD_BAND,
+        }
+        lo, hi = band.get(vname, (1, 10_000))
+        if n_words < lo:
+            v.append(f"too_short:{n_words}<{lo}")
+        elif n_words > hi:
+            v.append(f"too_long:{n_words}>{hi}")
+
+    if BANNED_RE.search(t):
+        v.append("banned")
+    if vname == "V7_pancreas_only" and V7_BAN_EXTRA.search(t):
+        v.append("v7_upgrade_word")
+
+    canon_pos = bool(cond.get("lesion_present"))
+    text_for_lesion = INCIDENTAL_CYST_RE.sub("", t)
+    any_lesion_word = bool(LESION_WORDS.search(text_for_lesion))
+
+    if vname == "V4_tag_string":
+        text_for_neg = re.sub(r",\s*", ". ", text_for_lesion)
+    else:
+        text_for_neg = text_for_lesion
+
+    if canon_pos:
+        if not any_lesion_word and vname != "V7_pancreas_only":
+            v.append("missing_lesion_mention")
+        elif vname == "V7_pancreas_only" and not any_lesion_word:
+            v.append("missing_lesion_mention")
+        canon_sizes = []
+        for L in cond.get("lesion_list", []):
+            for s in (L.get("size_cm") or []):
+                canon_sizes.append(round(float(s), 1))
+        text_dims = parse_dims_cm(t)
+        if canon_sizes and not any(abs(d - cs) < 0.2 for d in text_dims for cs in canon_sizes):
+            v.append("size_not_echoed")
+    else:
+        if has_unnegated_lesion(text_for_neg):
+            v.append("hallucinated_lesion_mention")
+
+    # V7 extra: pancreas-only content
+    if vname == "V7_pancreas_only":
+        extra = re.search(
+            r"\b(liver|hepatic|spleen|splenic|kidney|renal|bowel|habitus|"
+            r"subcutaneous|rib|skin|bladder)\b", t, re.IGNORECASE)
+        if extra:
+            v.append(f"extra_pancreatic:{extra.group(0).lower()}")
+
+    return v
+
+
+def main():
+    per_variant = collections.defaultdict(lambda: {
+        "total": 0, "ok": 0, "violations": collections.Counter(),
+        "lens_words": []})
+    flagged = []
+    total_cases = 0
+    with open(FINAL) as f:
+        for line in f:
+            d = json.loads(line)
+            total_cases += 1
+            cond = d["cond"]
+            for vname, text in (d.get("captions") or {}).items():
+                stat = per_variant[vname]
+                stat["total"] += 1
+                stat["lens_words"].append(len((text or "").split()))
+                viol = audit_one(d["id"], vname, text or "", cond)
+                if not viol:
+                    stat["ok"] += 1
+                else:
+                    for x in viol:
+                        stat["violations"][x.split(":")[0]] += 1
+                    flagged.append({"id": d["id"], "variant": vname,
+                                    "violations": viol, "text": (text or "")[:300],
+                                    "lesion_present": bool(cond.get("lesion_present"))})
+
+    print(f"cases audited: {total_cases}  flagged rows: {len(flagged)}")
+    print("\nPer-variant pass rate:")
+    for vname in sorted(per_variant):
+        s = per_variant[vname]
+        lens = s["lens_words"] or [0]
+        p50 = int(statistics.median(lens))
+        print(f"  {vname:28s}  total={s['total']:>5}  ok={s['ok']:>5}  "
+              f"pass={100*s['ok']/max(1,s['total']):5.1f}%  p50_words={p50}")
+    print("\nTop violations overall:")
+    overall = collections.Counter()
+    for s in per_variant.values():
+        overall.update(s["violations"])
+    for k, c in overall.most_common(10):
+        print(f"  {k}: {c}")
+
+    # write markdown
+    with open(OUT_MD, "w") as f:
+        f.write("# F6 Final Corpus QA (2026-04-20)\n\n")
+        f.write(f"- Source: `{FINAL}`\n")
+        f.write(f"- Cases: {total_cases}\n")
+        f.write(f"- Flagged rows (case × variant): {len(flagged)}\n\n")
+        f.write("| Variant | Total | OK | Pass % | P50 words | P95 words |\n")
+        f.write("|---|---|---|---|---|---|\n")
+        for vname in sorted(per_variant):
+            s = per_variant[vname]
+            lens = s["lens_words"] or [0]
+            p50 = int(statistics.median(lens))
+            p95 = int(sorted(lens)[int(len(lens)*0.95)-1])
+            f.write(f"| {vname} | {s['total']} | {s['ok']} | "
+                    f"{100*s['ok']/max(1,s['total']):.1f}% | {p50} | {p95} |\n")
+        f.write("\n## Top violations\n\n")
+        for k, c in overall.most_common(15):
+            f.write(f"- `{k}`: {c}\n")
+    print(f"\nWrote: {OUT_MD}")
+
+
+if __name__ == "__main__":
+    main()