Update app.py

app.py

@@ -1,11 +1,13 @@
 import gradio as gr
 import torch
-from diffusers import I2VGenXLPipeline
+from diffusers import I2VGenXLPipeline, LCMScheduler
 from diffusers.utils import export_to_video
 import gc
 import traceback
 
 MODEL_ID = "ali-vilab/i2vgen-xl"
+LORA_ID = "latent-consistency/lcm-lora-sdxl" # Die Turbo-Impfung
+
 pipe = None
 
 def load_model_safely():
@@ -13,27 +15,39 @@ def load_model_safely():
     if pipe is not None:
         return pipe, "Modell bereits geladen."
 
-    log = "Starte Lade-Prozess...\n"
+    log = "Lade Modell...\n"
     
     try:
-        # Wir laden fp16 Varianten, nutzen sie aber als float32
+        # 1. Basis Modell laden
         pipe = I2VGenXLPipeline.from_pretrained(
             MODEL_ID, 
             torch_dtype=torch.float32, 
             variant="fp16"
         )
         
-        # JETZT WIRD ES SPANNEND: Klappt das Offloading mit den neuen Requirements?
+        # 2. TURBO (LCM) LADEN
+        log += "💉 Injiziere LCM Turbo LoRA...\n"
         try:
-            pipe.enable_model_cpu_offload()
-            log += "✅ SUCCESS: Model CPU Offloading ist AKTIV!\n"
+            # Wir laden den Adapter. Das braucht etwas RAM!
+            pipe.load_lora_weights(LORA_ID, adapter_name="lcm")
+            pipe.fuse_lora() # Verschmilzt LoRA mit Modell für Speed
+            
+            # WICHTIG: Scheduler auf LCM ändern
+            pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+            log += "✅ Turbo aktiviert (LCM Scheduler & LoRA geladen).\n"
         except Exception as e:
-            log += f"⚠️ Offloading gescheitert: {e}\n"
+            log += f"⚠️ Turbo fehlgeschlagen (RAM voll?): {e}\nWir machen langsam weiter.\n"
+
+        # 3. Speicher Optimierung
+        try:
+            pipe.enable_model_cpu_offload()
+            log += "✅ Model Offloading aktiv.\n"
+        except:
             try:
                 pipe.enable_sequential_cpu_offload()
-                log += "✅ SUCCESS: Sequential Offloading ist AKTIV!\n"
+                log += "✅ Sequential Offloading aktiv.\n"
             except:
-                log += "❌ KRITISCH: Kein Offloading. 448px wird wahrscheinlich abstürzen.\n"
+                log += "❌ RAM WARNUNG: Kein Offloading möglich.\n"
 
         pipe.enable_vae_slicing()
         pipe.enable_vae_tiling()
@@ -43,14 +57,13 @@ def load_model_safely():
     except Exception as e:
         return None, f"Absturz beim Laden: {e}"
 
-def generate_video(image_in, prompt, negative_prompt, steps):
+def generate_video(image_in, prompt, negative_prompt):
     global pipe
     log_messages = ""
     
     if image_in is None:
         return None, "Kein Bild!"
     
-    # Modell laden
     if pipe is None:
         model, msg = load_model_safely()
         log_messages += msg
@@ -62,14 +75,14 @@ def generate_video(image_in, prompt, negative_prompt, steps):
     gc.collect()
     
     try:
-        # WIR ERZWINGEN EINE FUNKTIONIERENDE AUFLÖSUNG
-        # Unter 448 sieht das Bild kaputt aus (wie in deinem Screenshot).
-        target_size = 448 
+        # TURBO SETUP:
+        target_size = 448 # Wir hoffen, dass 448 mit LoRA noch passt
+        steps = 6         # LCM braucht nur 4-8 Steps!
+        guidance = 1.5    # LCM braucht niedrigen Guidance Scale (1.0 - 2.0)
         
-        log_messages += f"Skaliere auf {target_size}x{target_size} (Minimum für Qualität)...\n"
-        image_in = image_in.resize((target_size, target_size))
+        log_messages += f"Generiere Turbo-Video (Nur {steps} Steps!)...\n"
         
-        log_messages += f"Starte Generierung ({steps} Steps)... Bitte Geduld.\n"
+        image_in = image_in.resize((target_size, target_size))
         
         generator = torch.manual_seed(42)
         
@@ -79,41 +92,36 @@ def generate_video(image_in, prompt, negative_prompt, steps):
             negative_prompt=negative_prompt,
             num_frames=16,          
             num_inference_steps=steps, 
-            guidance_scale=9.0,     
+            guidance_scale=guidance,     
             height=target_size, 
             width=target_size,  
             generator=generator
         ).frames[0]
         
-        video_path = "final.mp4"
+        video_path = "turbo_output.mp4"
         export_to_video(output, video_path, fps=8)
         
         log_messages += "✅ FERTIG!"
         return video_path, log_messages
         
     except Exception as e:
-        err = str(e)
-        if "Out of memory" in err or "Killed" in err:
-            return None, log_messages + "\n❌ RAM VOLL. Das 16GB Limit verhindert diese Auflösung."
-        return None, log_messages + f"\n❌ Fehler: {err}"
+        return None, log_messages + f"\n❌ Fehler: {e}"
 
-# Interface
 with gr.Blocks() as demo:
-    gr.Markdown("# I2VGen-XL (448px Fix)")
-    gr.Markdown("Wir versuchen 448x448 Pixel. Wenn das wegen RAM abstürzt, ist dieses Modell unmöglich auf Free Tier.")
+    gr.Markdown("# I2VGen-XL ⚡ TURBO (LCM)")
+    gr.Markdown("Mit LCM LoRA: Nur 6 Steps nötig! (Hoffen wir, dass der RAM reicht)")
     
     with gr.Row():
         with gr.Column():
             img = gr.Image(type="pil", label="Bild")
-            txt = gr.Textbox(label="Prompt", value="girl jumping")
+            txt = gr.Textbox(label="Prompt", value="clouds moving, cinematic")
             neg = gr.Textbox(value="distortion, blurry", label="Negative")
-            steps = gr.Slider(4, 25, value=10, step=1, label="Steps")
-            btn = gr.Button("Starten")
+            btn = gr.Button("Turbo Start (6 Steps)")
     
     with gr.Row():
         vid = gr.Video(label="Video")
-        logs = gr.Textbox(label="Log", lines=8)
+        logs = gr.Textbox(label="Status", lines=8)
         
-    btn.click(generate_video, [img, txt, neg, steps], [vid, logs])
+    btn.click(generate_video, [img, txt, neg], [vid, logs])
 
 demo.launch()