Update app.py

app.py

@@ -472,18 +472,56 @@ def prepare_lora_cache(
     """Build cached LoRA state for single transformer."""
     global pipeline
     
+    print("[LoRA] === Starting LoRA Cache Preparation ===")
     progress(0.05, desc="Preparing LoRA cache...")
     
+    # Validate all LoRA files exist
+    print("[LoRA] Validating LoRA file paths...")
+    lora_files = [
+        ("Distilled", distilled_lora_path, distilled_strength),
+        ("Pose", pose_lora_path, pose_strength),
+        ("General", general_lora_path, general_strength),
+        ("Motion", motion_lora_path, motion_strength),
+        ("Dreamlay", dreamlay_lora_path, dreamlay_strength),
+        ("Mself", mself_lora_path, mself_strength),
+        ("Dramatic", dramatic_lora_path, dramatic_strength),
+        ("Fluid", fluid_lora_path, fluid_strength),
+        ("Liquid", liquid_lora_path, liquid_strength),
+        ("Demopose", demopose_lora_path, demopose_strength),
+        ("Voice", voice_lora_path, voice_strength),
+        ("Realism", realism_lora_path, realism_strength),
+        ("Transition", transition_lora_path, transition_strength),
+    ]
+    
+    active_loras = []
+    for name, path, strength in lora_files:
+        if path is not None and float(strength) != 0.0:
+            active_loras.append((name, path, strength))
+            print(f"[LoRA]   - {name}: strength={strength}")
+    
+    print(f"[LoRA] Active LoRAs: {len(active_loras)}")
+    
     key_str = f"{checkpoint_path}:{distilled_strength}:{pose_strength}:{general_strength}:{motion_strength}:{dreamlay_strength}:{mself_strength}:{dramatic_strength}:{fluid_strength}:{liquid_strength}:{demopose_strength}:{voice_strength}:{realism_strength}:{transition_strength}"
     key = hashlib.sha256(key_str.encode()).hexdigest()
     
     cache_path = LORA_CACHE_DIR / f"{key}.safetensors"
+    print(f"[LoRA] Cache key: {key[:16]}...")
+    print(f"[LoRA] Cache path: {cache_path}")
     
     if cache_path.exists():
+        print("[LoRA] Loading from existing cache...")
         progress(0.20, desc="Loading cached LoRA state...")
         state = load_file(str(cache_path))
+        print(f"[LoRA] Loaded state dict with {len(state)} keys, size: {sum(v.numel() * v.element_size() for v in state.values()) / 1024**3:.2f} GB")
         pipeline.apply_cached_lora_state(state)
-        return f"Loaded cached LoRA state: {cache_path.name}"
+        print("[LoRA] State applied to pipeline._cached_state")
+        print("[LoRA] === LoRA Cache Preparation Complete ===")
+        return f"Loaded cached LoRA state: {cache_path.name} ({len(state)} keys)"
+    
+    if not active_loras:
+        print("[LoRA] No non-zero LoRA strengths selected; nothing to prepare.")
+        print("[LoRA] === LoRA Cache Preparation Complete (no LoRAs) ===")
+        return "No non-zero LoRA strengths selected; nothing to prepare."
     
     entries = [
         (distilled_lora_path, distilled_strength),
@@ -501,34 +539,55 @@ def prepare_lora_cache(
         (transition_lora_path, transition_strength),
     ]
     
-    loras = [
+    loras_for_builder = [
         LoraPathStrengthAndSDOps(path, strength, LTXV_LORA_COMFY_RENAMING_MAP)
         for path, strength in entries
         if path is not None and float(strength) != 0.0
     ]
     
+    print(f"[LoRA] Building fused state on CPU with {len(loras_for_builder)} LoRAs...")
+    print("[LoRA] This may take several minutes (do not close the Space)...")
     progress(0.35, desc="Building fused state (CPU)...")
+    
+    import time
+    start_time = time.time()
+    
     tmp_ledger = pipeline.model_ledger.__class__(
         dtype=torch.bfloat16,
         device=torch.device("cpu"),
         checkpoint_path=str(checkpoint_path),
         spatial_upsampler_path=str(spatial_upsampler_path),
         gemma_root_path=str(gemma_root),
-        loras=tuple(loras),
+        loras=tuple(loras_for_builder),
         quantization=None,
     )
+    print(f"[LoRA] Temporary ledger created in {time.time() - start_time:.1f}s")
+    
+    print("[LoRA] Loading transformer with LoRAs applied...")
     transformer = tmp_ledger.transformer()
+    print(f"[LoRA] Transformer loaded in {time.time() - start_time:.1f}s")
+    
+    print("[LoRA] Extracting state dict...")
+    progress(0.70, desc="Extracting fused stateDict")
     state = {k: v.detach().cpu().contiguous() for k, v in transformer.state_dict().items()}
+    print(f"[LoRA] State dict extracted: {len(state)} keys")
+    
+    print(f"[LoRA] Saving to cache: {cache_path}")
     save_file(state, str(cache_path))
+    print(f"[LoRA] Cache saved, size: {sum(v.numel() * v.element_size() for v in state.values()) / 1024**3:.2f} GB")
     
+    print("[LoRA] Cleaning up temporary ledger...")
     del transformer, tmp_ledger
     gc.collect()
+    print(f"[LoRA] Cleanup complete in {time.time() - start_time:.1f}s total")
     
+    print("[LoRA] Applying state to pipeline._cached_state...")
     progress(0.90, desc="Applying LoRA state to pipeline...")
     pipeline.apply_cached_lora_state(state)
     
     progress(1.0, desc="Done!")
-    return f"Built and cached LoRA state: {cache_path.name}"
+    print("[LoRA] === LoRA Cache Preparation Complete ===")
+    return f"Built and cached LoRA state: {cache_path.name} ({len(state)} keys, {time.time() - start_time:.1f}s)"
 
 # =============================================================================
 # LoRA State Application (called BEFORE pipeline generation)
@@ -539,23 +598,40 @@ def apply_prepared_lora_state_to_pipeline():
     Apply the prepared LoRA state from pipeline._cached_state to the preloaded
     transformer. This should be called BEFORE pipeline generation, not during.
     """
+    print("[LoRA] === Applying LoRA State to Transformer ===")
+    
     if pipeline._cached_state is None:
         print("[LoRA] No prepared LoRA state available; skipping.")
+        print("[LoRA] === LoRA Application Complete (no state) ===")
         return False
     
     try:
         existing_transformer = _transformer  # The preloaded transformer from globals
+        state = pipeline._cached_state
+        print(f"[LoRA] Applying state dict with {len(state)} keys...")
+        print(f"[LoRA] State dict size: {sum(v.numel() * v.element_size() for v in state.values()) / 1024**3:.2f} GB")
+        
+        import time
+        start_time = time.time()
+        
         with torch.no_grad():
-            missing, unexpected = existing_transformer.load_state_dict(pipeline._cached_state, strict=False)
-            if missing:
-                print(f"[LoRA] load_state_dict mismatch: missing={len(missing)} keys")
-            if unexpected:
-                print(f"[LoRA] load_state_dict mismatch: unexpected={len(unexpected)} keys")
+            missing, unexpected = existing_transformer.load_state_dict(state, strict=False)
+        
+        print(f"[LoRA] load_state_dict completed in {time.time() - start_time:.1f}s")
+        
+        if missing:
+            print(f"[LoRA] WARNING: {len(missing)} keys missing from state dict")
+        if unexpected:
+            print(f"[LoRA] WARNING: {len(unexpected)} unexpected keys in state dict")
+        
+        if not missing and not unexpected:
+            print("[LoRA] State dict loaded successfully with no mismatches!")
         
-        print("[LoRA] Prepared LoRA state applied to the pipeline.")
+        print("[LoRA] === LoRA Application Complete (success) ===")
         return True
     except Exception as e:
-        print(f"[LoRA] Failed to apply LoRA state: {type(e).__name__}: {e}")
+        print(f"[LoRA] FAILED to apply LoRA state: {type(e).__name__}: {e}")
+        print("[LoRA] === LoRA Application Complete (FAILED) ===")
         return False
 
 # =============================================================================
@@ -759,7 +835,6 @@ def generate_video(
             width=width,
             num_frames=num_frames,
             frame_rate=DEFAULT_FRAME_RATE,
-            num_inference_steps=LTX_2_3_HQ_PARAMS.num_inference_steps,
             video_guider_params=video_guider_params,
             audio_guider_params=audio_guider_params,
             images=images,