Added Video Support (#18)

- Added Video Support (24f8595f5086f8051c077849203d663bfba52f7e)
- Update requirements.txt (cb25f513b7f5cca52c02e57a1ffadb3d0bbbd80f)
- Added streaming output and error handling (b9caa337fc287469039d003e38787dc4db8123b4)


Co-authored-by: Nishith Jain <[email protected]>

app.py

@@ -1,79 +1,95 @@
 import gradio as gr
 import spaces
-from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
+from transformers import Qwen2VLForConditionalGeneration, AutoProcessor, TextIteratorStreamer
 from qwen_vl_utils import process_vision_info
 import torch
 from PIL import Image
 import subprocess
-from datetime import datetime
 import numpy as np
 import os
+from threading import Thread
+import uuid
+import io
 
-
-# subprocess.run('pip install flash-attn --no-build-isolation', env={'FLASH_ATTENTION_SKIP_CUDA_BUILD': "TRUE"}, shell=True)
-
-# models = {
-#     "Qwen/Qwen2-VL-2B-Instruct": AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-VL-2B-Instruct", trust_remote_code=True, torch_dtype="auto", _attn_implementation="flash_attention_2").cuda().eval()
-
-# }
-def array_to_image_path(image_array):
-    # Convert numpy array to PIL Image
-    img = Image.fromarray(np.uint8(image_array))
-    
-    # Generate a unique filename using timestamp
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"image_{timestamp}.png"
-    
-    # Save the image
-    img.save(filename)
-    
-    # Get the full path of the saved image
-    full_path = os.path.abspath(filename)
-    
-    return full_path
-    
-models = {
-    "Qwen/Qwen2-VL-2B-Instruct": Qwen2VLForConditionalGeneration.from_pretrained("Qwen/Qwen2-VL-2B-Instruct", trust_remote_code=True, torch_dtype="auto").cuda().eval()
-
-}
-
-processors = {
-    "Qwen/Qwen2-VL-2B-Instruct": AutoProcessor.from_pretrained("Qwen/Qwen2-VL-2B-Instruct", trust_remote_code=True)
-}
+# Model and Processor Loading (Done once at startup)
+MODEL_ID = "Qwen/Qwen2-VL-2B-Instruct"
+model = Qwen2VLForConditionalGeneration.from_pretrained(
+    MODEL_ID,
+    trust_remote_code=True,
+    torch_dtype=torch.float16
+).to("cuda").eval()
+processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)
 
 DESCRIPTION = "[Qwen2-VL-2B Demo](https://huggingface.co/Qwen/Qwen2-VL-2B-Instruct)"
 
-kwargs = {}
-kwargs['torch_dtype'] = torch.bfloat16
+image_extensions = Image.registered_extensions()
+video_extensions = ("avi", "mp4", "mov", "mkv", "flv", "wmv", "mjpeg", "wav", "gif", "webm", "m4v", "3gp")
+
+
+def identify_and_save_blob(blob_path):
+    """Identifies if the blob is an image or video and saves it accordingly."""
+    try:
+        with open(blob_path, 'rb') as file:
+            blob_content = file.read()
+            
+            # Try to identify if it's an image
+            try:
+                Image.open(io.BytesIO(blob_content)).verify()  # Check if it's a valid image
+                extension = ".png"  # Default to PNG for saving
+                media_type = "image"
+            except (IOError, SyntaxError):
+                # If it's not a valid image, assume it's a video
+                extension = ".mp4"  # Default to MP4 for saving
+                media_type = "video"
+            
+            # Create a unique filename
+            filename = f"temp_{uuid.uuid4()}_media{extension}"
+            with open(filename, "wb") as f:
+                f.write(blob_content)
+                
+            return filename, media_type
+            
+    except FileNotFoundError:
+        raise ValueError(f"The file {blob_path} was not found.")
+    except Exception as e:
+        raise ValueError(f"An error occurred while processing the file: {e}")
 
-user_prompt = '<|user|>\n'
-assistant_prompt = '<|assistant|>\n'
-prompt_suffix = "<|end|>\n"
 
 @spaces.GPU
-def run_example(image, text_input=None, model_id="Qwen/Qwen2-VL-2B-Instruct"):
-    image_path = array_to_image_path(image)
-    
-    print(image_path)
-    model = models[model_id]
-    processor = processors[model_id]
-
-    prompt = f"{user_prompt}<|image_1|>\n{text_input}{prompt_suffix}{assistant_prompt}"
-    image = Image.fromarray(image).convert("RGB")
+def qwen_inference(media_input, text_input=None):
+    if isinstance(media_input, str):  # If it's a filepath
+        media_path = media_input
+        if media_path.endswith(tuple([i for i, f in image_extensions.items()])):
+            media_type = "image"
+        elif media_path.endswith(video_extensions): 
+            media_type = "video"
+        else:
+            try:
+                media_path, media_type = identify_and_save_blob(media_input)
+                print(media_path, media_type)
+            except Exception as e:
+                print(e)
+                raise ValueError(
+                    "Unsupported media type. Please upload an image or video."
+                )
+        
+
+    print(media_path)
+
     messages = [
-    {
+        {
             "role": "user",
             "content": [
                 {
-                    "type": "image",
-                    "image": image_path,
+                    "type": media_type,
+                    media_type: media_path,
+                    **({"fps": 8.0} if media_type == "video" else {}),
                 },
                 {"type": "text", "text": text_input},
             ],
         }
     ]
-    
-    # Preparation for inference
+
     text = processor.apply_chat_template(
         messages, tokenize=False, add_generation_prompt=True
     )
@@ -84,19 +100,20 @@ def run_example(image, text_input=None, model_id="Qwen/Qwen2-VL-2B-Instruct"):
         videos=video_inputs,
         padding=True,
         return_tensors="pt",
+    ).to("cuda")
+
+    streamer = TextIteratorStreamer(
+        processor, skip_prompt=True, **{"skip_special_tokens": True}
     )
-    inputs = inputs.to("cuda")
-    
-    # Inference: Generation of the output
-    generated_ids = model.generate(**inputs, max_new_tokens=128)
-    generated_ids_trimmed = [
-        out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
-    ]
-    output_text = processor.batch_decode(
-        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
-    )
-    
-    return output_text[0]
+    generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=1024)
+
+    thread = Thread(target=model.generate, kwargs=generation_kwargs)
+    thread.start()
+
+    buffer = ""
+    for new_text in streamer:
+        buffer += new_text
+        yield buffer
 
 css = """
   #output {
@@ -108,17 +125,20 @@ css = """
 
 with gr.Blocks(css=css) as demo:
     gr.Markdown(DESCRIPTION)
-    with gr.Tab(label="Qwen2-VL-2B Input"):
+
+    with gr.Tab(label="Image/Video Input"):
         with gr.Row():
             with gr.Column():
-                input_img = gr.Image(label="Input Picture")
-                model_selector = gr.Dropdown(choices=list(models.keys()), label="Model", value="Qwen/Qwen2-VL-2B-Instruct")
+                input_media = gr.File(
+                    label="Upload Image or Video", type="filepath" 
+                )
                 text_input = gr.Textbox(label="Question")
                 submit_btn = gr.Button(value="Submit")
             with gr.Column():
                 output_text = gr.Textbox(label="Output Text")
 
-        submit_btn.click(run_example, [input_img, text_input, model_selector], [output_text])
+        submit_btn.click(
+            qwen_inference, [input_media, text_input], [output_text]
+        )
 
-demo.queue(api_open=False)
 demo.launch(debug=True)

requirements.txt

@@ -5,4 +5,5 @@ torch
 torchvision
 git+https://github.com/huggingface/transformers.git
 accelerate
-qwen-vl-utils
+qwen-vl-utils
+av