Deploy UniVideo Studio - app.py

app.py

@@ -0,0 +1,237 @@
+import gradio as gr
+import os
+import requests
+from PIL import Image
+import io
+
+# Note: UniVideo requires significant GPU resources
+# This Space provides a UI that would connect to the Inference API
+# For local deployment, you'd need to follow the full installation from:
+# https://github.com/KlingTeam/UniVideo
+
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+MODEL_ID = "KlingTeam/UniVideo"
+
+def call_inference_api(task, **kwargs):
+    """
+    Call the Hugging Face Inference API for UniVideo
+    Note: As of now, UniVideo may not be available via standard Inference API
+    This is a template for when it becomes available
+    """
+    api_url = f"https://api-inference.huggingface.co/models/{MODEL_ID}"
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+    
+    try:
+        response = requests.post(api_url, headers=headers, json=kwargs, timeout=120)
+        if response.status_code == 200:
+            return response.content
+        else:
+            return None, f"API Error: {response.status_code} - {response.text}"
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+def text_to_video(prompt, duration=5):
+    """Generate video from text prompt"""
+    return None, """
+    ⚠️ **UniVideo requires GPU resources**
+    
+    This model is not yet available via the standard Inference API.
+    
+    **To use UniVideo:**
+    1. Clone the repository: https://github.com/KlingTeam/UniVideo
+    2. Follow installation instructions
+    3. Download the checkpoint from: https://huggingface.co/KlingTeam/UniVideo
+    4. Run locally with GPU (recommended: A100 or H100)
+    
+    **Alternative:** Upgrade this Space to GPU hardware and implement the full pipeline.
+    
+    Your prompt: "{}"
+    """.format(prompt)
+
+def image_to_video(image, prompt):
+    """Animate image to video"""
+    if image is None:
+        return None, "Please upload an image"
+    
+    return None, """
+    ⚠️ **UniVideo Image-to-Video requires GPU**
+    
+    This feature requires running the full UniVideo model locally.
+    
+    **Quick Start:**
+    ```bash
+    cd univideo
+    python univideo_inference.py --task i2v --config configs/univideo_qwen2p5vl7b_hidden_hunyuanvideo.yaml
+    ```
+    
+    Your prompt: "{}"
+    """.format(prompt)
+
+def video_understanding(video):
+    """Understand and describe video content"""
+    if video is None:
+        return "Please upload a video"
+    
+    return """
+    ⚠️ **UniVideo Understanding requires GPU**
+    
+    To analyze videos with UniVideo:
+    ```bash
+    python univideo_inference.py --task understanding --config configs/univideo_qwen2p5vl7b_hidden_hunyuanvideo.yaml
+    ```
+    """
+
+def video_editing(video, instruction):
+    """Edit video based on text instruction"""
+    if video is None:
+        return None, "Please upload a video"
+    
+    return None, f"""
+    ⚠️ **UniVideo Video Editing requires GPU**
+    
+    To edit videos with UniVideo:
+    ```bash
+    python univideo_inference.py --task v2v_edit --config configs/univideo_qwen2p5vl7b_hidden_hunyuanvideo.yaml
+    ```
+    
+    Your instruction: "{instruction}"
+    """
+
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="UniVideo Studio") as demo:
+    gr.Markdown("# 🎬 UniVideo Studio")
+    gr.Markdown("**Unified Understanding, Generation, and Editing for Videos**")
+    gr.Markdown("⚠️ *Note: This Space requires GPU hardware. Currently showing setup instructions.*")
+    
+    with gr.Tabs():
+        # Text-to-Video Tab
+        with gr.Tab("📝 Text-to-Video"):
+            with gr.Row():
+                with gr.Column():
+                    t2v_prompt = gr.Textbox(
+                        label="Prompt",
+                        placeholder="Describe the video you want to generate...",
+                        lines=3
+                    )
+                    t2v_duration = gr.Slider(3, 10, value=5, step=1, label="Duration (seconds)")
+                    t2v_btn = gr.Button("Generate Video", variant="primary")
+                
+                with gr.Column():
+                    t2v_output = gr.Video(label="Generated Video")
+                    t2v_status = gr.Textbox(label="Status", lines=10)
+            
+            t2v_btn.click(
+                fn=text_to_video,
+                inputs=[t2v_prompt, t2v_duration],
+                outputs=[t2v_output, t2v_status]
+            )
+        
+        # Image-to-Video Tab
+        with gr.Tab("🖼️ Image-to-Video"):
+            with gr.Row():
+                with gr.Column():
+                    i2v_image = gr.Image(label="Input Image", type="pil")
+                    i2v_prompt = gr.Textbox(
+                        label="Motion Description",
+                        placeholder="Describe how the image should animate...",
+                        lines=2
+                    )
+                    i2v_btn = gr.Button("Animate Image", variant="primary")
+                
+                with gr.Column():
+                    i2v_output = gr.Video(label="Generated Video")
+                    i2v_status = gr.Textbox(label="Status", lines=10)
+            
+            i2v_btn.click(
+                fn=image_to_video,
+                inputs=[i2v_image, i2v_prompt],
+                outputs=[i2v_output, i2v_status]
+            )
+        
+        # Video Understanding Tab
+        with gr.Tab("🧠 Video Understanding"):
+            with gr.Row():
+                with gr.Column():
+                    vu_video = gr.Video(label="Input Video")
+                    vu_btn = gr.Button("Analyze Video", variant="primary")
+                
+                with gr.Column():
+                    vu_output = gr.Textbox(label="Analysis", lines=15)
+            
+            vu_btn.click(
+                fn=video_understanding,
+                inputs=[vu_video],
+                outputs=[vu_output]
+            )
+        
+        # Video Editing Tab
+        with gr.Tab("✂️ Video Editing"):
+            with gr.Row():
+                with gr.Column():
+                    ve_video = gr.Video(label="Input Video")
+                    ve_instruction = gr.Textbox(
+                        label="Editing Instruction",
+                        placeholder="Describe how to edit the video...",
+                        lines=2
+                    )
+                    ve_btn = gr.Button("Edit Video", variant="primary")
+                
+                with gr.Column():
+                    ve_output = gr.Video(label="Edited Video")
+                    ve_status = gr.Textbox(label="Status", lines=10)
+            
+            ve_btn.click(
+                fn=video_editing,
+                inputs=[ve_video, ve_instruction],
+                outputs=[ve_output, ve_status]
+            )
+    
+    gr.Markdown("""
+    ## 📚 Resources
+    
+    - **Paper**: [UniVideo: Unified Understanding, Generation, and Editing for Videos](https://arxiv.org/abs/2510.08377)
+    - **GitHub**: [KlingTeam/UniVideo](https://github.com/KlingTeam/UniVideo)
+    - **Model**: [KlingTeam/UniVideo on Hugging Face](https://huggingface.co/KlingTeam/UniVideo)
+    - **Demo Page**: [UniVideo Project Page](https://congwei1230.github.io/UniVideo/)
+    
+    ## 💡 To Run UniVideo Locally
+    
+    1. **Clone Repository**:
+       ```bash
+       git clone https://github.com/KlingTeam/UniVideo.git
+       cd UniVideo
+       ```
+    
+    2. **Install Dependencies**:
+       ```bash
+       conda env create -f environment.yml
+       conda activate univideo
+       ```
+    
+    3. **Download Checkpoint**:
+       ```bash
+       python download_ckpt.py
+       ```
+    
+    4. **Run Inference**:
+       ```bash
+       cd univideo
+       python univideo_inference.py --task i2v --config configs/univideo_qwen2p5vl7b_hidden_hunyuanvideo.yaml
+       ```
+    
+    ## ⚙️ Hardware Requirements
+    
+    - **Recommended**: NVIDIA A100 (80GB) or H100
+    - **Minimum**: NVIDIA GPU with 24GB+ VRAM
+    - **CPU**: Not supported (model is too large)
+    
+    ## 🔧 To Enable This Space
+    
+    1. Upgrade Space hardware to GPU (Settings → Hardware)
+    2. Implement full UniVideo pipeline in `app.py`
+    3. Add model checkpoint loading
+    4. Configure inference parameters
+    """)
+
+if __name__ == "__main__":
+    demo.launch()