Duplicate from prithivMLmods/VLM-Video-Understanding

Co-authored-by: Prithiv Sakthi <prithivMLmods@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

Aya-Vision-8B/aya_vision_8b.ipynb

@@ -0,0 +1,189 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "m7rU-pjX3Y1O"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio transformers accelerate numpy\n",
+        "!pip install torch torchvision av hf_xet spaces\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "dZUVag_jJMck"
+      },
+      "outputs": [],
+      "source": [
+        "from huggingface_hub import notebook_login, HfApi\n",
+        "notebook_login()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "kW4MjaOs3c9E"
+      },
+      "outputs": [],
+      "source": [
+        "import gradio as gr\n",
+        "from transformers import AutoProcessor, TextIteratorStreamer, AutoModelForImageTextToText\n",
+        "from transformers.image_utils import load_image\n",
+        "from threading import Thread\n",
+        "import time\n",
+        "import torch\n",
+        "import spaces\n",
+        "import cv2\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "\n",
+        "# Helper: progress bar HTML\n",
+        "def progress_bar_html(label: str) -> str:\n",
+        "    return f'''\n",
+        "<div style=\"display: flex; align-items: center;\">\n",
+        "    <span style=\"margin-right: 10px; font-size: 14px;\">{label}</span>\n",
+        "    <div style=\"width: 110px; height: 5px; background-color: #FFB6C1; border-radius: 2px; overflow: hidden;\">\n",
+        "        <div style=\"width: 100%; height: 100%; background-color: #FF69B4; animation: loading 1.5s linear infinite;\"></div>\n",
+        "    </div>\n",
+        "</div>\n",
+        "<style>\n",
+        "@keyframes loading {{\n",
+        "    0% {{ transform: translateX(-100%); }}\n",
+        "    100% {{ transform: translateX(100%); }}\n",
+        "}}\n",
+        "</style>\n",
+        "    '''\n",
+        "\n",
+        "# Aya Vision 8B setup\n",
+        "AYA_MODEL_ID = \"CohereForAI/aya-vision-8b\"\n",
+        "aya_processor = AutoProcessor.from_pretrained(AYA_MODEL_ID)\n",
+        "aya_model = AutoModelForImageTextToText.from_pretrained(\n",
+        "    AYA_MODEL_ID,\n",
+        "    device_map=\"auto\",\n",
+        "    torch_dtype=torch.float16\n",
+        ")\n",
+        "\n",
+        "def downsample_video(video_path, num_frames=10):\n",
+        "    \"\"\"\n",
+        "    Extract evenly spaced frames and timestamps from a video file.\n",
+        "    Returns list of (PIL.Image, timestamp_sec).\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS) or 30\n",
+        "    indices = np.linspace(0, total-1, num_frames, dtype=int)\n",
+        "    frames = []\n",
+        "    for idx in indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))\n",
+        "        ret, frame = vidcap.read()\n",
+        "        if not ret:\n",
+        "            continue\n",
+        "        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
+        "        pil = Image.fromarray(frame)\n",
+        "        timestamp = round(idx / fps, 2)\n",
+        "        frames.append((pil, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def process_image(prompt: str, image: Image.Image):\n",
+        "    if image is None:\n",
+        "        yield \"Error: Please upload an image.\"\n",
+        "        return\n",
+        "    if not prompt.strip():\n",
+        "        yield \"Error: Please provide a prompt with the image.\"\n",
+        "        return\n",
+        "    yield progress_bar_html(\"Processing Image with Aya Vision 8B\")\n",
+        "    messages = [{\"role\": \"user\", \"content\": [\n",
+        "        {\"type\": \"image\", \"image\": image},\n",
+        "        {\"type\": \"text\", \"text\": prompt.strip()}\n",
+        "    ]}]\n",
+        "    inputs = aya_processor.apply_chat_template(\n",
+        "        messages, padding=True, add_generation_prompt=True,\n",
+        "        tokenize=True, return_dict=True, return_tensors=\"pt\"\n",
+        "    ).to(aya_model.device)\n",
+        "    streamer = TextIteratorStreamer(aya_processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    thread = Thread(target=aya_model.generate, kwargs={**inputs, \"streamer\": streamer, \"max_new_tokens\": 1024, \"do_sample\": True, \"temperature\": 0.3})\n",
+        "    thread.start()\n",
+        "    buff = \"\"\n",
+        "    for chunk in streamer:\n",
+        "        buff += chunk.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buff\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def process_video(prompt: str, video_file: str):\n",
+        "    if video_file is None:\n",
+        "        yield \"Error: Please upload a video.\"\n",
+        "        return\n",
+        "    if not prompt.strip():\n",
+        "        yield \"Error: Please provide a prompt with the video.\"\n",
+        "        return\n",
+        "    yield progress_bar_html(\"Processing Video with Aya Vision 8B\")\n",
+        "    frames = downsample_video(video_file)\n",
+        "    # Build chat messages with each frame and timestamp\n",
+        "    content = [{\"type\": \"text\", \"text\": prompt.strip()}]\n",
+        "    for img, ts in frames:\n",
+        "        content.append({\"type\": \"text\", \"text\": f\"Frame at {ts}s:\"})\n",
+        "        content.append({\"type\": \"image\", \"image\": img})\n",
+        "    messages = [{\"role\": \"user\", \"content\": content}]\n",
+        "    inputs = aya_processor.apply_chat_template(\n",
+        "        messages, tokenize=True, add_generation_prompt=True,\n",
+        "        return_dict=True, return_tensors=\"pt\"\n",
+        "    ).to(aya_model.device)\n",
+        "    streamer = TextIteratorStreamer(aya_processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    thread = Thread(target=aya_model.generate, kwargs={**inputs, \"streamer\": streamer, \"max_new_tokens\": 1024, \"do_sample\": True, \"temperature\": 0.3})\n",
+        "    thread.start()\n",
+        "    buff = \"\"\n",
+        "    for chunk in streamer:\n",
+        "        buff += chunk.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buff\n",
+        "\n",
+        "# Build Gradio UI\n",
+        "demo = gr.Blocks()\n",
+        "with demo:\n",
+        "    gr.Markdown(\"# **Aya Vision 8B Multimodal: Image & Video**\")\n",
+        "    with gr.Tabs():\n",
+        "        with gr.TabItem(\"Image Inference\"):\n",
+        "            txt_i = gr.Textbox(label=\"Prompt\", placeholder=\"Enter prompt...\")\n",
+        "            img_u = gr.Image(type=\"filepath\", label=\"Image\")\n",
+        "            btn_i = gr.Button(\"Run Image\")\n",
+        "            out_i = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "            btn_i.click(fn=process_image, inputs=[txt_i, img_u], outputs=out_i)\n",
+        "        with gr.TabItem(\"Video Inference\"):\n",
+        "            txt_v = gr.Textbox(label=\"Prompt\", placeholder=\"Enter prompt...\")\n",
+        "            vid_u = gr.Video(label=\"Video\")\n",
+        "            btn_v = gr.Button(\"Run Video\")\n",
+        "            out_v = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "            btn_v.click(fn=process_video, inputs=[txt_v, vid_u], outputs=out_v)\n",
+        "\n",
+        "demo.launch(debug=True, share=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Florence-2-Base/Florence_2_base.ipynb

@@ -0,0 +1,94 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "m7rU-pjX3Y1O"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio transformers==4.30.2 pillow\n",
+        "!pip install torch torchvision hf_xet timm==1.0.10\n",
+        "!pip install flash-attn --no-build-isolation"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import gradio as gr\n",
+        "import torch\n",
+        "from PIL import Image\n",
+        "from transformers import AutoProcessor, AutoModelForCausalLM\n",
+        "\n",
+        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "vision_language_model = AutoModelForCausalLM.from_pretrained('microsoft/Florence-2-base', trust_remote_code=True).to(device).eval()\n",
+        "vision_language_processor = AutoProcessor.from_pretrained('microsoft/Florence-2-base', trust_remote_code=True)\n",
+        "\n",
+        "def describe_image(uploaded_image):\n",
+        "    \"\"\"\n",
+        "    Generates a detailed description of the input image.\n",
+        "\n",
+        "    Args:\n",
+        "        uploaded_image (PIL.Image.Image or numpy.ndarray): The image to describe.\n",
+        "\n",
+        "    Returns:\n",
+        "        str: A detailed textual description of the image.\n",
+        "    \"\"\"\n",
+        "    if not isinstance(uploaded_image, Image.Image):\n",
+        "        uploaded_image = Image.fromarray(uploaded_image)\n",
+        "\n",
+        "    inputs = vision_language_processor(text=\"<MORE_DETAILED_CAPTION>\", images=uploaded_image, return_tensors=\"pt\").to(device)\n",
+        "    with torch.no_grad():\n",
+        "        generated_ids = vision_language_model.generate(\n",
+        "            input_ids=inputs[\"input_ids\"],\n",
+        "            pixel_values=inputs[\"pixel_values\"],\n",
+        "            max_new_tokens=1024,\n",
+        "            early_stopping=False,\n",
+        "            do_sample=False,\n",
+        "            num_beams=3,\n",
+        "        )\n",
+        "    generated_text = vision_language_processor.batch_decode(generated_ids, skip_special_tokens=False)[0]\n",
+        "    processed_description = vision_language_processor.post_process_generation(\n",
+        "        generated_text,\n",
+        "        task=\"<MORE_DETAILED_CAPTION>\",\n",
+        "        image_size=(uploaded_image.width, uploaded_image.height)\n",
+        "    )\n",
+        "    image_description = processed_description[\"<MORE_DETAILED_CAPTION>\"]\n",
+        "    print(\"\\nImage description generated!:\", image_description)\n",
+        "    return image_description\n",
+        "\n",
+        "image_description_interface = gr.Interface(\n",
+        "    fn=describe_image,\n",
+        "    inputs=gr.Image(label=\"Upload Image\"),\n",
+        "    outputs=gr.Textbox(label=\"Generated Caption\", lines=4, show_copy_button=True),\n",
+        "    live=False,\n",
+        ")\n",
+        "\n",
+        "image_description_interface.launch(debug=True, ssr_mode=False)"
+      ],
+      "metadata": {
+        "id": "kW4MjaOs3c9E"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Gemma3-VL/Gemma3_4B_it.ipynb

@@ -0,0 +1,369 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "m7rU-pjX3Y1O"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio transformers accelerate numpy requests\n",
+        "!pip install torch torchvision av hf_xet qwen-vl-utils\n",
+        "!pip install pillow huggingface_hub opencv-python spaces"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from huggingface_hub import notebook_login, HfApi\n",
+        "notebook_login()"
+      ],
+      "metadata": {
+        "id": "dZUVag_jJMck"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "import re\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    AutoProcessor,\n",
+        "    Gemma3ForConditionalGeneration,\n",
+        "    Qwen2VLForConditionalGeneration,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"4096\"))\n",
+        "MAX_SEED = np.iinfo(np.int32).max\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "# Helper function to return a progress bar HTML snippet.\n",
+        "def progress_bar_html(label: str) -> str:\n",
+        "    return f'''\n",
+        "<div style=\"display: flex; align-items: center;\">\n",
+        "    <span style=\"margin-right: 10px; font-size: 14px;\">{label}</span>\n",
+        "    <div style=\"width: 110px; height: 5px; background-color: #F0FFF0; border-radius: 2px; overflow: hidden;\">\n",
+        "        <div style=\"width: 100%; height: 100%; background-color: #00FF00; animation: loading 1.5s linear infinite;\"></div>\n",
+        "    </div>\n",
+        "</div>\n",
+        "<style>\n",
+        "@keyframes loading {{\n",
+        "    0% {{ transform: translateX(-100%); }}\n",
+        "    100% {{ transform: translateX(100%); }}\n",
+        "}}\n",
+        "</style>\n",
+        "    '''\n",
+        "\n",
+        "# Qwen2-VL (for optional image inference)\n",
+        "\n",
+        "MODEL_ID_VL = \"prithivMLmods/Qwen2-VL-OCR-2B-Instruct\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID_VL, trust_remote_code=True)\n",
+        "model_m = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID_VL,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def clean_chat_history(chat_history):\n",
+        "    cleaned = []\n",
+        "    for msg in chat_history:\n",
+        "        if isinstance(msg, dict) and isinstance(msg.get(\"content\"), str):\n",
+        "            cleaned.append(msg)\n",
+        "    return cleaned\n",
+        "\n",
+        "bad_words = json.loads(os.getenv('BAD_WORDS', \"[]\"))\n",
+        "bad_words_negative = json.loads(os.getenv('BAD_WORDS_NEGATIVE', \"[]\"))\n",
+        "default_negative = os.getenv(\"default_negative\", \"\")\n",
+        "\n",
+        "def check_text(prompt, negative=\"\"):\n",
+        "    for i in bad_words:\n",
+        "        if i in prompt:\n",
+        "            return True\n",
+        "    for i in bad_words_negative:\n",
+        "        if i in negative:\n",
+        "            return True\n",
+        "    return False\n",
+        "\n",
+        "def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:\n",
+        "    if randomize_seed:\n",
+        "        seed = random.randint(0, MAX_SEED)\n",
+        "    return seed\n",
+        "\n",
+        "CACHE_EXAMPLES = torch.cuda.is_available() and os.getenv(\"CACHE_EXAMPLES\", \"0\") == \"1\"\n",
+        "MAX_IMAGE_SIZE = int(os.getenv(\"MAX_IMAGE_SIZE\", \"2048\"))\n",
+        "USE_TORCH_COMPILE = os.getenv(\"USE_TORCH_COMPILE\", \"0\") == \"1\"\n",
+        "ENABLE_CPU_OFFLOAD = os.getenv(\"ENABLE_CPU_OFFLOAD\", \"0\") == \"1\"\n",
+        "\n",
+        "dtype = torch.float16 if device.type == \"cuda\" else torch.float32\n",
+        "\n",
+        "\n",
+        "# Gemma3 Model (default for text, image, & video inference)\n",
+        "\n",
+        "gemma3_model_id = \"google/gemma-3-4b-it\"  # alternative: google/gemma-3-12b-it\n",
+        "gemma3_model = Gemma3ForConditionalGeneration.from_pretrained(\n",
+        "    gemma3_model_id, device_map=\"auto\"\n",
+        ").eval()\n",
+        "gemma3_processor = AutoProcessor.from_pretrained(gemma3_model_id)\n",
+        "\n",
+        "# VIDEO PROCESSING HELPER\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            # Convert from BGR to RGB and then to PIL Image.\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "# MAIN GENERATION FUNCTION\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate(\n",
+        "    input_dict: dict,\n",
+        "    chat_history: list[dict],\n",
+        "    max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,\n",
+        "    temperature: float = 0.6,\n",
+        "    top_p: float = 0.9,\n",
+        "    top_k: int = 50,\n",
+        "    repetition_penalty: float = 1.2,\n",
+        "):\n",
+        "    text = input_dict[\"text\"]\n",
+        "    files = input_dict.get(\"files\", [])\n",
+        "    lower_text = text.lower().strip()\n",
+        "\n",
+        "    # ----- Qwen2-VL branch (triggered with @qwen2-vl) -----\n",
+        "    if lower_text.startswith(\"@qwen2-vl\"):\n",
+        "        prompt_clean = re.sub(r\"@qwen2-vl\", \"\", text, flags=re.IGNORECASE).strip().strip('\"')\n",
+        "        if files:\n",
+        "            images = [load_image(f) for f in files]\n",
+        "            messages = [{\n",
+        "                \"role\": \"user\",\n",
+        "                \"content\": [\n",
+        "                    *[{\"type\": \"image\", \"image\": image} for image in images],\n",
+        "                    {\"type\": \"text\", \"text\": prompt_clean},\n",
+        "                ]\n",
+        "            }]\n",
+        "            prompt = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "            inputs = processor(text=[prompt], images=images, return_tensors=\"pt\", padding=True).to(\"cuda\")\n",
+        "        else:\n",
+        "            messages = [\n",
+        "                {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "                {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": prompt_clean}]}\n",
+        "            ]\n",
+        "            inputs = processor.apply_chat_template(\n",
+        "                messages, add_generation_prompt=True, tokenize=True,\n",
+        "                return_dict=True, return_tensors=\"pt\"\n",
+        "            ).to(\"cuda\", dtype=torch.float16)\n",
+        "        streamer = TextIteratorStreamer(processor.tokenizer, timeout=20.0, skip_prompt=True, skip_special_tokens=True)\n",
+        "        generation_kwargs = {\n",
+        "            **inputs,\n",
+        "            \"streamer\": streamer,\n",
+        "            \"max_new_tokens\": max_new_tokens,\n",
+        "            \"do_sample\": True,\n",
+        "            \"temperature\": temperature,\n",
+        "            \"top_p\": top_p,\n",
+        "            \"top_k\": top_k,\n",
+        "            \"repetition_penalty\": repetition_penalty,\n",
+        "        }\n",
+        "        thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "        thread.start()\n",
+        "        buffer = \"\"\n",
+        "        yield progress_bar_html(\"Processing with Qwen2VL\")\n",
+        "        for new_text in streamer:\n",
+        "            buffer += new_text\n",
+        "            buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "            time.sleep(0.01)\n",
+        "            yield buffer\n",
+        "        return\n",
+        "\n",
+        "    # ----- Default branch: Gemma3 (for text, image, & video inference) -----\n",
+        "    if files:\n",
+        "        # Check if any provided file is a video based on extension.\n",
+        "        video_extensions = (\".mp4\", \".mov\", \".avi\", \".mkv\", \".webm\")\n",
+        "        if any(str(f).lower().endswith(video_extensions) for f in files):\n",
+        "            # Video inference branch.\n",
+        "            prompt_clean = re.sub(r\"@video-infer\", \"\", text, flags=re.IGNORECASE).strip().strip('\"')\n",
+        "            video_path = files[0]\n",
+        "            frames = downsample_video(video_path)\n",
+        "            messages = [\n",
+        "                {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "                {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": prompt_clean}]}\n",
+        "            ]\n",
+        "            # Append each frame (with its timestamp) to the conversation.\n",
+        "            for frame in frames:\n",
+        "                image, timestamp = frame\n",
+        "                image_path = f\"video_frame_{uuid.uuid4().hex}.png\"\n",
+        "                image.save(image_path)\n",
+        "                messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "                messages[1][\"content\"].append({\"type\": \"image\", \"url\": image_path})\n",
+        "            inputs = gemma3_processor.apply_chat_template(\n",
+        "                messages, add_generation_prompt=True, tokenize=True,\n",
+        "                return_dict=True, return_tensors=\"pt\"\n",
+        "            ).to(gemma3_model.device, dtype=torch.bfloat16)\n",
+        "            streamer = TextIteratorStreamer(gemma3_processor.tokenizer, timeout=20.0, skip_prompt=True, skip_special_tokens=True)\n",
+        "            generation_kwargs = {\n",
+        "                **inputs,\n",
+        "                \"streamer\": streamer,\n",
+        "                \"max_new_tokens\": max_new_tokens,\n",
+        "                \"do_sample\": True,\n",
+        "                \"temperature\": temperature,\n",
+        "                \"top_p\": top_p,\n",
+        "                \"top_k\": top_k,\n",
+        "                \"repetition_penalty\": repetition_penalty,\n",
+        "            }\n",
+        "            thread = Thread(target=gemma3_model.generate, kwargs=generation_kwargs)\n",
+        "            thread.start()\n",
+        "            buffer = \"\"\n",
+        "            yield progress_bar_html(\"Processing video with Gemma3\")\n",
+        "            for new_text in streamer:\n",
+        "                buffer += new_text\n",
+        "                time.sleep(0.01)\n",
+        "                yield buffer\n",
+        "            return\n",
+        "        else:\n",
+        "            # Image inference branch.\n",
+        "            prompt_clean = re.sub(r\"@gemma3\", \"\", text, flags=re.IGNORECASE).strip().strip('\"')\n",
+        "            images = [load_image(f) for f in files]\n",
+        "            messages = [{\n",
+        "                \"role\": \"user\",\n",
+        "                \"content\": [\n",
+        "                    *[{\"type\": \"image\", \"image\": image} for image in images],\n",
+        "                    {\"type\": \"text\", \"text\": prompt_clean},\n",
+        "                ]\n",
+        "            }]\n",
+        "            inputs = gemma3_processor.apply_chat_template(\n",
+        "                messages, tokenize=True, add_generation_prompt=True,\n",
+        "                return_dict=True, return_tensors=\"pt\"\n",
+        "            ).to(gemma3_model.device, dtype=torch.bfloat16)\n",
+        "            streamer = TextIteratorStreamer(gemma3_processor.tokenizer, timeout=20.0, skip_prompt=True, skip_special_tokens=True)\n",
+        "            generation_kwargs = {\n",
+        "                **inputs,\n",
+        "                \"streamer\": streamer,\n",
+        "                \"max_new_tokens\": max_new_tokens,\n",
+        "                \"do_sample\": True,\n",
+        "                \"temperature\": temperature,\n",
+        "                \"top_p\": top_p,\n",
+        "                \"top_k\": top_k,\n",
+        "                \"repetition_penalty\": repetition_penalty,\n",
+        "            }\n",
+        "            thread = Thread(target=gemma3_model.generate, kwargs=generation_kwargs)\n",
+        "            thread.start()\n",
+        "            buffer = \"\"\n",
+        "            yield progress_bar_html(\"Processing with Gemma3\")\n",
+        "            for new_text in streamer:\n",
+        "                buffer += new_text\n",
+        "                time.sleep(0.01)\n",
+        "                yield buffer\n",
+        "            return\n",
+        "    else:\n",
+        "        # Text-only inference branch.\n",
+        "        messages = [\n",
+        "            {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "            {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "        ]\n",
+        "        inputs = gemma3_processor.apply_chat_template(\n",
+        "            messages, add_generation_prompt=True, tokenize=True,\n",
+        "            return_dict=True, return_tensors=\"pt\"\n",
+        "        ).to(gemma3_model.device, dtype=torch.bfloat16)\n",
+        "        streamer = TextIteratorStreamer(gemma3_processor.tokenizer, timeout=20.0, skip_prompt=True, skip_special_tokens=True)\n",
+        "        generation_kwargs = {\n",
+        "            **inputs,\n",
+        "            \"streamer\": streamer,\n",
+        "            \"max_new_tokens\": max_new_tokens,\n",
+        "            \"do_sample\": True,\n",
+        "            \"temperature\": temperature,\n",
+        "            \"top_p\": top_p,\n",
+        "            \"top_k\": top_k,\n",
+        "            \"repetition_penalty\": repetition_penalty,\n",
+        "        }\n",
+        "        thread = Thread(target=gemma3_model.generate, kwargs=generation_kwargs)\n",
+        "        thread.start()\n",
+        "        outputs = []\n",
+        "        for new_text in streamer:\n",
+        "            outputs.append(new_text)\n",
+        "            yield \"\".join(outputs)\n",
+        "        final_response = \"\".join(outputs)\n",
+        "        yield final_response\n",
+        "\n",
+        "\n",
+        "# Gradio Interface\n",
+        "\n",
+        "demo = gr.ChatInterface(\n",
+        "    fn=generate,\n",
+        "    additional_inputs=[\n",
+        "        gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS),\n",
+        "        gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6),\n",
+        "        gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9),\n",
+        "        gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50),\n",
+        "        gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2),\n",
+        "    ],\n",
+        "    type=\"messages\",\n",
+        "    description=\"# **Gemma 3 Multimodal** \\n`Use @qwen2-vl to switch to Qwen2-VL OCR for image inference and @video-infer for video input`\",\n",
+        "    fill_height=True,\n",
+        "    textbox=gr.MultimodalTextbox(label=\"Query Input\", file_types=[\"image\", \"video\"], file_count=\"multiple\", placeholder=\"Tag with @qwen2-vl for Qwen2-VL inference if needed.\"),\n",
+        "    stop_btn=\"Stop Generation\",\n",
+        "    multimodal=True,\n",
+        ")\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=20).launch(share=True)"
+      ],
+      "metadata": {
+        "id": "kW4MjaOs3c9E"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Imgscope-OCR-2B-0527/Imgscope-OCR-2B-05270-Video-Understanding/Imgscope-OCR-2B-0527-Video-Understanding.ipynb

@@ -0,0 +1,164 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "XKQwuI75LWLA"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio transformers pillow opencv-python\n",
+        "!pip install accelerate torchvision torch huggingface_hub\n",
+        "!pip install hf_xet qwen-vl-utils gradio_client\n",
+        "!pip install transformers-stream-generator spaces"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import uuid\n",
+        "import time\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "import cv2\n",
+        "from PIL import Image\n",
+        "from transformers import Qwen2VLForConditionalGeneration, AutoProcessor\n",
+        "\n",
+        "# Ensure CUDA if available\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "# Load Callisto OCR3 multimodal model and processor\n",
+        "MODEL_ID = \"prithivMLmods/Imgscope-OCR-2B-0527\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(device).eval()\n",
+        "\n",
+        "# Constants\n",
+        "MAX_INPUT_TOKEN_LENGTH = 4096\n",
+        "\n",
+        "\n",
+        "def downsample_video(video_path: str, num_frames: int = 10):\n",
+        "    \"\"\"\n",
+        "    Extracts 'num_frames' evenly spaced frames from the video.\n",
+        "    Returns a list of (PIL.Image, timestamp_seconds).\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS) or 1\n",
+        "    indices = np.linspace(0, total - 1, num_frames, dtype=int)\n",
+        "    frames = []\n",
+        "    for idx in indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, idx)\n",
+        "        ret, frame = vidcap.read()\n",
+        "        if not ret:\n",
+        "            continue\n",
+        "        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
+        "        pil = Image.fromarray(frame)\n",
+        "        timestamp = round(idx / fps, 2)\n",
+        "        frames.append((pil, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "\n",
+        "def generate(video_file: str):\n",
+        "    \"\"\"\n",
+        "    Process the uploaded video through OCR and return concatenated output.\n",
+        "    \"\"\"\n",
+        "    # Step 1: extract frames\n",
+        "    frames = downsample_video(video_file)\n",
+        "\n",
+        "    # Step 2: build chat-like messages\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant, for video understanding.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": \"Please describe the content of the following video frames:\"}]\n",
+        "        }\n",
+        "    ]\n",
+        "    for img, ts in frames:\n",
+        "        # save temporary frame image\n",
+        "        path = f\"frame_{uuid.uuid4().hex}.png\"\n",
+        "        img.save(path)\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame at {ts}s:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"url\": path})\n",
+        "\n",
+        "    # Step 3: tokenize with truncation\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=True,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(device)\n",
+        "\n",
+        "    # Step 4: use streamer to collect output\n",
+        "    from transformers import TextIteratorStreamer\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    gen_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": 1024,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": 0.7,\n",
+        "    }\n",
+        "    thread = Thread(target=model.generate, kwargs=gen_kwargs)\n",
+        "    thread.start()\n",
+        "\n",
+        "    # collect all tokens\n",
+        "    buffer = \"\"\n",
+        "    for chunk in streamer:\n",
+        "        buffer += chunk.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "\n",
+        "    # return full concatenated response\n",
+        "    return buffer\n",
+        "\n",
+        "\n",
+        "def launch_app():\n",
+        "    demo = gr.Interface(\n",
+        "        fn=generate,\n",
+        "        inputs=gr.Video(label=\"Upload Video\"),\n",
+        "        outputs=gr.Textbox(label=\"Video Description\"),\n",
+        "        title=\"Video Understanding with Imgscope-OCR-2B-0527\",\n",
+        "        description=\"Upload a video and get an OCR-based description of its frames.\",\n",
+        "        allow_flagging=\"never\"\n",
+        "    )\n",
+        "    demo.queue().launch(debug=True)\n",
+        "\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    launch_app()"
+      ],
+      "metadata": {
+        "id": "GZXqC00zLbS1"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Imgscope-OCR-2B-0527/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Imgscope-OCR-2B-0527/README.md

@@ -0,0 +1,178 @@
+![2.png](https://cdn-uploads.huggingface.co/production/uploads/65bb837dbfb878f46c77de4c/yUKVKSX2E18k0h3YwCx1h.png)
+
+# **Imgscope-OCR-2B-0527**
+
+> The **Imgscope-OCR-2B-0527** model is a fine-tuned version of *Qwen2-VL-2B-Instruct*, specifically optimized for *messy handwriting recognition*, *document OCR*, *realistic handwritten OCR*, and *math problem solving with LaTeX formatting*. This model is trained on custom datasets for document and handwriting OCR tasks and integrates a conversational approach with strong visual and textual understanding for multi-modal applications.
+
+> [!warning]
+Colab Demo : https://huggingface.co/prithivMLmods/Imgscope-OCR-2B-0527/blob/main/Imgscope%20OCR%202B%200527%20Demo/Imgscope-OCR-2B-0527.ipynb
+
+---
+
+### Key Enhancements
+
+* **SoTA Understanding of Images of Various Resolution & Ratio**
+  Imgscope-OCR-2B-0527 achieves state-of-the-art performance on visual understanding benchmarks such as MathVista, DocVQA, RealWorldQA, and MTVQA.
+
+* **Enhanced Handwriting OCR**
+  Specifically optimized for recognizing and interpreting **realistic and messy handwriting** with high accuracy. Ideal for digitizing handwritten documents and notes.
+
+* **Document OCR Fine-Tuning**
+  Fine-tuned with curated and realistic **document OCR datasets**, enabling accurate extraction of text from various structured and unstructured layouts.
+
+* **Understanding Videos of 20+ Minutes**
+  Capable of processing long videos for **video-based question answering**, **transcription**, and **content generation**.
+
+* **Device Control Agent**
+  Supports decision-making and control capabilities for integration with **mobile devices**, **robots**, and **automation systems** using visual-textual commands.
+
+* **Multilingual OCR Support**
+  In addition to English and Chinese, the model supports **OCR in multiple languages** including European languages, Japanese, Korean, Arabic, and Vietnamese.
+
+---
+
+### Demo Video Inference
+
+https://github.com/user-attachments/assets/3ca9ef10-8a71-4cd1-8be1-951a9f6d5a00
+
+```
+
+The video starts with a group of people gathered around a table filled with snacks and drinks, indicating a casual social gathering. One person is seen holding a can of Pringles, suggesting that the snack is being enjoyed by the attendees.
+
+As the scene progresses, the focus shifts to a man who is seen pouring a drink from a can into a glass. This action implies that the drink is being served or shared among the group.
+
+The next scene shows a different setting where a man is walking down a hallway while holding a can of Pringles. This could indicate that he is on his way to join the group or has just arrived at the location.
+
+The following scene takes place in a diner where two people are seated at a booth. The man is seen holding a can of Pringles, which suggests that they might be enjoying a meal together.
+
+The video then transitions to a wedding ceremony where a man is feeding a woman a piece of cake using a can of Pringles. This unusual gesture adds a humorous element to the otherwise traditional event.
+
+Next, the scene changes to a bedroom where a man is seen feeding a woman a piece of cake using a can of Pringles. This scene further emphasizes the playful nature of the video.
+
+The video then shifts to an office setting where a man is seen working at a desk. The presence of a can of Pringles on the desk suggests that it might be part of his workspace or a snack during work hours.
+
+Finally, the video ends with a scene of a funeral where a woman is seen crying over a casket. The presence of a can of Pringles on the casket adds an unexpected and humorous touch to the solemn occasion.
+
+Throughout the video, the recurring theme of Pringles is evident, with various scenes featuring the snack as a central element. The video concludes with the text "GET STUCK IN," encouraging viewers to enjoy the snack and engage with the content.
+
+```
+
+### How to Use
+
+```python
+from transformers import Qwen2VLForConditionalGeneration, AutoTokenizer, AutoProcessor
+from qwen_vl_utils import process_vision_info
+
+# Load the model
+model = Qwen2VLForConditionalGeneration.from_pretrained(
+    "prithivMLmods/Imgscope-OCR-2B-0527",  # replace with updated model ID if available
+    torch_dtype="auto",
+    device_map="auto"
+)
+
+# Optional: Flash Attention for performance optimization
+# model = Qwen2VLForConditionalGeneration.from_pretrained(
+#     "prithivMLmods/Imgscope-OCR-2B-0527",
+#     torch_dtype=torch.bfloat16,
+#     attn_implementation="flash_attention_2",
+#     device_map="auto",
+# )
+
+# Load processor
+processor = AutoProcessor.from_pretrained("prithivMLmods/Imgscope-OCR-2B-0527")
+
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "image",
+                "image": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg",
+            },
+            {"type": "text", "text": "Recognize the handwriting in this image."},
+        ],
+    }
+]
+
+# Prepare input
+text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+image_inputs, video_inputs = process_vision_info(messages)
+inputs = processor(
+    text=[text],
+    images=image_inputs,
+    videos=video_inputs,
+    padding=True,
+    return_tensors="pt",
+)
+inputs = inputs.to("cuda")
+
+# Generate 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
+)
+print(output_text)
+```
+
+---
+
+### Demo Inference
+
+![Screenshot 2025-05-27 at 03-40-34 Gradio.png](https://cdn-uploads.huggingface.co/production/uploads/65bb837dbfb878f46c77de4c/9KiRkOGPB8cLl6VHwh2UD.png)
+![Screenshot 2025-05-27 at 03-40-56 (anonymous) - output_e0fbfa20-686e-4bce-b2e8-25991be5a5a0.pdf.png](https://cdn-uploads.huggingface.co/production/uploads/65bb837dbfb878f46c77de4c/VOHQIrT7hCs5afGMRROvD.png)
+
+---
+
+### Buffering Output (Streaming)
+
+```python
+buffer = ""
+for new_text in streamer:
+    buffer += new_text
+    buffer = buffer.replace("<|im_end|>", "")
+    yield buffer
+```
+
+---
+
+### Key Features
+
+1. **Realistic Messy Handwriting OCR**
+
+   * Fine-tuned for **complex and hard-to-read handwritten inputs** using real-world handwriting datasets.
+
+2. **Document OCR and Layout Understanding**
+
+   * Accurately extracts text from structured documents, including scanned pages, forms, and academic papers.
+
+3. **Image and Text Multi-modal Reasoning**
+
+   * Combines **vision-language capabilities** for tasks like captioning, answering image-based queries, and understanding image+text prompts.
+
+4. **Math Problem Solving and LaTeX Rendering**
+
+   * Converts mathematical expressions and problem-solving steps into **LaTeX** format.
+
+5. **Multi-turn Conversations**
+
+   * Supports **dialogue-based reasoning**, retaining context for follow-up questions.
+
+6. **Video + Image + Text-to-Text Generation**
+
+   * Accepts inputs from videos, images, or combined media with text, and generates relevant output accordingly.
+
+---
+
+## **Intended Use**
+
+**Imgscope-OCR-2B-0527** is intended for:
+
+* Handwritten and printed document digitization
+* OCR pipelines for educational institutions and businesses
+* Academic and scientific content parsing, especially math-heavy documents
+* Assistive tools for visually impaired users
+* Robotic and mobile automation agents interpreting screen or camera data
+* Multilingual OCR processing for document translation or archiving

Imgscope-OCR-2B-0527/app.py

@@ -0,0 +1,283 @@
+import gradio as gr
+import spaces
+from transformers import Qwen2VLForConditionalGeneration, AutoProcessor, TextIteratorStreamer
+from qwen_vl_utils import process_vision_info
+import torch
+from PIL import Image
+import os
+import uuid
+import io
+from threading import Thread
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.lib import colors
+from reportlab.platypus import SimpleDocTemplate, Image as RLImage, Paragraph, Spacer
+from reportlab.lib.units import inch
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+import docx
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+# Define model options
+MODEL_OPTIONS = {
+    "Imgscope-OCR-2B-0527": "prithivMLmods/Imgscope-OCR-2B-0527",
+}
+
+# Preload models and processors into CUDA
+models = {}
+processors = {}
+for name, model_id in MODEL_OPTIONS.items():
+    print(f"Loading {name}...")
+    models[name] = Qwen2VLForConditionalGeneration.from_pretrained(
+        model_id,
+        trust_remote_code=True,
+        torch_dtype=torch.float16
+    ).to("cuda").eval()
+    processors[name] = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+
+image_extensions = Image.registered_extensions()
+
+def identify_and_save_blob(blob_path):
+    """Identifies if the blob is an image and saves it."""
+    try:
+        with open(blob_path, 'rb') as file:
+            blob_content = file.read()
+            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):
+                raise ValueError("Unsupported media type. Please upload a valid image.")
+
+            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}")
+
+@spaces.GPU
+def qwen_inference(model_name, media_input, text_input=None):
+    """Handles inference for the selected model."""
+    model = models[model_name]
+    processor = processors[model_name]
+
+    if isinstance(media_input, str):
+        media_path = media_input
+        if media_path.endswith(tuple([i for i in image_extensions.keys()])):
+            media_type = "image"
+        else:
+            try:
+                media_path, media_type = identify_and_save_blob(media_input)
+            except Exception as e:
+                raise ValueError("Unsupported media type. Please upload a valid image.")
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": media_type,
+                    media_type: media_path
+                },
+                {"type": "text", "text": text_input},
+            ],
+        }
+    ]
+
+    text = processor.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+    image_inputs, _ = process_vision_info(messages)
+    inputs = processor(
+        text=[text],
+        images=image_inputs,
+        padding=True,
+        return_tensors="pt",
+    ).to("cuda")
+
+    streamer = TextIteratorStreamer(
+        processor.tokenizer, skip_prompt=True, skip_special_tokens=True
+    )
+    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
+        # Remove <|im_end|> or similar tokens from the output
+        buffer = buffer.replace("<|im_end|>", "")
+        yield buffer
+
+def format_plain_text(output_text):
+    """Formats the output text as plain text without LaTeX delimiters."""
+    # Remove LaTeX delimiters and convert to plain text
+    plain_text = output_text.replace("\\(", "").replace("\\)", "").replace("\\[", "").replace("\\]", "")
+    return plain_text
+
+def generate_document(media_path, output_text, file_format, font_size, line_spacing, alignment, image_size):
+    """Generates a document with the input image and plain text output."""
+    plain_text = format_plain_text(output_text)
+    if file_format == "pdf":
+        return generate_pdf(media_path, plain_text, font_size, line_spacing, alignment, image_size)
+    elif file_format == "docx":
+        return generate_docx(media_path, plain_text, font_size, line_spacing, alignment, image_size)
+
+def generate_pdf(media_path, plain_text, font_size, line_spacing, alignment, image_size):
+    """Generates a PDF document."""
+    filename = f"output_{uuid.uuid4()}.pdf"
+    doc = SimpleDocTemplate(
+        filename,
+        pagesize=A4,
+        rightMargin=inch,
+        leftMargin=inch,
+        topMargin=inch,
+        bottomMargin=inch
+    )
+    styles = getSampleStyleSheet()
+    styles["Normal"].fontSize = int(font_size)
+    styles["Normal"].leading = int(font_size) * line_spacing
+    styles["Normal"].alignment = {
+        "Left": 0,
+        "Center": 1,
+        "Right": 2,
+        "Justified": 4
+    }[alignment]
+
+    story = []
+
+    # Add image with size adjustment
+    image_sizes = {
+        "Small": (200, 200),
+        "Medium": (400, 400),
+        "Large": (600, 600)
+    }
+    img = RLImage(media_path, width=image_sizes[image_size][0], height=image_sizes[image_size][1])
+    story.append(img)
+    story.append(Spacer(1, 12))
+
+    # Add plain text output
+    text = Paragraph(plain_text, styles["Normal"])
+    story.append(text)
+
+    doc.build(story)
+    return filename
+
+def generate_docx(media_path, plain_text, font_size, line_spacing, alignment, image_size):
+    """Generates a DOCX document."""
+    filename = f"output_{uuid.uuid4()}.docx"
+    doc = docx.Document()
+
+    # Add image with size adjustment
+    image_sizes = {
+        "Small": docx.shared.Inches(2),
+        "Medium": docx.shared.Inches(4),
+        "Large": docx.shared.Inches(6)
+    }
+    doc.add_picture(media_path, width=image_sizes[image_size])
+    doc.add_paragraph()
+
+    # Add plain text output
+    paragraph = doc.add_paragraph()
+    paragraph.paragraph_format.line_spacing = line_spacing
+    paragraph.paragraph_format.alignment = {
+        "Left": WD_ALIGN_PARAGRAPH.LEFT,
+        "Center": WD_ALIGN_PARAGRAPH.CENTER,
+        "Right": WD_ALIGN_PARAGRAPH.RIGHT,
+        "Justified": WD_ALIGN_PARAGRAPH.JUSTIFY
+    }[alignment]
+    run = paragraph.add_run(plain_text)
+    run.font.size = docx.shared.Pt(int(font_size))
+
+    doc.save(filename)
+    return filename
+
+# CSS for output styling
+css = """
+  #output {
+    height: 500px;
+    overflow: auto;
+    border: 1px solid #ccc;
+  }
+.submit-btn {
+    background-color: #cf3434  !important;
+    color: white !important;
+}
+.submit-btn:hover {
+    background-color: #ff2323 !important;
+}
+.download-btn {
+    background-color: #35a6d6 !important;
+    color: white !important;
+}
+.download-btn:hover {
+    background-color: #22bcff !important;
+}
+"""
+
+# Gradio app setup
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("# Imgscope-OCR-2B-0527: Vision and Language Processing")
+
+    with gr.Tab(label="Image Input"):
+
+        with gr.Row():
+            with gr.Column():
+                model_choice = gr.Dropdown(
+                    label="Model Selection",
+                    choices=list(MODEL_OPTIONS.keys()),
+                    value="Imgscope-OCR-2B-0527"
+                )
+                input_media = gr.File(
+                    label="Upload Image", type="filepath"
+                )
+                text_input = gr.Textbox(label="Question", placeholder="Ask a question about the image...")
+                submit_btn = gr.Button(value="Submit", elem_classes="submit-btn")
+
+            with gr.Column():
+                output_text = gr.Textbox(label="Output Text", lines=10)
+                plain_text_output = gr.Textbox(label="Standardized Plain Text", lines=10)
+
+        submit_btn.click(
+            qwen_inference, [model_choice, input_media, text_input], [output_text]
+        ).then(
+            lambda output_text: format_plain_text(output_text), [output_text], [plain_text_output]
+        )
+
+        # Add examples directly usable by clicking
+        with gr.Row():
+            with gr.Column():
+                line_spacing = gr.Dropdown(
+                    choices=[0.5, 1.0, 1.15, 1.5, 2.0, 2.5, 3.0],
+                    value=1.5,
+                    label="Line Spacing"
+                )
+                font_size = gr.Dropdown(
+                    choices=["8", "10", "12", "14", "16", "18", "20", "22", "24"],
+                    value="18",
+                    label="Font Size"
+                )
+                alignment = gr.Dropdown(
+                    choices=["Left", "Center", "Right", "Justified"],
+                    value="Justified",
+                    label="Text Alignment"
+                )
+                image_size = gr.Dropdown(
+                    choices=["Small", "Medium", "Large"],
+                    value="Small",
+                    label="Image Size"
+                )
+                file_format = gr.Radio(["pdf", "docx"], label="File Format", value="pdf")
+                get_document_btn = gr.Button(value="Get Document", elem_classes="download-btn")
+
+        get_document_btn.click(
+            generate_document, [input_media, output_text, file_format, font_size, line_spacing, alignment, image_size], gr.File(label="Download Document")
+        )
+
+demo.launch(debug=True)

Imgscope-OCR-2B-0527/notebook/Imgscope-OCR-2B-0527.ipynb

@@ -0,0 +1,327 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av ipython reportlab\n",
+        "!pip install fpdf python-docx pillow huggingface_hub hf_xet"
+      ],
+      "metadata": {
+        "id": "oDmd1ZObGSel"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import gradio as gr\n",
+        "import spaces\n",
+        "from transformers import Qwen2VLForConditionalGeneration, AutoProcessor, TextIteratorStreamer\n",
+        "from qwen_vl_utils import process_vision_info\n",
+        "import torch\n",
+        "from PIL import Image\n",
+        "import os\n",
+        "import uuid\n",
+        "import io\n",
+        "from threading import Thread\n",
+        "from reportlab.lib.pagesizes import A4\n",
+        "from reportlab.lib.styles import getSampleStyleSheet\n",
+        "from reportlab.lib import colors\n",
+        "from reportlab.platypus import SimpleDocTemplate, Image as RLImage, Paragraph, Spacer\n",
+        "from reportlab.lib.units import inch\n",
+        "from reportlab.pdfbase import pdfmetrics\n",
+        "from reportlab.pdfbase.ttfonts import TTFont\n",
+        "import docx\n",
+        "from docx.enum.text import WD_ALIGN_PARAGRAPH\n",
+        "\n",
+        "# Define model options\n",
+        "MODEL_OPTIONS = {\n",
+        "    \"Imgscope-OCR-2B-0527\": \"prithivMLmods/Imgscope-OCR-2B-0527\",\n",
+        "}\n",
+        "\n",
+        "# Preload models and processors into CUDA\n",
+        "models = {}\n",
+        "processors = {}\n",
+        "for name, model_id in MODEL_OPTIONS.items():\n",
+        "    print(f\"Loading {name}...\")\n",
+        "    models[name] = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+        "        model_id,\n",
+        "        trust_remote_code=True,\n",
+        "        torch_dtype=torch.float16\n",
+        "    ).to(\"cuda\").eval()\n",
+        "    processors[name] = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)\n",
+        "\n",
+        "image_extensions = Image.registered_extensions()\n",
+        "\n",
+        "def identify_and_save_blob(blob_path):\n",
+        "    \"\"\"Identifies if the blob is an image and saves it.\"\"\"\n",
+        "    try:\n",
+        "        with open(blob_path, 'rb') as file:\n",
+        "            blob_content = file.read()\n",
+        "            try:\n",
+        "                Image.open(io.BytesIO(blob_content)).verify()  # Check if it's a valid image\n",
+        "                extension = \".png\"  # Default to PNG for saving\n",
+        "                media_type = \"image\"\n",
+        "            except (IOError, SyntaxError):\n",
+        "                raise ValueError(\"Unsupported media type. Please upload a valid image.\")\n",
+        "\n",
+        "            filename = f\"temp_{uuid.uuid4()}_media{extension}\"\n",
+        "            with open(filename, \"wb\") as f:\n",
+        "                f.write(blob_content)\n",
+        "\n",
+        "            return filename, media_type\n",
+        "\n",
+        "    except FileNotFoundError:\n",
+        "        raise ValueError(f\"The file {blob_path} was not found.\")\n",
+        "    except Exception as e:\n",
+        "        raise ValueError(f\"An error occurred while processing the file: {e}\")\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def qwen_inference(model_name, media_input, text_input=None):\n",
+        "    \"\"\"Handles inference for the selected model.\"\"\"\n",
+        "    model = models[model_name]\n",
+        "    processor = processors[model_name]\n",
+        "\n",
+        "    if isinstance(media_input, str):\n",
+        "        media_path = media_input\n",
+        "        if media_path.endswith(tuple([i for i in image_extensions.keys()])):\n",
+        "            media_type = \"image\"\n",
+        "        else:\n",
+        "            try:\n",
+        "                media_path, media_type = identify_and_save_blob(media_input)\n",
+        "            except Exception as e:\n",
+        "                raise ValueError(\"Unsupported media type. Please upload a valid image.\")\n",
+        "\n",
+        "    messages = [\n",
+        "        {\n",
+        "            \"role\": \"user\",\n",
+        "            \"content\": [\n",
+        "                {\n",
+        "                    \"type\": media_type,\n",
+        "                    media_type: media_path\n",
+        "                },\n",
+        "                {\"type\": \"text\", \"text\": text_input},\n",
+        "            ],\n",
+        "        }\n",
+        "    ]\n",
+        "\n",
+        "    text = processor.apply_chat_template(\n",
+        "        messages, tokenize=False, add_generation_prompt=True\n",
+        "    )\n",
+        "    image_inputs, _ = process_vision_info(messages)\n",
+        "    inputs = processor(\n",
+        "        text=[text],\n",
+        "        images=image_inputs,\n",
+        "        padding=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "    ).to(\"cuda\")\n",
+        "\n",
+        "    streamer = TextIteratorStreamer(\n",
+        "        processor.tokenizer, skip_prompt=True, skip_special_tokens=True\n",
+        "    )\n",
+        "    generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=1024)\n",
+        "\n",
+        "    thread = Thread(target=model.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        # Remove <|im_end|> or similar tokens from the output\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        yield buffer\n",
+        "\n",
+        "def format_plain_text(output_text):\n",
+        "    \"\"\"Formats the output text as plain text without LaTeX delimiters.\"\"\"\n",
+        "    # Remove LaTeX delimiters and convert to plain text\n",
+        "    plain_text = output_text.replace(\"\\\\(\", \"\").replace(\"\\\\)\", \"\").replace(\"\\\\[\", \"\").replace(\"\\\\]\", \"\")\n",
+        "    return plain_text\n",
+        "\n",
+        "def generate_document(media_path, output_text, file_format, font_size, line_spacing, alignment, image_size):\n",
+        "    \"\"\"Generates a document with the input image and plain text output.\"\"\"\n",
+        "    plain_text = format_plain_text(output_text)\n",
+        "    if file_format == \"pdf\":\n",
+        "        return generate_pdf(media_path, plain_text, font_size, line_spacing, alignment, image_size)\n",
+        "    elif file_format == \"docx\":\n",
+        "        return generate_docx(media_path, plain_text, font_size, line_spacing, alignment, image_size)\n",
+        "\n",
+        "def generate_pdf(media_path, plain_text, font_size, line_spacing, alignment, image_size):\n",
+        "    \"\"\"Generates a PDF document.\"\"\"\n",
+        "    filename = f\"output_{uuid.uuid4()}.pdf\"\n",
+        "    doc = SimpleDocTemplate(\n",
+        "        filename,\n",
+        "        pagesize=A4,\n",
+        "        rightMargin=inch,\n",
+        "        leftMargin=inch,\n",
+        "        topMargin=inch,\n",
+        "        bottomMargin=inch\n",
+        "    )\n",
+        "    styles = getSampleStyleSheet()\n",
+        "    styles[\"Normal\"].fontSize = int(font_size)\n",
+        "    styles[\"Normal\"].leading = int(font_size) * line_spacing\n",
+        "    styles[\"Normal\"].alignment = {\n",
+        "        \"Left\": 0,\n",
+        "        \"Center\": 1,\n",
+        "        \"Right\": 2,\n",
+        "        \"Justified\": 4\n",
+        "    }[alignment]\n",
+        "\n",
+        "    story = []\n",
+        "\n",
+        "    # Add image with size adjustment\n",
+        "    image_sizes = {\n",
+        "        \"Small\": (200, 200),\n",
+        "        \"Medium\": (400, 400),\n",
+        "        \"Large\": (600, 600)\n",
+        "    }\n",
+        "    img = RLImage(media_path, width=image_sizes[image_size][0], height=image_sizes[image_size][1])\n",
+        "    story.append(img)\n",
+        "    story.append(Spacer(1, 12))\n",
+        "\n",
+        "    # Add plain text output\n",
+        "    text = Paragraph(plain_text, styles[\"Normal\"])\n",
+        "    story.append(text)\n",
+        "\n",
+        "    doc.build(story)\n",
+        "    return filename\n",
+        "\n",
+        "def generate_docx(media_path, plain_text, font_size, line_spacing, alignment, image_size):\n",
+        "    \"\"\"Generates a DOCX document.\"\"\"\n",
+        "    filename = f\"output_{uuid.uuid4()}.docx\"\n",
+        "    doc = docx.Document()\n",
+        "\n",
+        "    # Add image with size adjustment\n",
+        "    image_sizes = {\n",
+        "        \"Small\": docx.shared.Inches(2),\n",
+        "        \"Medium\": docx.shared.Inches(4),\n",
+        "        \"Large\": docx.shared.Inches(6)\n",
+        "    }\n",
+        "    doc.add_picture(media_path, width=image_sizes[image_size])\n",
+        "    doc.add_paragraph()\n",
+        "\n",
+        "    # Add plain text output\n",
+        "    paragraph = doc.add_paragraph()\n",
+        "    paragraph.paragraph_format.line_spacing = line_spacing\n",
+        "    paragraph.paragraph_format.alignment = {\n",
+        "        \"Left\": WD_ALIGN_PARAGRAPH.LEFT,\n",
+        "        \"Center\": WD_ALIGN_PARAGRAPH.CENTER,\n",
+        "        \"Right\": WD_ALIGN_PARAGRAPH.RIGHT,\n",
+        "        \"Justified\": WD_ALIGN_PARAGRAPH.JUSTIFY\n",
+        "    }[alignment]\n",
+        "    run = paragraph.add_run(plain_text)\n",
+        "    run.font.size = docx.shared.Pt(int(font_size))\n",
+        "\n",
+        "    doc.save(filename)\n",
+        "    return filename\n",
+        "\n",
+        "# CSS for output styling\n",
+        "css = \"\"\"\n",
+        "  #output {\n",
+        "    height: 500px;\n",
+        "    overflow: auto;\n",
+        "    border: 1px solid #ccc;\n",
+        "  }\n",
+        ".submit-btn {\n",
+        "    background-color: #cf3434  !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #ff2323 !important;\n",
+        "}\n",
+        ".download-btn {\n",
+        "    background-color: #35a6d6 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".download-btn:hover {\n",
+        "    background-color: #22bcff !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Gradio app setup\n",
+        "with gr.Blocks(css=css) as demo:\n",
+        "    gr.Markdown(\"# Imgscope-OCR-2B-0527: Vision and Language Processing\")\n",
+        "\n",
+        "    with gr.Tab(label=\"Image Input\"):\n",
+        "\n",
+        "        with gr.Row():\n",
+        "            with gr.Column():\n",
+        "                model_choice = gr.Dropdown(\n",
+        "                    label=\"Model Selection\",\n",
+        "                    choices=list(MODEL_OPTIONS.keys()),\n",
+        "                    value=\"Imgscope-OCR-2B-0527\"\n",
+        "                )\n",
+        "                input_media = gr.File(\n",
+        "                    label=\"Upload Image\", type=\"filepath\"\n",
+        "                )\n",
+        "                text_input = gr.Textbox(label=\"Question\", placeholder=\"Ask a question about the image...\")\n",
+        "                submit_btn = gr.Button(value=\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Column():\n",
+        "                output_text = gr.Textbox(label=\"Output Text\", lines=10)\n",
+        "                plain_text_output = gr.Textbox(label=\"Standardized Plain Text\", lines=10)\n",
+        "\n",
+        "        submit_btn.click(\n",
+        "            qwen_inference, [model_choice, input_media, text_input], [output_text]\n",
+        "        ).then(\n",
+        "            lambda output_text: format_plain_text(output_text), [output_text], [plain_text_output]\n",
+        "        )\n",
+        "\n",
+        "        # Add examples directly usable by clicking\n",
+        "        with gr.Row():\n",
+        "            with gr.Column():\n",
+        "                line_spacing = gr.Dropdown(\n",
+        "                    choices=[0.5, 1.0, 1.15, 1.5, 2.0, 2.5, 3.0],\n",
+        "                    value=1.5,\n",
+        "                    label=\"Line Spacing\"\n",
+        "                )\n",
+        "                font_size = gr.Dropdown(\n",
+        "                    choices=[\"8\", \"10\", \"12\", \"14\", \"16\", \"18\", \"20\", \"22\", \"24\"],\n",
+        "                    value=\"18\",\n",
+        "                    label=\"Font Size\"\n",
+        "                )\n",
+        "                alignment = gr.Dropdown(\n",
+        "                    choices=[\"Left\", \"Center\", \"Right\", \"Justified\"],\n",
+        "                    value=\"Justified\",\n",
+        "                    label=\"Text Alignment\"\n",
+        "                )\n",
+        "                image_size = gr.Dropdown(\n",
+        "                    choices=[\"Small\", \"Medium\", \"Large\"],\n",
+        "                    value=\"Small\",\n",
+        "                    label=\"Image Size\"\n",
+        "                )\n",
+        "                file_format = gr.Radio([\"pdf\", \"docx\"], label=\"File Format\", value=\"pdf\")\n",
+        "                get_document_btn = gr.Button(value=\"Get Document\", elem_classes=\"download-btn\")\n",
+        "\n",
+        "        get_document_btn.click(\n",
+        "            generate_document, [input_media, output_text, file_format, font_size, line_spacing, alignment, image_size], gr.File(label=\"Download Document\")\n",
+        "        )\n",
+        "\n",
+        "demo.launch(debug=True)"
+      ],
+      "metadata": {
+        "id": "ovBSsRFhGbs2"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Imgscope-OCR-2B-0527/requirements.txt

@@ -0,0 +1,17 @@
+gradio
+spaces
+transformers
+accelerate
+numpy
+requests
+torch
+torchvision
+qwen-vl-utils
+av
+ipython
+reportlab
+fpdf
+python-docx
+pillow
+huggingface_hub
+hf_xet

Inkscope-Captions-2B-0526/Inkscope-Captions-2B-0526-Video-Understanding/Inkscope-Captions-2B-0526-Video-Understanding.ipynb

@@ -0,0 +1,164 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "XKQwuI75LWLA"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio transformers pillow opencv-python\n",
+        "!pip install accelerate torchvision torch huggingface_hub\n",
+        "!pip install hf_xet qwen-vl-utils gradio_client\n",
+        "!pip install transformers-stream-generator spaces"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import uuid\n",
+        "import time\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "import cv2\n",
+        "from PIL import Image\n",
+        "from transformers import Qwen2VLForConditionalGeneration, AutoProcessor\n",
+        "\n",
+        "# Ensure CUDA if available\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "# Load Callisto OCR3 multimodal model and processor\n",
+        "MODEL_ID = \"prithivMLmods/Inkscope-Captions-2B-0526\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(device).eval()\n",
+        "\n",
+        "# Constants\n",
+        "MAX_INPUT_TOKEN_LENGTH = 4096\n",
+        "\n",
+        "\n",
+        "def downsample_video(video_path: str, num_frames: int = 10):\n",
+        "    \"\"\"\n",
+        "    Extracts 'num_frames' evenly spaced frames from the video.\n",
+        "    Returns a list of (PIL.Image, timestamp_seconds).\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS) or 1\n",
+        "    indices = np.linspace(0, total - 1, num_frames, dtype=int)\n",
+        "    frames = []\n",
+        "    for idx in indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, idx)\n",
+        "        ret, frame = vidcap.read()\n",
+        "        if not ret:\n",
+        "            continue\n",
+        "        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
+        "        pil = Image.fromarray(frame)\n",
+        "        timestamp = round(idx / fps, 2)\n",
+        "        frames.append((pil, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "\n",
+        "def generate(video_file: str):\n",
+        "    \"\"\"\n",
+        "    Process the uploaded video through OCR and return concatenated output.\n",
+        "    \"\"\"\n",
+        "    # Step 1: extract frames\n",
+        "    frames = downsample_video(video_file)\n",
+        "\n",
+        "    # Step 2: build chat-like messages\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant, for video understanding.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": \"Please explain the content of the following video frames:\"}]\n",
+        "        }\n",
+        "    ]\n",
+        "    for img, ts in frames:\n",
+        "        # save temporary frame image\n",
+        "        path = f\"frame_{uuid.uuid4().hex}.png\"\n",
+        "        img.save(path)\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame at {ts}s:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"url\": path})\n",
+        "\n",
+        "    # Step 3: tokenize with truncation\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=True,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(device)\n",
+        "\n",
+        "    # Step 4: use streamer to collect output\n",
+        "    from transformers import TextIteratorStreamer\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    gen_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": 1024,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": 0.7,\n",
+        "    }\n",
+        "    thread = Thread(target=model.generate, kwargs=gen_kwargs)\n",
+        "    thread.start()\n",
+        "\n",
+        "    # collect all tokens\n",
+        "    buffer = \"\"\n",
+        "    for chunk in streamer:\n",
+        "        buffer += chunk.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "\n",
+        "    # return full concatenated response\n",
+        "    return buffer\n",
+        "\n",
+        "\n",
+        "def launch_app():\n",
+        "    demo = gr.Interface(\n",
+        "        fn=generate,\n",
+        "        inputs=gr.Video(label=\"Upload Video\"),\n",
+        "        outputs=gr.Textbox(label=\"Video Caption\"),\n",
+        "        title=\"Video Understanding with Inkscope-Captions-2B-0526\",\n",
+        "        description=\"Upload a video and get an OCR-based description of its frames.\",\n",
+        "        allow_flagging=\"never\"\n",
+        "    )\n",
+        "    demo.queue().launch(debug=True)\n",
+        "\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    launch_app()"
+      ],
+      "metadata": {
+        "id": "GZXqC00zLbS1"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Inkscope-Captions-2B-0526/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Inkscope-Captions-2B-0526/README.md

@@ -0,0 +1,137 @@
+![9.png](https://cdn-uploads.huggingface.co/production/uploads/65bb837dbfb878f46c77de4c/-1klnWCRiSPeNT25L4fCI.png)
+
+# **Inkscope-Captions-2B-0526**
+
+> The **Inkscope-Captions-2B-0526** model is a fine-tuned version of *Qwen2-VL-2B-Instruct*, optimized for **image captioning**, **vision-language understanding**, and **English-language caption generation**. This model was fine-tuned on the `conceptual-captions-cc12m-llavanext` dataset (first 30k entries) to generate **detailed, high-quality captions** for images, including complex or abstract scenes.
+
+> [!note]
+Colab Demo : https://huggingface.co/prithivMLmods/Inkscope-Captions-2B-0526/blob/main/Inkscope%20Captions%202B%200526%20Demo/Inkscope-Captions-2B-0526.ipynb
+
+> [!note]
+Video Understanding Demo : https://huggingface.co/prithivMLmods/Inkscope-Captions-2B-0526/blob/main/Inkscope-Captions-2B-0526-Video-Understanding/Inkscope-Captions-2B-0526-Video-Understanding.ipynb
+---
+
+#### Key Enhancements:
+
+* **High-Quality Visual Captioning**: Generates **rich and descriptive captions** from diverse visual inputs, including abstract, real-world, and complex images.
+
+* **Fine-Tuned on CC12M Subset**: Trained using the **first 30k entries** of the *Conceptual Captions 12M (CC12M)* dataset with the **LLaVA-Next formatting**, ensuring alignment with instruction-tuned captioning.
+
+* **Multimodal Understanding**: Supports detailed understanding of **text+image combinations**, ideal for **caption generation**, **scene understanding**, and **instruction-based vision-language tasks**.
+
+* **Multilingual Recognition**: While focused on English captioning, the model can recognize text in various languages present in the image.
+
+* **Strong Foundation Model**: Built on *Qwen2-VL-2B-Instruct*, offering powerful visual-linguistic reasoning, OCR capability, and flexible prompt handling.
+
+---
+
+### How to Use
+
+```python
+from transformers import Qwen2VLForConditionalGeneration, AutoTokenizer, AutoProcessor
+from qwen_vl_utils import process_vision_info
+
+# Load the fine-tuned model
+model = Qwen2VLForConditionalGeneration.from_pretrained(
+    "prithivMLmods/Inkscope-Captions-2B-0526", torch_dtype="auto", device_map="auto"
+)
+
+# Load processor
+processor = AutoProcessor.from_pretrained("prithivMLmods/Inkscope-Captions-2B-0526")
+
+# Sample input message with an image
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "image",
+                "image": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg",
+            },
+            {"type": "text", "text": "Generate a detailed caption for this image."},
+        ],
+    }
+]
+
+# Preprocess input
+text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+image_inputs, video_inputs = process_vision_info(messages)
+inputs = processor(
+    text=[text],
+    images=image_inputs,
+    videos=video_inputs,
+    padding=True,
+    return_tensors="pt",
+).to("cuda")
+
+# Generate 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
+)
+print(output_text)
+```
+
+---
+
+### Buffering Output (Optional for streaming inference)
+
+```python
+buffer = ""
+for new_text in streamer:
+    buffer += new_text
+    buffer = buffer.replace("<|im_end|>", "")
+    yield buffer
+```
+
+---
+
+### **Demo Inference**
+
+![Screenshot 2025-05-27 at 03-59-36 Gradio.png](https://cdn-uploads.huggingface.co/production/uploads/65bb837dbfb878f46c77de4c/ykPB8Yxk0Z_1WDmSoCjKD.png)
+![Screenshot 2025-05-27 at 03-59-53 (anonymous) - output_8dc4ad31-403a-4f59-a483-be2aec11b756.pdf.png](https://cdn-uploads.huggingface.co/production/uploads/65bb837dbfb878f46c77de4c/tBPdM1iyRf8Fi12urNUbt.png)
+  
+---
+
+### **Video Inference**
+
+![Screenshot 2025-05-27 at 20-35-30 Video Understanding with Inkscope-Captions-2B-0526.png](https://cdn-uploads.huggingface.co/production/uploads/65bb837dbfb878f46c77de4c/LrHNNYV1elysHjAmzOXw3.png)
+
+---
+
+### **Key Features**
+
+1. **Caption Generation from Images:**
+
+   * Transforms visual scenes into **detailed, human-like descriptions**.
+
+2. **Conceptual Reasoning:**
+
+   * Captures abstract or high-level elements from images, including **emotion, action, or scene context**.
+
+3. **Multi-modal Prompting:**
+
+   * Accepts both **image and text** input for **instruction-tuned** caption generation.
+
+4. **Flexible Output Format:**
+
+   * Generates output in **natural language**, ideal for storytelling, accessibility tools, and educational applications.
+
+5. **Instruction-Tuned**:
+
+   * Fine-tuned with **LLaVA-Next style prompts**, making it suitable for interactive use and vision-language agents.
+
+---
+
+## **Intended Use**
+
+**Inkscope-Captions-2B-0526** is designed for the following applications:
+
+* **Image Captioning** for web-scale datasets, social media analysis, and generative applications.
+* **Accessibility Tools**: Helping visually impaired users understand image content through text.
+* **Content Tagging and Metadata Generation** for media, digital assets, and educational material.
+* **AI Companions and Tutors** that need to explain or describe visuals in a conversational setting.
+* **Instruction-following Vision-Language Tasks**, such as zero-shot VQA, scene description, and multimodal storytelling.

Inkscope-Captions-2B-0526/app.py

@@ -0,0 +1,283 @@
+import gradio as gr
+import spaces
+from transformers import Qwen2VLForConditionalGeneration, AutoProcessor, TextIteratorStreamer
+from qwen_vl_utils import process_vision_info
+import torch
+from PIL import Image
+import os
+import uuid
+import io
+from threading import Thread
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.lib import colors
+from reportlab.platypus import SimpleDocTemplate, Image as RLImage, Paragraph, Spacer
+from reportlab.lib.units import inch
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+import docx
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+# Define model options
+MODEL_OPTIONS = {
+    "Inkscope-Captions-2B-0526": "prithivMLmods/Inkscope-Captions-2B-0526",
+}
+
+# Preload models and processors into CUDA
+models = {}
+processors = {}
+for name, model_id in MODEL_OPTIONS.items():
+    print(f"Loading {name}...")
+    models[name] = Qwen2VLForConditionalGeneration.from_pretrained(
+        model_id,
+        trust_remote_code=True,
+        torch_dtype=torch.float16
+    ).to("cuda").eval()
+    processors[name] = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+
+image_extensions = Image.registered_extensions()
+
+def identify_and_save_blob(blob_path):
+    """Identifies if the blob is an image and saves it."""
+    try:
+        with open(blob_path, 'rb') as file:
+            blob_content = file.read()
+            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):
+                raise ValueError("Unsupported media type. Please upload a valid image.")
+
+            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}")
+
+@spaces.GPU
+def qwen_inference(model_name, media_input, text_input=None):
+    """Handles inference for the selected model."""
+    model = models[model_name]
+    processor = processors[model_name]
+
+    if isinstance(media_input, str):
+        media_path = media_input
+        if media_path.endswith(tuple([i for i in image_extensions.keys()])):
+            media_type = "image"
+        else:
+            try:
+                media_path, media_type = identify_and_save_blob(media_input)
+            except Exception as e:
+                raise ValueError("Unsupported media type. Please upload a valid image.")
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": media_type,
+                    media_type: media_path
+                },
+                {"type": "text", "text": text_input},
+            ],
+        }
+    ]
+
+    text = processor.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+    image_inputs, _ = process_vision_info(messages)
+    inputs = processor(
+        text=[text],
+        images=image_inputs,
+        padding=True,
+        return_tensors="pt",
+    ).to("cuda")
+
+    streamer = TextIteratorStreamer(
+        processor.tokenizer, skip_prompt=True, skip_special_tokens=True
+    )
+    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
+        # Remove <|im_end|> or similar tokens from the output
+        buffer = buffer.replace("<|im_end|>", "")
+        yield buffer
+
+def format_plain_text(output_text):
+    """Formats the output text as plain text without LaTeX delimiters."""
+    # Remove LaTeX delimiters and convert to plain text
+    plain_text = output_text.replace("\\(", "").replace("\\)", "").replace("\\[", "").replace("\\]", "")
+    return plain_text
+
+def generate_document(media_path, output_text, file_format, font_size, line_spacing, alignment, image_size):
+    """Generates a document with the input image and plain text output."""
+    plain_text = format_plain_text(output_text)
+    if file_format == "pdf":
+        return generate_pdf(media_path, plain_text, font_size, line_spacing, alignment, image_size)
+    elif file_format == "docx":
+        return generate_docx(media_path, plain_text, font_size, line_spacing, alignment, image_size)
+
+def generate_pdf(media_path, plain_text, font_size, line_spacing, alignment, image_size):
+    """Generates a PDF document."""
+    filename = f"output_{uuid.uuid4()}.pdf"
+    doc = SimpleDocTemplate(
+        filename,
+        pagesize=A4,
+        rightMargin=inch,
+        leftMargin=inch,
+        topMargin=inch,
+        bottomMargin=inch
+    )
+    styles = getSampleStyleSheet()
+    styles["Normal"].fontSize = int(font_size)
+    styles["Normal"].leading = int(font_size) * line_spacing
+    styles["Normal"].alignment = {
+        "Left": 0,
+        "Center": 1,
+        "Right": 2,
+        "Justified": 4
+    }[alignment]
+
+    story = []
+
+    # Add image with size adjustment
+    image_sizes = {
+        "Small": (200, 200),
+        "Medium": (400, 400),
+        "Large": (600, 600)
+    }
+    img = RLImage(media_path, width=image_sizes[image_size][0], height=image_sizes[image_size][1])
+    story.append(img)
+    story.append(Spacer(1, 12))
+
+    # Add plain text output
+    text = Paragraph(plain_text, styles["Normal"])
+    story.append(text)
+
+    doc.build(story)
+    return filename
+
+def generate_docx(media_path, plain_text, font_size, line_spacing, alignment, image_size):
+    """Generates a DOCX document."""
+    filename = f"output_{uuid.uuid4()}.docx"
+    doc = docx.Document()
+
+    # Add image with size adjustment
+    image_sizes = {
+        "Small": docx.shared.Inches(2),
+        "Medium": docx.shared.Inches(4),
+        "Large": docx.shared.Inches(6)
+    }
+    doc.add_picture(media_path, width=image_sizes[image_size])
+    doc.add_paragraph()
+
+    # Add plain text output
+    paragraph = doc.add_paragraph()
+    paragraph.paragraph_format.line_spacing = line_spacing
+    paragraph.paragraph_format.alignment = {
+        "Left": WD_ALIGN_PARAGRAPH.LEFT,
+        "Center": WD_ALIGN_PARAGRAPH.CENTER,
+        "Right": WD_ALIGN_PARAGRAPH.RIGHT,
+        "Justified": WD_ALIGN_PARAGRAPH.JUSTIFY
+    }[alignment]
+    run = paragraph.add_run(plain_text)
+    run.font.size = docx.shared.Pt(int(font_size))
+
+    doc.save(filename)
+    return filename
+
+# CSS for output styling
+css = """
+  #output {
+    height: 500px;
+    overflow: auto;
+    border: 1px solid #ccc;
+  }
+.submit-btn {
+    background-color: #cf3434  !important;
+    color: white !important;
+}
+.submit-btn:hover {
+    background-color: #ff2323 !important;
+}
+.download-btn {
+    background-color: #35a6d6 !important;
+    color: white !important;
+}
+.download-btn:hover {
+    background-color: #22bcff !important;
+}
+"""
+
+# Gradio app setup
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("# Inkscope-Captions-2B-0526 : Vision and Language Processing")
+
+    with gr.Tab(label="Image Input"):
+
+        with gr.Row():
+            with gr.Column():
+                model_choice = gr.Dropdown(
+                    label="Model Selection",
+                    choices=list(MODEL_OPTIONS.keys()),
+                    value="Inkscope-Captions-2B-0526"
+                )
+                input_media = gr.File(
+                    label="Upload Image", type="filepath"
+                )
+                text_input = gr.Textbox(label="Question", placeholder="Ask a question about the image...")
+                submit_btn = gr.Button(value="Submit", elem_classes="submit-btn")
+
+            with gr.Column():
+                output_text = gr.Textbox(label="Output Text", lines=10)
+                plain_text_output = gr.Textbox(label="Standardized Plain Text", lines=10)
+
+        submit_btn.click(
+            qwen_inference, [model_choice, input_media, text_input], [output_text]
+        ).then(
+            lambda output_text: format_plain_text(output_text), [output_text], [plain_text_output]
+        )
+
+        # Add examples directly usable by clicking
+        with gr.Row():
+            with gr.Column():
+                line_spacing = gr.Dropdown(
+                    choices=[0.5, 1.0, 1.15, 1.5, 2.0, 2.5, 3.0],
+                    value=1.5,
+                    label="Line Spacing"
+                )
+                font_size = gr.Dropdown(
+                    choices=["8", "10", "12", "14", "16", "18", "20", "22", "24"],
+                    value="18",
+                    label="Font Size"
+                )
+                alignment = gr.Dropdown(
+                    choices=["Left", "Center", "Right", "Justified"],
+                    value="Justified",
+                    label="Text Alignment"
+                )
+                image_size = gr.Dropdown(
+                    choices=["Small", "Medium", "Large"],
+                    value="Small",
+                    label="Image Size"
+                )
+                file_format = gr.Radio(["pdf", "docx"], label="File Format", value="pdf")
+                get_document_btn = gr.Button(value="Get Document", elem_classes="download-btn")
+
+        get_document_btn.click(
+            generate_document, [input_media, output_text, file_format, font_size, line_spacing, alignment, image_size], gr.File(label="Download Document")
+        )
+
+demo.launch(debug=True)

Inkscope-Captions-2B-0526/notebook/Inkscope-Captions-2B-0526.ipynb

@@ -0,0 +1,327 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av ipython reportlab\n",
+        "!pip install fpdf python-docx pillow huggingface_hub hf_xet"
+      ],
+      "metadata": {
+        "id": "oDmd1ZObGSel"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import gradio as gr\n",
+        "import spaces\n",
+        "from transformers import Qwen2VLForConditionalGeneration, AutoProcessor, TextIteratorStreamer\n",
+        "from qwen_vl_utils import process_vision_info\n",
+        "import torch\n",
+        "from PIL import Image\n",
+        "import os\n",
+        "import uuid\n",
+        "import io\n",
+        "from threading import Thread\n",
+        "from reportlab.lib.pagesizes import A4\n",
+        "from reportlab.lib.styles import getSampleStyleSheet\n",
+        "from reportlab.lib import colors\n",
+        "from reportlab.platypus import SimpleDocTemplate, Image as RLImage, Paragraph, Spacer\n",
+        "from reportlab.lib.units import inch\n",
+        "from reportlab.pdfbase import pdfmetrics\n",
+        "from reportlab.pdfbase.ttfonts import TTFont\n",
+        "import docx\n",
+        "from docx.enum.text import WD_ALIGN_PARAGRAPH\n",
+        "\n",
+        "# Define model options\n",
+        "MODEL_OPTIONS = {\n",
+        "    \"Inkscope-Captions-2B-0526\": \"prithivMLmods/Inkscope-Captions-2B-0526\",\n",
+        "}\n",
+        "\n",
+        "# Preload models and processors into CUDA\n",
+        "models = {}\n",
+        "processors = {}\n",
+        "for name, model_id in MODEL_OPTIONS.items():\n",
+        "    print(f\"Loading {name}...\")\n",
+        "    models[name] = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+        "        model_id,\n",
+        "        trust_remote_code=True,\n",
+        "        torch_dtype=torch.float16\n",
+        "    ).to(\"cuda\").eval()\n",
+        "    processors[name] = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)\n",
+        "\n",
+        "image_extensions = Image.registered_extensions()\n",
+        "\n",
+        "def identify_and_save_blob(blob_path):\n",
+        "    \"\"\"Identifies if the blob is an image and saves it.\"\"\"\n",
+        "    try:\n",
+        "        with open(blob_path, 'rb') as file:\n",
+        "            blob_content = file.read()\n",
+        "            try:\n",
+        "                Image.open(io.BytesIO(blob_content)).verify()  # Check if it's a valid image\n",
+        "                extension = \".png\"  # Default to PNG for saving\n",
+        "                media_type = \"image\"\n",
+        "            except (IOError, SyntaxError):\n",
+        "                raise ValueError(\"Unsupported media type. Please upload a valid image.\")\n",
+        "\n",
+        "            filename = f\"temp_{uuid.uuid4()}_media{extension}\"\n",
+        "            with open(filename, \"wb\") as f:\n",
+        "                f.write(blob_content)\n",
+        "\n",
+        "            return filename, media_type\n",
+        "\n",
+        "    except FileNotFoundError:\n",
+        "        raise ValueError(f\"The file {blob_path} was not found.\")\n",
+        "    except Exception as e:\n",
+        "        raise ValueError(f\"An error occurred while processing the file: {e}\")\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def qwen_inference(model_name, media_input, text_input=None):\n",
+        "    \"\"\"Handles inference for the selected model.\"\"\"\n",
+        "    model = models[model_name]\n",
+        "    processor = processors[model_name]\n",
+        "\n",
+        "    if isinstance(media_input, str):\n",
+        "        media_path = media_input\n",
+        "        if media_path.endswith(tuple([i for i in image_extensions.keys()])):\n",
+        "            media_type = \"image\"\n",
+        "        else:\n",
+        "            try:\n",
+        "                media_path, media_type = identify_and_save_blob(media_input)\n",
+        "            except Exception as e:\n",
+        "                raise ValueError(\"Unsupported media type. Please upload a valid image.\")\n",
+        "\n",
+        "    messages = [\n",
+        "        {\n",
+        "            \"role\": \"user\",\n",
+        "            \"content\": [\n",
+        "                {\n",
+        "                    \"type\": media_type,\n",
+        "                    media_type: media_path\n",
+        "                },\n",
+        "                {\"type\": \"text\", \"text\": text_input},\n",
+        "            ],\n",
+        "        }\n",
+        "    ]\n",
+        "\n",
+        "    text = processor.apply_chat_template(\n",
+        "        messages, tokenize=False, add_generation_prompt=True\n",
+        "    )\n",
+        "    image_inputs, _ = process_vision_info(messages)\n",
+        "    inputs = processor(\n",
+        "        text=[text],\n",
+        "        images=image_inputs,\n",
+        "        padding=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "    ).to(\"cuda\")\n",
+        "\n",
+        "    streamer = TextIteratorStreamer(\n",
+        "        processor.tokenizer, skip_prompt=True, skip_special_tokens=True\n",
+        "    )\n",
+        "    generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=1024)\n",
+        "\n",
+        "    thread = Thread(target=model.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        # Remove <|im_end|> or similar tokens from the output\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        yield buffer\n",
+        "\n",
+        "def format_plain_text(output_text):\n",
+        "    \"\"\"Formats the output text as plain text without LaTeX delimiters.\"\"\"\n",
+        "    # Remove LaTeX delimiters and convert to plain text\n",
+        "    plain_text = output_text.replace(\"\\\\(\", \"\").replace(\"\\\\)\", \"\").replace(\"\\\\[\", \"\").replace(\"\\\\]\", \"\")\n",
+        "    return plain_text\n",
+        "\n",
+        "def generate_document(media_path, output_text, file_format, font_size, line_spacing, alignment, image_size):\n",
+        "    \"\"\"Generates a document with the input image and plain text output.\"\"\"\n",
+        "    plain_text = format_plain_text(output_text)\n",
+        "    if file_format == \"pdf\":\n",
+        "        return generate_pdf(media_path, plain_text, font_size, line_spacing, alignment, image_size)\n",
+        "    elif file_format == \"docx\":\n",
+        "        return generate_docx(media_path, plain_text, font_size, line_spacing, alignment, image_size)\n",
+        "\n",
+        "def generate_pdf(media_path, plain_text, font_size, line_spacing, alignment, image_size):\n",
+        "    \"\"\"Generates a PDF document.\"\"\"\n",
+        "    filename = f\"output_{uuid.uuid4()}.pdf\"\n",
+        "    doc = SimpleDocTemplate(\n",
+        "        filename,\n",
+        "        pagesize=A4,\n",
+        "        rightMargin=inch,\n",
+        "        leftMargin=inch,\n",
+        "        topMargin=inch,\n",
+        "        bottomMargin=inch\n",
+        "    )\n",
+        "    styles = getSampleStyleSheet()\n",
+        "    styles[\"Normal\"].fontSize = int(font_size)\n",
+        "    styles[\"Normal\"].leading = int(font_size) * line_spacing\n",
+        "    styles[\"Normal\"].alignment = {\n",
+        "        \"Left\": 0,\n",
+        "        \"Center\": 1,\n",
+        "        \"Right\": 2,\n",
+        "        \"Justified\": 4\n",
+        "    }[alignment]\n",
+        "\n",
+        "    story = []\n",
+        "\n",
+        "    # Add image with size adjustment\n",
+        "    image_sizes = {\n",
+        "        \"Small\": (200, 200),\n",
+        "        \"Medium\": (400, 400),\n",
+        "        \"Large\": (600, 600)\n",
+        "    }\n",
+        "    img = RLImage(media_path, width=image_sizes[image_size][0], height=image_sizes[image_size][1])\n",
+        "    story.append(img)\n",
+        "    story.append(Spacer(1, 12))\n",
+        "\n",
+        "    # Add plain text output\n",
+        "    text = Paragraph(plain_text, styles[\"Normal\"])\n",
+        "    story.append(text)\n",
+        "\n",
+        "    doc.build(story)\n",
+        "    return filename\n",
+        "\n",
+        "def generate_docx(media_path, plain_text, font_size, line_spacing, alignment, image_size):\n",
+        "    \"\"\"Generates a DOCX document.\"\"\"\n",
+        "    filename = f\"output_{uuid.uuid4()}.docx\"\n",
+        "    doc = docx.Document()\n",
+        "\n",
+        "    # Add image with size adjustment\n",
+        "    image_sizes = {\n",
+        "        \"Small\": docx.shared.Inches(2),\n",
+        "        \"Medium\": docx.shared.Inches(4),\n",
+        "        \"Large\": docx.shared.Inches(6)\n",
+        "    }\n",
+        "    doc.add_picture(media_path, width=image_sizes[image_size])\n",
+        "    doc.add_paragraph()\n",
+        "\n",
+        "    # Add plain text output\n",
+        "    paragraph = doc.add_paragraph()\n",
+        "    paragraph.paragraph_format.line_spacing = line_spacing\n",
+        "    paragraph.paragraph_format.alignment = {\n",
+        "        \"Left\": WD_ALIGN_PARAGRAPH.LEFT,\n",
+        "        \"Center\": WD_ALIGN_PARAGRAPH.CENTER,\n",
+        "        \"Right\": WD_ALIGN_PARAGRAPH.RIGHT,\n",
+        "        \"Justified\": WD_ALIGN_PARAGRAPH.JUSTIFY\n",
+        "    }[alignment]\n",
+        "    run = paragraph.add_run(plain_text)\n",
+        "    run.font.size = docx.shared.Pt(int(font_size))\n",
+        "\n",
+        "    doc.save(filename)\n",
+        "    return filename\n",
+        "\n",
+        "# CSS for output styling\n",
+        "css = \"\"\"\n",
+        "  #output {\n",
+        "    height: 500px;\n",
+        "    overflow: auto;\n",
+        "    border: 1px solid #ccc;\n",
+        "  }\n",
+        ".submit-btn {\n",
+        "    background-color: #cf3434  !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #ff2323 !important;\n",
+        "}\n",
+        ".download-btn {\n",
+        "    background-color: #35a6d6 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".download-btn:hover {\n",
+        "    background-color: #22bcff !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Gradio app setup\n",
+        "with gr.Blocks(css=css) as demo:\n",
+        "    gr.Markdown(\"# Inkscope-Captions-2B-0526 : Vision and Language Processing\")\n",
+        "\n",
+        "    with gr.Tab(label=\"Image Input\"):\n",
+        "\n",
+        "        with gr.Row():\n",
+        "            with gr.Column():\n",
+        "                model_choice = gr.Dropdown(\n",
+        "                    label=\"Model Selection\",\n",
+        "                    choices=list(MODEL_OPTIONS.keys()),\n",
+        "                    value=\"Inkscope-Captions-2B-0526\"\n",
+        "                )\n",
+        "                input_media = gr.File(\n",
+        "                    label=\"Upload Image\", type=\"filepath\"\n",
+        "                )\n",
+        "                text_input = gr.Textbox(label=\"Question\", placeholder=\"Ask a question about the image...\")\n",
+        "                submit_btn = gr.Button(value=\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Column():\n",
+        "                output_text = gr.Textbox(label=\"Output Text\", lines=10)\n",
+        "                plain_text_output = gr.Textbox(label=\"Standardized Plain Text\", lines=10)\n",
+        "\n",
+        "        submit_btn.click(\n",
+        "            qwen_inference, [model_choice, input_media, text_input], [output_text]\n",
+        "        ).then(\n",
+        "            lambda output_text: format_plain_text(output_text), [output_text], [plain_text_output]\n",
+        "        )\n",
+        "\n",
+        "        # Add examples directly usable by clicking\n",
+        "        with gr.Row():\n",
+        "            with gr.Column():\n",
+        "                line_spacing = gr.Dropdown(\n",
+        "                    choices=[0.5, 1.0, 1.15, 1.5, 2.0, 2.5, 3.0],\n",
+        "                    value=1.5,\n",
+        "                    label=\"Line Spacing\"\n",
+        "                )\n",
+        "                font_size = gr.Dropdown(\n",
+        "                    choices=[\"8\", \"10\", \"12\", \"14\", \"16\", \"18\", \"20\", \"22\", \"24\"],\n",
+        "                    value=\"18\",\n",
+        "                    label=\"Font Size\"\n",
+        "                )\n",
+        "                alignment = gr.Dropdown(\n",
+        "                    choices=[\"Left\", \"Center\", \"Right\", \"Justified\"],\n",
+        "                    value=\"Justified\",\n",
+        "                    label=\"Text Alignment\"\n",
+        "                )\n",
+        "                image_size = gr.Dropdown(\n",
+        "                    choices=[\"Small\", \"Medium\", \"Large\"],\n",
+        "                    value=\"Small\",\n",
+        "                    label=\"Image Size\"\n",
+        "                )\n",
+        "                file_format = gr.Radio([\"pdf\", \"docx\"], label=\"File Format\", value=\"pdf\")\n",
+        "                get_document_btn = gr.Button(value=\"Get Document\", elem_classes=\"download-btn\")\n",
+        "\n",
+        "        get_document_btn.click(\n",
+        "            generate_document, [input_media, output_text, file_format, font_size, line_spacing, alignment, image_size], gr.File(label=\"Download Document\")\n",
+        "        )\n",
+        "\n",
+        "demo.launch(debug=True)"
+      ],
+      "metadata": {
+        "id": "ovBSsRFhGbs2"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Inkscope-Captions-2B-0526/requirements.txt

@@ -0,0 +1,17 @@
+gradio
+spaces
+transformers
+accelerate
+numpy
+requests
+torch
+torchvision
+qwen-vl-utils
+av
+ipython
+reportlab
+fpdf
+python-docx
+pillow
+huggingface_hub
+hf_xet

MiMo-VL-7B-RL/MiMo_VL_7B_RL.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2_5_VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"4096\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"XiaomiMiMo/MiMo-VL-7B-RL\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2_5_VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **XiaomiMiMo/MiMo-VL-7B-RL**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

MiMo-VL-7B-SFT/MiMo_VL_7B_SFT.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2_5_VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"4096\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"XiaomiMiMo/MiMo-VL-7B-SFT\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2_5_VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **XiaomiMiMo/MiMo-VL-7B-SFT**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Qwen-2VL-MessyOCR/Qwen2_VL_OCR_2B_Instruct_prithivmlmods.ipynb

@@ -0,0 +1,247 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import time\n",
+        "import numpy as np\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"8192\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"prithivMLmods/Qwen2-VL-OCR-2B-Instruct\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(device).eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(\n",
+        "        messages, tokenize=False, add_generation_prompt=True\n",
+        "    )\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False  # Disable truncation to keep image tokens intact\n",
+        "    ).to(device)\n",
+        "\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    for image, timestamp in frames:\n",
+        "        messages[1][\"content\"].extend([\n",
+        "            {\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"},\n",
+        "            {\"type\": \"image\", \"image\": image}\n",
+        "        ])\n",
+        "\n",
+        "    # Use chat template with no truncation\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False\n",
+        "    ).to(device)\n",
+        "\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "# Gradio App Style and Layout\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **prithivMLmods/Qwen2-VL-OCR-2B-Instruct**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)\n"
+      ],
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

Qwen2-VL/Qwen2_VL_2B_Instruct.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"8192\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"Qwen/Qwen2-VL-2B-Instruct\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **Qwen/Qwen2-VL-2B-Instruct**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Qwen2-VL/Qwen2_VL_7B_Instruct.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"8192\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"Qwen/Qwen2-VL-7B-Instruct\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **Qwen/Qwen2-VL-7B-Instruct**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Qwen2.5-VL/Qwen2_5VL_3B.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2_5_VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"8192\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"Qwen/Qwen2.5-VL-3B-Instruct\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2_5_VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **Qwen/Qwen2.5-VL-3B-Instruct**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Qwen2.5-VL/Qwen2_5VL_7B.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2_5_VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"8192\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"Qwen/Qwen2.5-VL-7B-Instruct\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2_5_VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **Qwen/Qwen2.5-VL-7B-Instruct**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

README.md

@@ -0,0 +1,104 @@
+---
+license: apache-2.0
+task_categories:
+- video-text-to-text
+- image-to-text
+language:
+- en
+tags:
+- colab
+- notebook
+- demo
+- vlm
+- models
+- hf
+- ocr
+- reasoning
+- code
+size_categories:
+- n<1K
+---
+# **VLM-Video-Understanding**
+
+> A minimalistic demo for image inference and video understanding using OpenCV, built on top of several popular open-source Vision-Language Models (VLMs). This repository provides Colab notebooks demonstrating how to apply these VLMs to video and image tasks using Python and Gradio.
+
+## Overview
+
+This project showcases lightweight inference pipelines for the following:
+- Video frame extraction and preprocessing
+- Image-level inference with VLMs
+- Real-time or pre-recorded video understanding
+- OCR-based text extraction from video frames
+
+## Models Included
+
+The repository supports a variety of open-source models and configurations, including:
+
+- Aya-Vision-8B
+- Florence-2-Base
+- Gemma3-VL
+- MiMo-VL-7B-RL
+- MiMo-VL-7B-SFT
+- Qwen2-VL
+- Qwen2.5-VL
+- Qwen-2VL-MessyOCR
+- RolmOCR-Qwen2.5-VL
+- olmOCR-Qwen2-VL
+- typhoon-ocr-7b-Qwen2.5VL
+
+Each model has a dedicated Colab notebook to help users understand how to use it with video inputs.
+
+## Technologies Used
+
+- **Python**
+- **OpenCV** – for video and image processing
+- **Gradio** – for interactive UI
+- **Jupyter Notebooks** – for easy experimentation
+- **Hugging Face Transformers** – for loading VLMs
+
+## Folder Structure
+
+```
+
+├── Aya-Vision-8B/
+├── Florence-2-Base/
+├── Gemma3-VL/
+├── MiMo-VL-7B-RL/
+├── MiMo-VL-7B-SFT/
+├── Qwen2-VL/
+├── Qwen2.5-VL/
+├── Qwen-2VL-MessyOCR/
+├── RolmOCR-Qwen2.5-VL/
+├── olmOCR-Qwen2-VL/
+├── typhoon-ocr-7b-Qwen2.5VL/
+├── LICENSE
+└── README.md
+
+````
+
+## Getting Started
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/PRITHIVSAKTHIUR/VLM-Video-Understanding.git
+cd VLM-Video-Understanding
+````
+
+2. Open any of the Colab notebooks and follow the instructions to run image or video inference.
+
+3. Optionally, install dependencies locally:
+
+```bash
+pip install opencv-python gradio transformers
+```
+
+## Hugging Face Dataset
+
+The models and examples are supported by a dataset on Hugging Face:
+
+[VLM-Video-Understanding](https://huggingface.co/datasets/prithivMLmods/VLM-Video-Understanding)
+
+## License
+
+This project is licensed under the Apache-2.0 License.

RolmOCR-Qwen2.5-VL/reducto_RolmOCR_Qwen2_5VL_7B.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2_5_VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"8192\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"reducto/RolmOCR\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2_5_VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False  # Disable truncation to keep image tokens intact\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **reducto/RolmOCR**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

olmOCR-Qwen2-VL/olmOCR_7B_0225.ipynb

@@ -0,0 +1,242 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2_5_VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"8192\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"allenai/olmOCR-7B-0225-preview\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2_5_VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **allenai/olmOCR-7B-0225-preview**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ],
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

typhoon-ocr-7b-Qwen2.5VL/typhoon_ocr_7b.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL8y37Y6bORU"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!pip install gradio spaces transformers accelerate numpy requests\n",
+        "!pip install torch torchvision qwen-vl-utils av hf_xet\n",
+        "!pip install pillow huggingface_hub opencv-python"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Y-NTbL1tdL9X"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import uuid\n",
+        "import json\n",
+        "import time\n",
+        "import asyncio\n",
+        "from threading import Thread\n",
+        "\n",
+        "import gradio as gr\n",
+        "import spaces\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import cv2\n",
+        "\n",
+        "from transformers import (\n",
+        "    Qwen2_5_VLForConditionalGeneration,\n",
+        "    AutoProcessor,\n",
+        "    TextIteratorStreamer,\n",
+        ")\n",
+        "from transformers.image_utils import load_image\n",
+        "\n",
+        "# Constants for text generation\n",
+        "MAX_MAX_NEW_TOKENS = 2048\n",
+        "DEFAULT_MAX_NEW_TOKENS = 1024\n",
+        "# Increase or disable input truncation to avoid token mismatches\n",
+        "MAX_INPUT_TOKEN_LENGTH = int(os.getenv(\"MAX_INPUT_TOKEN_LENGTH\", \"8192\"))\n",
+        "\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "MODEL_ID = \"scb10x/typhoon-ocr-7b\"\n",
+        "processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)\n",
+        "model_m = Qwen2_5_VLForConditionalGeneration.from_pretrained(\n",
+        "    MODEL_ID,\n",
+        "    trust_remote_code=True,\n",
+        "    torch_dtype=torch.float16\n",
+        ").to(\"cuda\").eval()\n",
+        "\n",
+        "def downsample_video(video_path):\n",
+        "    \"\"\"\n",
+        "    Downsamples the video to evenly spaced frames.\n",
+        "    Each frame is returned as a PIL image along with its timestamp.\n",
+        "    \"\"\"\n",
+        "    vidcap = cv2.VideoCapture(video_path)\n",
+        "    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+        "    fps = vidcap.get(cv2.CAP_PROP_FPS)\n",
+        "    frames = []\n",
+        "    # Sample 10 evenly spaced frames.\n",
+        "    frame_indices = np.linspace(0, total_frames - 1, 10, dtype=int)\n",
+        "    for i in frame_indices:\n",
+        "        vidcap.set(cv2.CAP_PROP_POS_FRAMES, i)\n",
+        "        success, image = vidcap.read()\n",
+        "        if success:\n",
+        "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB\n",
+        "            pil_image = Image.fromarray(image)\n",
+        "            timestamp = round(i / fps, 2)\n",
+        "            frames.append((pil_image, timestamp))\n",
+        "    vidcap.release()\n",
+        "    return frames\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_image(text: str, image: Image.Image,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if image is None:\n",
+        "        yield \"Please upload an image.\"\n",
+        "        return\n",
+        "\n",
+        "    messages = [{\n",
+        "        \"role\": \"user\",\n",
+        "        \"content\": [\n",
+        "            {\"type\": \"image\", \"image\": image},\n",
+        "            {\"type\": \"text\", \"text\": text},\n",
+        "        ]\n",
+        "    }]\n",
+        "    prompt_full = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+        "    inputs = processor(\n",
+        "        text=[prompt_full],\n",
+        "        images=[image],\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=True,\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {**inputs, \"streamer\": streamer, \"max_new_tokens\": max_new_tokens}\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "@spaces.GPU\n",
+        "def generate_video(text: str, video_path: str,\n",
+        "                   max_new_tokens: int = 1024,\n",
+        "                   temperature: float = 0.6,\n",
+        "                   top_p: float = 0.9,\n",
+        "                   top_k: int = 50,\n",
+        "                   repetition_penalty: float = 1.2):\n",
+        "\n",
+        "    if video_path is None:\n",
+        "        yield \"Please upload a video.\"\n",
+        "        return\n",
+        "\n",
+        "    frames = downsample_video(video_path)\n",
+        "    messages = [\n",
+        "        {\"role\": \"system\", \"content\": [{\"type\": \"text\", \"text\": \"You are a helpful assistant.\"}]},\n",
+        "        {\"role\": \"user\", \"content\": [{\"type\": \"text\", \"text\": text}]}\n",
+        "    ]\n",
+        "    # Append each frame with its timestamp.\n",
+        "    for frame in frames:\n",
+        "        image, timestamp = frame\n",
+        "        messages[1][\"content\"].append({\"type\": \"text\", \"text\": f\"Frame {timestamp}:\"})\n",
+        "        messages[1][\"content\"].append({\"type\": \"image\", \"image\": image})\n",
+        "    inputs = processor.apply_chat_template(\n",
+        "        messages,\n",
+        "        tokenize=True,\n",
+        "        add_generation_prompt=True,\n",
+        "        return_dict=True,\n",
+        "        return_tensors=\"pt\",\n",
+        "        truncation=False,\n",
+        "        max_length=MAX_INPUT_TOKEN_LENGTH\n",
+        "    ).to(\"cuda\")\n",
+        "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)\n",
+        "    generation_kwargs = {\n",
+        "        **inputs,\n",
+        "        \"streamer\": streamer,\n",
+        "        \"max_new_tokens\": max_new_tokens,\n",
+        "        \"do_sample\": True,\n",
+        "        \"temperature\": temperature,\n",
+        "        \"top_p\": top_p,\n",
+        "        \"top_k\": top_k,\n",
+        "        \"repetition_penalty\": repetition_penalty,\n",
+        "    }\n",
+        "    thread = Thread(target=model_m.generate, kwargs=generation_kwargs)\n",
+        "    thread.start()\n",
+        "    buffer = \"\"\n",
+        "    for new_text in streamer:\n",
+        "        buffer += new_text\n",
+        "        buffer = buffer.replace(\"<|im_end|>\", \"\")\n",
+        "        time.sleep(0.01)\n",
+        "        yield buffer\n",
+        "\n",
+        "css = \"\"\"\n",
+        ".submit-btn {\n",
+        "    background-color: #2980b9 !important;\n",
+        "    color: white !important;\n",
+        "}\n",
+        ".submit-btn:hover {\n",
+        "    background-color: #3498db !important;\n",
+        "}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Create the Gradio Interface\n",
+        "with gr.Blocks(css=css, theme=\"bethecloud/storj_theme\") as demo:\n",
+        "    gr.Markdown(\"# **typhoon-ocr-7b**\")\n",
+        "    with gr.Row():\n",
+        "        with gr.Column():\n",
+        "            with gr.Tabs():\n",
+        "                with gr.TabItem(\"Image Inference\"):\n",
+        "                    image_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    image_upload = gr.Image(type=\"pil\", label=\"Image\")\n",
+        "                    image_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "                with gr.TabItem(\"Video Inference\"):\n",
+        "                    video_query = gr.Textbox(label=\"Query Input\", placeholder=\"Enter your query here...\")\n",
+        "                    video_upload = gr.Video(label=\"Video\")\n",
+        "                    video_submit = gr.Button(\"Submit\", elem_classes=\"submit-btn\")\n",
+        "\n",
+        "            with gr.Accordion(\"Advanced options\", open=False):\n",
+        "                max_new_tokens = gr.Slider(label=\"Max new tokens\", minimum=1, maximum=MAX_MAX_NEW_TOKENS, step=1, value=DEFAULT_MAX_NEW_TOKENS)\n",
+        "                temperature = gr.Slider(label=\"Temperature\", minimum=0.1, maximum=4.0, step=0.1, value=0.6)\n",
+        "                top_p = gr.Slider(label=\"Top-p (nucleus sampling)\", minimum=0.05, maximum=1.0, step=0.05, value=0.9)\n",
+        "                top_k = gr.Slider(label=\"Top-k\", minimum=1, maximum=1000, step=1, value=50)\n",
+        "                repetition_penalty = gr.Slider(label=\"Repetition penalty\", minimum=1.0, maximum=2.0, step=0.05, value=1.2)\n",
+        "        with gr.Column():\n",
+        "            output = gr.Textbox(label=\"Output\", interactive=False)\n",
+        "\n",
+        "    image_submit.click(\n",
+        "        fn=generate_image,\n",
+        "        inputs=[image_query, image_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "    video_submit.click(\n",
+        "        fn=generate_video,\n",
+        "        inputs=[video_query, video_upload, max_new_tokens, temperature, top_p, top_k, repetition_penalty],\n",
+        "        outputs=output\n",
+        "    )\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    demo.queue(max_size=30).launch(share=True, ssr_mode=False, show_error=True)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}