v2 p2

demo_app.py

@@ -1,12 +1,11 @@
 import spaces
 import gradio as gr
 import numpy as np
-import os
 import torch
-from PIL import Image
-from pathlib import Path
 from diffusers import HunyuanVideoPipeline
 from huggingface_hub import snapshot_download
+from PIL import Image
+import os
 
 # Configuration
 LORA_CHOICES = [
@@ -27,32 +26,18 @@ pipe = HunyuanVideoPipeline.from_pretrained(
     torch_dtype=torch.float16
 ).to("cuda")
 
-# Load all available LoRAs
+# Load LoRA adapters
 for lora_file in LORA_CHOICES:
-    try:
-        pipe.load_lora_weights(
-            "Sergidev/TTV4ME",
-            weight_name=lora_file,
-            adapter_name=lora_file.split('.')[0],
-            token=os.environ.get("HF_TOKEN")
-        )
-    except Exception as e:
-        print(f"Error loading {lora_file}: {str(e)}")
+    pipe.load_lora_weights(
+        "Sergidev/TTV4ME",
+        weight_name=lora_file,
+        adapter_name=lora_file.split('.')[0],
+        token=os.environ.get("HF_TOKEN")
+    )
 
 @spaces.GPU(duration=300)
-def generate(
-    prompt,
-    image_input,
-    height,
-    width,
-    num_frames,
-    num_inference_steps,
-    seed_value,
-    fps,
-    selected_loras,
-    lora_weights,
-    progress=gr.Progress(track_tqdm=True)
-):
+def generate(prompt, image_input, height, width, num_frames,
+            num_inference_steps, seed_value, fps, selected_loras, lora_weights):
     # Image validation
     if image_input is not None:
         img = Image.open(image_input)
@@ -68,157 +53,69 @@ def generate(
             active_adapters.append(LORA_CHOICES[idx].split('.')[0])
             adapter_weights.append(lora_weights[idx])
 
-    if active_adapters:
-        pipe.set_adapters(active_adapters, adapter_weights)
-
-    # Generation logic
-    torch.cuda.empty_cache()
-    if seed_value == -1:
-        seed_value = torch.randint(0, MAX_SEED, (1,)).item()
-
-    generator = torch.Generator('cuda').manual_seed(seed_value)
-
-    try:
-        if image_input:
-            output = pipe.image_to_video(
-                Image.open(image_input).convert("RGB"),
-                prompt=prompt,
-                height=height,
-                width=width,
-                num_frames=num_frames,
-                num_inference_steps=num_inference_steps,
-                generator=generator,
-            )
-        else:
-            output = pipe.text_to_video(
-                prompt=prompt,
-                height=height,
-                width=width,
-                num_frames=num_frames,
-                num_inference_steps=num_inference_steps,
-                generator=generator,
-            )
-
-        return output.video
-    finally:
-        torch.cuda.empty_cache()
-
-def apply_preset(preset_name):
-    if preset_name == "Higher Resolution":
-        return [608, 448, 24, 29, 12]
-    elif preset_name == "More Frames":
-        return [512, 320, 42, 27, 14]
-    return [512, 512, 24, 25, 12]
-
-css = """
-/* Existing CSS remains unchanged */
-"""
-
-with gr.Blocks(css=css, theme="dark") as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown("# 🎬 Hunyuan Studio", elem_classes=["title"])
-        gr.Markdown(
-            """Text-to-Video & Image-to-Video generation with multiple LoRA adapters.<br>
-            Ensure image resolution matches selected video dimensions.""",
-            elem_classes=["description"]
-        )
+    pipe.set_adapters(active_adapters, adapter_weights)
 
-        with gr.Column(elem_classes=["prompt-container"]):
-            prompt = gr.Textbox(
-                label="Prompt",
-                placeholder="Enter text prompt or describe the image...",
-                elem_classes=["prompt-textbox"],
-                lines=3
-            )
-            image_input = gr.Image(
-                label="Upload Reference Image (Optional)",
-                type="filepath",
-                visible=True
-            )
+    # Generate video
+    generator = torch.Generator('cuda').manual_seed(seed_value if seed_value != -1 else torch.seed())
 
-        with gr.Row():
-            run_button = gr.Button("🎬 Generate Video", variant="primary", size="lg")
+    if image_input:
+        output = pipe.image_to_video(
+            Image.open(image_input).convert("RGB"),
+            prompt=prompt,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            num_inference_steps=num_inference_steps,
+            generator=generator,
+        )
+    else:
+        output = pipe.text_to_video(
+            prompt=prompt,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            num_inference_steps=num_inference_steps,
+            generator=generator,
+        )
 
-        with gr.Row(elem_classes=["preset-buttons"]):
-            preset_high_res = gr.Button("📺 Resolution Preset")
-            preset_more_frames = gr.Button("🎞️ Frames Preset")
+    return output.frames[0]
+
+with gr.Blocks(theme="dark") as demo:
+    with gr.Column():
+        gr.Markdown("# 🎬 Hunyuan Studio")
 
         with gr.Row():
-            result = gr.Video(label="Generated Video")
-
-        with gr.Accordion("⚙️ Advanced Settings", open=False):
-            with gr.Row():
-                seed = gr.Slider(
-                    label="Seed (-1 for random)",
-                    minimum=-1,
-                    maximum=MAX_SEED,
-                    step=1,
-                    value=-1,
-                )
-
-            with gr.Row():
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=16,
-                    value=512,
-                )
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=16,
-                    value=512,
-                )
-
-            with gr.Row():
-                num_frames = gr.Slider(
-                    label="Frame Count",
-                    minimum=1,
-                    maximum=257,
-                    step=1,
-                    value=24,
-                )
-                num_inference_steps = gr.Slider(
-                    label="Inference Steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=25,
-                )
-                fps = gr.Slider(
-                    label="FPS",
-                    minimum=1,
-                    maximum=60,
-                    step=1,
-                    value=12,
-                )
-
-            with gr.Accordion("🧩 LoRA Configuration", open=False):
-                lora_checkboxes = []
-                lora_sliders = []
-                for lora in LORA_CHOICES:
-                    with gr.Row():
-                        cb = gr.Checkbox(label=f"Enable {lora}", value=False)
-                        sl = gr.Slider(0.0, 1.0, value=0.8, label=f"{lora} Weight")
-                        lora_checkboxes.append(cb)
-                        lora_sliders.append(sl)
-
-    # Event handling
-    run_button.click(
+            with gr.Column():
+                prompt = gr.Textbox(label="Prompt")
+                image_input = gr.Image(label="Input Image", type="filepath")
+
+                with gr.Accordion("Advanced Settings"):
+                    resolution = gr.Dropdown(
+                        choices=["512x512", "768x768", "1024x1024"],
+                        value="512x512",
+                        label="Output Resolution"
+                    )
+                    seed = gr.Slider(-1, MAX_SEED, value=-1, label="Seed")
+                    num_frames = gr.Slider(1, 257, 24, label="Frame Count")
+                    num_inference_steps = gr.Slider(1, 50, 25, label="Inference Steps")
+                    fps = gr.Slider(1, 60, 12, label="FPS")
+
+                    with gr.Accordion("LoRA Configuration"):
+                        lora_components = []
+                        for lora in LORA_CHOICES:
+                            lora_components.append(gr.Checkbox(label=f"Enable {lora}"))
+                            lora_components.append(gr.Slider(0.0, 1.0, 0.8, label=f"{lora} Weight"))
+
+                generate_btn = gr.Button("Generate Video")
+
+            with gr.Column():
+                output_video = gr.Video(label="Result")
+
+    generate_btn.click(
         fn=generate,
-        inputs=[prompt, image_input, height, width, num_frames,
-               num_inference_steps, seed, fps, lora_checkboxes, lora_sliders],
-        outputs=result
-    )
-
-    preset_high_res.click(
-        fn=lambda: apply_preset("Higher Resolution"),
-        outputs=[height, width, num_frames, num_inference_steps, fps]
-    )
-
-    preset_more_frames.click(
-        fn=lambda: apply_preset("More Frames"),
-        outputs=[height, width, num_frames, num_inference_steps, fps]
+        inputs=[prompt, image_input,
+               gr.Number(512), gr.Number(512),  # Height/width from resolution
+               num_frames, num_inference_steps, seed, fps,
+               *lora_components],
+        outputs=output_video
     )

requirements.txt

@@ -1,12 +1,11 @@
 --extra-index-url https://download.pytorch.org/whl/cu124
-diffusers==0.29.0
-transformers==4.41.0
-gradio>=4.0.0
+git+https://github.com/huggingface/diffusers.git@main
+git+https://github.com/huggingface/transformers.git@main
 torch>=2.4.0,<2.6.0
-safetensors>=0.4.2
-huggingface_hub>=0.23.0
-imageio>=2.34.0
-opencv-python-headless>=4.9.0
+gradio>=4.0.0
+safetensors
+huggingface_hub
+imageio
+opencv-python-headless
 Pillow>=10.2.0
 numpy<2.0
-accelerate>=0.30.0

utils.py

@@ -1,25 +1,9 @@
 def install_packages():
     import subprocess
     import sys
-    import importlib
-
-    required = [
-        'torch>=2.4.0,<2.6.0',
-        'diffusers',
-        'transformers',
-        'gradio',
-        'safetensors',
-        'huggingface_hub',
-        'imageio',
-        'opencv-python-headless',
-        'Pillow'
-    ]
 
     subprocess.run([
         sys.executable, "-m", "pip", "install",
-        "--upgrade", "pip", "setuptools", "wheel"
+        "-r", "requirements.txt",
+        "--upgrade"
     ], check=True)
-
-    subprocess.run([
-        sys.executable, "-m", "pip", "install"
-    ] + required, check=True)