upload notebooks

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": []
+    }
+  ]
+}

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
+}

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
+}