init demo.

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,63 +1,290 @@
+import os
+import shutil
+
+import torch
+import tempfile
 import gradio as gr
-from huggingface_hub import InferenceClient
+from PIL import Image
+from fastapi import FastAPI
 
+import sys
+sys.path.append('./')
+from videollama2.constants import MMODAL_TOKEN_INDEX, DEFAULT_MMODAL_TOKEN
+from videollama2.conversation import conv_templates, SeparatorStyle, Conversation
+from videollama2.model.builder import load_pretrained_model
+from videollama2.mm_utils import KeywordsStoppingCriteria, tokenizer_MMODAL_token, get_model_name_from_path, process_image, process_video
+
+
+title_markdown = ("""
+<div style="display: flex; justify-content: center; align-items: center; text-align: center;">
+  <a href="https://github.com/DAMO-NLP-SG/VideoLLaMA2" style="margin-right: 20px; text-decoration: none; display: flex; align-items: center;">
+    <img src="https://s2.loli.net/2024/06/03/D3NeXHWy5az9tmT.png" alt="VideoLLaMA2🚀" style="max-width: 120px; height: auto;">
+  </a>
+  <div>
+    <h1 >VideoLLaMA 2: Advancing Spatial-Temporal Modeling and Audio Understanding in Video-LLMs</h1>
+    <h5 style="margin: 0;">If you like our project, please give us a star ✨ on Github for the latest update.</h5>
+  </div>
+</div>
+
+
+<div align="center">
+    <div style="display:flex; gap: 0.25rem;" align="center">
+        <a href='VideoLLaMA 2: Advancing Spatial-Temporal Modeling and Audio Understanding in Video-LLMs'><img src='https://img.shields.io/badge/Github-Code-blue'></a>
+        <a href="https://arxiv.org/pdf/2406.07476.pdf"><img src="https://img.shields.io/badge/Arxiv-2406.07476-red"></a>
+        <a href='https://github.com/DAMO-NLP-SG/VideoLLaMA2/stargazers'><img src='https://img.shields.io/github/stars/DAMO-NLP-SG/VideoLLaMA2.svg?style=social'></a>
+    </div>
+</div>
+""")
+
+
+block_css = """
+#buttons button {
+    min-width: min(120px,100%);
+}
 """
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+tos_markdown = ("""
+### Terms of use
+By using this service, users are required to agree to the following terms:
+The service is a research preview intended for non-commercial use only. It only provides limited safety measures and may generate offensive content. It must not be used for any illegal, harmful, violent, racist, or sexual purposes. The service may collect user dialogue data for future research.
+Please click the "Flag" button if you get any inappropriate answer! We will collect those to keep improving our moderator.
+For an optimal experience, please use desktop computers for this demo, as mobile devices may compromise its quality.
+""")
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
 
-    messages.append({"role": "user", "content": message})
+learn_more_markdown = ("""
+### License
+The service is a research preview intended for non-commercial use only, subject to the model [License](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md) of LLaMA, [Terms of Use](https://openai.com/policies/terms-of-use) of the data generated by OpenAI, and [Privacy Practices](https://chrome.google.com/webstore/detail/sharegpt-share-your-chatg/daiacboceoaocpibfodeljbdfacokfjb) of ShareGPT. Please contact us if you find any potential violation.
+""")
 
-    response = ""
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+class Chat:
+    def __init__(self, model_path, conv_mode, model_base=None, load_8bit=False, load_4bit=False, device='cuda'):
+        # disable_torch_init()
+        model_name = get_model_name_from_path(model_path)
+        self.tokenizer, self.model, processor, context_len = load_pretrained_model(
+            model_path, model_base, model_name,
+            load_8bit, load_4bit,
+            device=device)
+        self.processor = processor
+        self.conv_mode = conv_mode
+        self.conv = conv_templates[conv_mode].copy()
+        self.device = self.model.device
 
-        response += token
-        yield response
+    def get_prompt(self, qs, state):
+        state.append_message(state.roles[0], qs)
+        state.append_message(state.roles[1], None)
+        return state
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-if __name__ == "__main__":
-    demo.launch()
+    @torch.inference_mode()
+    def generate(self, tensor: list, modals: list, prompt: str, first_run: bool, state):
+        # TODO: support multiple turns of conversation.
+        assert len(tensor) == len(modals)
+
+        # 1. prepare model, tokenizer, and processor.
+        tokenizer, model, processor = self.tokenizer, self.model, self.processor
+
+        # 2. text preprocess (tag process & generate prompt).
+        state = self.get_prompt(prompt, state)
+        prompt = state.get_prompt()
+        # print('\n\n\n')
+        # print(prompt)
+        input_ids = tokenizer_MMODAL_token(prompt, tokenizer, MMODAL_TOKEN_INDEX[modals[0]], return_tensors='pt').unsqueeze(0).to(self.device)
+
+        # 3. generate response according to visual signals and prompts. 
+        stop_str = self.conv.sep if self.conv.sep_style in [SeparatorStyle.SINGLE] else self.conv.sep2
+        # keywords = ["<s>", "</s>"]
+        keywords = [stop_str]
+        stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
+
+        with torch.inference_mode():
+            output_ids = model.generate(
+                input_ids,
+                images_or_videos=tensor,
+                modal_list=modals,
+                do_sample=True,
+                temperature=0.2,
+                max_new_tokens=1024,
+                use_cache=True,
+                stopping_criteria=[stopping_criteria],
+            )
+
+        outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]
+        print(outputs)
+        return outputs, state
+
+
+def save_image_to_local(image):
+    filename = os.path.join('temp', next(tempfile._get_candidate_names()) + '.jpg')
+    image = Image.open(image)
+    image.save(filename)
+    return filename
+
+
+def save_video_to_local(video_path):
+    filename = os.path.join('temp', next(tempfile._get_candidate_names()) + '.mp4')
+    shutil.copyfile(video_path, filename)
+    return filename
+
+
+def generate(image, video, first_run, state, state_, textbox_in, tensor, modals, dtype=torch.float16):
+    flag = 1
+    if not textbox_in:
+        if len(state_.messages) > 0:
+            textbox_in = state_.messages[-1][1]
+            state_.messages.pop(-1)
+            flag = 0
+        else:
+            return "Please enter instruction"
+
+    image = image if image else "none"
+    video = video if video else "none"
+    assert not (os.path.exists(image) and os.path.exists(video))
+
+    if type(state) is not Conversation:
+        state = conv_templates[conv_mode].copy()
+        state_ = conv_templates[conv_mode].copy()
+        tensor = []
+        modals = []
+
+    first_run = False if len(state.messages) > 0 else True
+
+    text_en_in = textbox_in.replace("picture", "image")
+
+    processor = handler.processor
+    if os.path.exists(image) and not os.path.exists(video):
+        tensor.append(process_image(image, processor).to(handler.model.device, dtype=dtype))
+        modals.append('IMAGE')
+    if not os.path.exists(image) and os.path.exists(video):
+        tensor.append(process_video(video, processor).to(handler.model.device, dtype=dtype))
+        modals.append('VIDEO')
+    if os.path.exists(image) and os.path.exists(video):
+        raise NotImplementedError("Not support image and video at the same time")
+
+    # BUG: Only support single video and image inference now.
+    if os.path.exists(image) and not os.path.exists(video):
+        text_en_in = text_en_in.replace(DEFAULT_MMODAL_TOKEN['IMAGE'], '').strip()
+        text_en_in = DEFAULT_MMODAL_TOKEN['IMAGE'] + '\n' + text_en_in
+    if not os.path.exists(image) and os.path.exists(video):
+        text_en_in = text_en_in.replace(DEFAULT_MMODAL_TOKEN['VIDEO'], '').strip()
+        text_en_in = DEFAULT_MMODAL_TOKEN['VIDEO'] + '\n' + text_en_in
+    # if os.path.exists(image) and os.path.exists(video):
+    #   pass
+    text_en_out, state_ = handler.generate(tensor, modals, text_en_in, first_run=first_run, state=state_)
+    state_.messages[-1] = (state_.roles[1], text_en_out)
+
+    text_en_out = text_en_out.split('#')[0]
+    textbox_out = text_en_out
+
+    show_images = ""
+    if os.path.exists(image):
+        filename = save_image_to_local(image)
+        show_images += f'<img src="./file={filename}" style="display: inline-block;width: 250px;max-height: 400px;">'
+    if os.path.exists(video):
+        filename = save_video_to_local(video)
+        show_images += f'<video controls playsinline width="500" style="display: inline-block;"  src="./file={filename}"></video>'
+
+    if flag:
+        state.append_message(state.roles[0], textbox_in + "\n" + show_images)
+    state.append_message(state.roles[1], textbox_out)
+
+    return (gr.update(value=image if os.path.exists(image) else None, interactive=True), gr.update(value=video if os.path.exists(video) else None, interactive=True), 
+            state.to_gradio_chatbot(), False, state, state_, gr.update(value=None, interactive=True), tensor, modals)
+
+
+def regenerate(state, state_, textbox, tensor, modals):
+    state.messages.pop(-1)
+    state_.messages.pop(-1)
+    tensor.pop(-1)
+    modals.pop(-1)
+    textbox = gr.update(value=None, interactive=True)
+    if len(state.messages) > 0:
+        return state, state_, textbox, state.to_gradio_chatbot(), False, tensor, modals
+    return state, state_, textbox, state.to_gradio_chatbot(), True, tensor, modals
+
+
+def clear_history(state, state_, tensor, modals):
+    state = conv_templates[conv_mode].copy()
+    state_ = conv_templates[conv_mode].copy()
+    return (gr.update(value=None, interactive=True),
+            gr.update(value=None, interactive=True), \
+            state.to_gradio_chatbot(), \
+            True, state, state_, gr.update(value=None, interactive=True), [], [])
+
+
+if __name__ == '__main__':
+    conv_mode = "llama_2"
+    model_path = 'DAMO-NLP-SG/VideoLLaMA2-7B'
+
+    handler = Chat(model_path, conv_mode=conv_mode, load_8bit=False, load_4bit=False, device='cuda')
+    handler.model.to(dtype=torch.float16)
+
+    if not os.path.exists("temp"):
+        os.makedirs("temp")
+
+    app = FastAPI()
+
+    textbox = gr.Textbox(
+        show_label=False, placeholder="Enter text and press ENTER", container=False
+    )
+    with gr.Blocks(title='VideoLLaMA2🚀', theme=gr.themes.Default(), css=block_css) as demo:
+        gr.Markdown(title_markdown)
+        state = gr.State()
+        state_ = gr.State()
+        first_run = gr.State()
+        tensor = gr.State()
+        modals = gr.State()
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                image = gr.Image(label="Input Image", type="filepath")
+                video = gr.Video(label="Input Video")
+
+                cur_dir = os.path.dirname(os.path.abspath(__file__))
+                gr.Examples(
+                    examples=[
+                        [
+                            f"{cur_dir}/examples/extreme_ironing.jpg",
+                            "What is unusual about this image?",
+                        ],
+                        [
+                            f"{cur_dir}/examples/waterview.jpg",
+                            "What are the things I should be cautious about when I visit here?",
+                        ],
+                        [
+                            f"{cur_dir}/examples/desert.jpg",
+                            "If there are factual errors in the questions, point it out; if not, proceed answering the question. What’s happening in the desert?",
+                        ],
+                    ],
+                    inputs=[image, textbox],
+                )
+
+            with gr.Column(scale=7):
+                chatbot = gr.Chatbot(label="VideoLLaMA2", bubble_full_width=True).style(height=750)
+                with gr.Row():
+                    with gr.Column(scale=8):
+                        textbox.render()
+                    with gr.Column(scale=1, min_width=50):
+                        submit_btn = gr.Button(value="Send", variant="primary", interactive=True)
+                with gr.Row(elem_id="buttons") as button_row:
+                    upvote_btn = gr.Button(value="👍  Upvote", interactive=True)
+                    downvote_btn = gr.Button(value="👎  Downvote", interactive=True)
+                    # flag_btn = gr.Button(value="⚠️  Flag", interactive=True)
+                    # stop_btn = gr.Button(value="⏹️  Stop Generation", interactive=False)
+                    regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=True)
+                    clear_btn = gr.Button(value="🗑️  Clear history", interactive=True)
+
+        gr.Markdown(tos_markdown)
+        gr.Markdown(learn_more_markdown)
+
+        submit_btn.click(generate, [image, video, first_run, state, state_, textbox, tensor, modals],
+                        [image, video, chatbot, first_run, state, state_, textbox, tensor, modals])
+
+        regenerate_btn.click(regenerate, [state, state_, textbox, tensor, modals], [state, state_, textbox, chatbot, first_run, tensor, modals]).then(
+            generate, [image, video, first_run, state, state_, textbox, tensor, modals], [image, video, chatbot, first_run, state, state_, textbox, tensor, modals])
+
+        clear_btn.click(clear_history, [state, state_, tensor, modals],
+                        [image, video, chatbot, first_run, state, state_, textbox, tensor, modals])
+
+    demo.launch()

requirements.txt

@@ -1 +1,31 @@
-huggingface_hub==0.22.2
+huggingface_hub==0.22.2
+torch>=2.0.1
+torchvision>=0.15.2
+transformers==4.37.2
+tokenizers==0.15.1
+sentencepiece==0.1.99
+shortuuid
+deepspeed==0.13.1
+accelerate==0.21.0
+peft==0.4.0
+decord==0.6.0
+pytorchvideo==0.1.5
+imageio==2.34.0
+imageio-ffmpeg==0.4.9
+moviepy==1.0.3
+scenedetect==0.6.3
+numpy
+scikit-learn==1.2.2
+einops==0.6.1
+einops-exts==0.0.4
+timm==0.6.13
+bitsandbytes==0.41.0
+pydantic<2,>=1
+markdown2[all]
+gradio==3.35.2
+gradio_client==0.2.9
+requests
+httpx==0.24.0
+uvicorn
+fastapi
+wandb

videollama2/__init__.py

@@ -0,0 +1 @@
+from .model import Videollama2LlamaForCausalLM, Videollama2MistralForCausalLM

videollama2/constants.py

@@ -0,0 +1,38 @@
+CONTROLLER_HEART_BEAT_EXPIRATION = 30
+WORKER_HEART_BEAT_INTERVAL = 15
+
+LOGDIR = "./log_dir"
+
+NUM_FRAMES = 8
+MAX_FRAMES = 32
+NUM_FRAMES_PER_SECOND = 1
+Grids = [(2, 2), (1, 2), (1, 3), (1, 4), (2, 1), (3, 1), (4, 1)]
+
+# Model Constants
+IGNORE_INDEX = -100
+IMAGE_TOKEN_INDEX = -200
+DEFAULT_IMAGE_TOKEN = "<image>"
+DEFAULT_VIDEO_TOKEN = "<video>"
+DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
+DEFAULT_IM_START_TOKEN = "<im_start>"
+DEFAULT_IM_END_TOKEN = "<im_end>"
+IMAGE_PLACEHOLDER = "<image-placeholder>"
+
+
+DEFAULT_IMAGE_TOKEN = "<image>"
+DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
+DEFAULT_IM_START_TOKEN = "<im_start>"
+DEFAULT_IM_END_TOKEN = "<im_end>"
+IMAGE_PLACEHOLDER = "<image-placeholder>"
+
+
+MMODAL_TOKEN_INDEX = {"IMAGE": -200, "VIDEO": -201, "AUDIO": -202}
+MMODAL_INDEX_TOKEN = {v: k for k, v in MMODAL_TOKEN_INDEX.items()}
+MMODAL_START_TOKEN_INDEX = {"IMAGE": "<im_start>", "VIDEO": "<vid_start>", "AUDIO": "<ad_start>"}
+MMODAL_END_TOKEN_INDEX = {"IMAGE": "<im_end>", "VIDEO": "<vid_end>", "AUDIO": "<ad_end>"}
+
+
+DEFAULT_MMODAL_TOKEN = {"IMAGE": "<image>", "VIDEO": "<video>", "AUDIO": "<audio>"}
+DEFAULT_MMODAL_PATCH_TOKEN = {"IMAGE": "<im_patch>", "VIDEO": "<vid_patch>", "AUDIO": "<ad_patch>"}
+DEFAULT_MMODAL_START_TOKEN = {"IMAGE": "<Image>", "VIDEO": "<Video>", "AUDIO": "<ad_start>"}
+DEFAULT_MMODAL_END_TOKEN = {"IMAGE": "<\Image>", "VIDEO": "<\Video>", "AUDIO": "<\Audio>"}

videollama2/conversation.py

@@ -0,0 +1,484 @@
+import base64
+import dataclasses
+from io import BytesIO
+from enum import auto, Enum
+from typing import List, Tuple
+
+from PIL import Image
+from .constants import LOGDIR, NUM_FRAMES
+
+
+class SeparatorStyle(Enum):
+    """Different separator style."""
+    SINGLE = auto()
+    TWO = auto()
+    MPT = auto()
+    PLAIN = auto()
+    LLAMA_2 = auto()
+
+
+@dataclasses.dataclass
+class Conversation:
+    """A class that keeps all conversation history."""
+    system: str
+    roles: List[str]
+    messages: List[List[str]]
+    offset: int
+    sep_style: SeparatorStyle = SeparatorStyle.SINGLE
+    sep: str = "###"
+    sep2: str = None
+    version: str = "Unknown"
+
+    skip_next: bool = False
+    modality: str = "image"
+
+    def get_prompt(self):
+        messages = self.messages
+        modality_token = f"<{self.modality}>"
+        if len(messages) > 0 and type(messages[0][1]) is tuple:
+            messages = self.messages.copy()
+            init_role, init_msg = messages[0].copy()
+            init_msg = init_msg[0].replace(modality_token, "").strip()
+            if 'mmtag' in self.version:
+                messages[0] = (init_role, init_msg)
+                messages.insert(0, (self.roles[0], "<Image><image></Image>"))
+                messages.insert(1, (self.roles[1], "Received."))
+            else:
+                messages[0] = (init_role, f"{modality_token}\n" + init_msg)
+
+        if self.sep_style == SeparatorStyle.SINGLE:
+            ret = self.system + self.sep
+            for role, message in messages:
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    ret += role + ": " + message + self.sep
+                else:
+                    ret += role + ":"
+        elif self.sep_style == SeparatorStyle.TWO:
+            seps = [self.sep, self.sep2]
+            ret = self.system + seps[0]
+            for i, (role, message) in enumerate(messages):
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    ret += role + ": " + message + seps[i % 2]
+                else:
+                    ret += role + ":"
+        elif self.sep_style == SeparatorStyle.MPT:
+            ret = self.system + self.sep
+            for role, message in messages:
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    ret += role + message + self.sep
+                else:
+                    ret += role
+        elif self.sep_style == SeparatorStyle.LLAMA_2:
+            wrap_sys = lambda msg: f"<<SYS>>\n{msg}\n<</SYS>>\n\n"
+            wrap_inst = lambda msg: f"[INST] {msg} [/INST]"
+            ret = ""
+
+            for i, (role, message) in enumerate(messages):
+                if i == 0:
+                    assert message, "first message should not be none"
+                    assert role == self.roles[0], "first message should come from user"
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    if i == 0: message = wrap_sys(self.system) + message
+                    if i % 2 == 0:
+                        message = wrap_inst(message)
+                        ret += self.sep + message
+                    else:
+                        ret += " " + message + " " + self.sep2
+                else:
+                    ret += ""
+            ret = ret.lstrip(self.sep)
+        elif self.sep_style == SeparatorStyle.PLAIN:
+            seps = [self.sep, self.sep2]
+            ret = self.system
+            for i, (role, message) in enumerate(messages):
+                if message:
+                    if type(message) is tuple:
+                        message, _, _ = message
+                    ret += message + seps[i % 2]
+                else:
+                    ret += ""
+        else:
+            raise ValueError(f"Invalid style: {self.sep_style}")
+
+        return ret
+
+    def append_message(self, role, message):
+        self.messages.append([role, message])
+
+
+    def process_image(self, image, image_process_mode, return_pil=False, image_format='PNG', max_len=800, min_len=400):
+        if image_process_mode == "Pad":
+            def expand2square(pil_img, background_color=(122, 116, 104)):
+                width, height = pil_img.size
+                if width == height:
+                    return pil_img
+                elif width > height:
+                    result = Image.new(pil_img.mode, (width, width), background_color)
+                    result.paste(pil_img, (0, (width - height) // 2))
+                    return result
+                else:
+                    result = Image.new(pil_img.mode, (height, height), background_color)
+                    result.paste(pil_img, ((height - width) // 2, 0))
+                    return result
+            image = expand2square(image)
+        elif image_process_mode in ["Default", "Crop"]:
+            pass
+        elif image_process_mode == "Resize":
+            image = image.resize((336, 336))
+        else:
+            raise ValueError(f"Invalid image_process_mode: {image_process_mode}")
+        if max(image.size) > max_len:
+            max_hw, min_hw = max(image.size), min(image.size)
+            aspect_ratio = max_hw / min_hw
+            shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
+            longest_edge = int(shortest_edge * aspect_ratio)
+            W, H = image.size
+            if H > W:
+                H, W = longest_edge, shortest_edge
+            else:
+                H, W = shortest_edge, longest_edge
+            image = image.resize((W, H))
+        if return_pil:
+            return image
+        else:
+            buffered = BytesIO()
+            image.save(buffered, format=image_format)
+            img_b64_str = base64.b64encode(buffered.getvalue()).decode()
+            return img_b64_str
+
+
+    def get_videos(self, return_pil=False):
+        video_frames = []
+        for i, (role, msg) in enumerate(self.messages[self.offset:]):
+            if i % 2 == 0:
+                if type(msg) is tuple:
+                    from decord import VideoReader, cpu
+                    import numpy as np
+                    # here video is the file path of input video
+                    msg, video, image_process_mode = msg
+                    if not return_pil:
+                        # return filepath
+                        video_frames.append(video)
+                    else:
+                        # read video using decord.VideoReader
+                        decord_vr = VideoReader(uri=video, ctx=cpu(0))
+                        duration = len(decord_vr)
+                        frame_id_list = np.linspace(0, duration-1, NUM_FRAMES, dtype=int)
+                        # convert the extracted image frames into PIL objects
+                        all_images = [Image.fromarray(f) for f in decord_vr.get_batch(frame_id_list).asnumpy()]
+                        video_frames.extend([self.process_image(image, image_process_mode, return_pil=return_pil) for image in all_images])
+        return video_frames
+
+
+    def get_images(self, return_pil=False):
+        images = []
+        for i, (role, msg) in enumerate(self.messages[self.offset:]):
+            if i % 2 == 0:
+                if type(msg) is tuple:
+                    msg, image, image_process_mode = msg
+                    image = self.process_image(image, image_process_mode, return_pil=return_pil)
+                    images.append(image)
+
+                    # import base64
+                    # from io import BytesIO
+                    # from PIL import Image
+                    # # here image is a PIL object
+                    # msg, image, image_process_mode = msg
+                    # if image_process_mode == "Pad":
+                    #     def expand2square(pil_img, background_color=(122, 116, 104)):
+                    #         width, height = pil_img.size
+                    #         if width == height:
+                    #             return pil_img
+                    #         elif width > height:
+                    #             result = Image.new(pil_img.mode, (width, width), background_color)
+                    #             result.paste(pil_img, (0, (width - height) // 2))
+                    #             return result
+                    #         else:
+                    #             result = Image.new(pil_img.mode, (height, height), background_color)
+                    #             result.paste(pil_img, ((height - width) // 2, 0))
+                    #             return result
+                    #     image = expand2square(image)
+                    # elif image_process_mode in ["Default", "Crop"]:
+                    #     pass
+                    # elif image_process_mode == "Resize":
+                    #     image = image.resize((336, 336))
+                    # else:
+                    #     raise ValueError(f"Invalid image_process_mode: {image_process_mode}")
+                    # max_hw, min_hw = max(image.size), min(image.size)
+                    # aspect_ratio = max_hw / min_hw
+                    # max_len, min_len = 800, 400
+                    # shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
+                    # longest_edge = int(shortest_edge * aspect_ratio)
+                    # W, H = image.size
+                    # if longest_edge != max(image.size):
+                    #     if H > W:
+                    #         H, W = longest_edge, shortest_edge
+                    #     else:
+                    #         H, W = shortest_edge, longest_edge
+                    #     image = image.resize((W, H))
+                    # if return_pil:
+                    #     images.append(image)
+                    # else:
+                    #     buffered = BytesIO()
+                    #     image.save(buffered, format="PNG")
+                    #     img_b64_str = base64.b64encode(buffered.getvalue()).decode()
+                    #     images.append(img_b64_str)
+        return images
+
+    def to_gradio_chatbot(self):
+        ret = []
+        for i, (role, msg) in enumerate(self.messages[self.offset:]):
+            if i % 2 == 0:
+                if type(msg) is tuple:
+                    # import base64
+                    # from io import BytesIO
+                    # from PIL import Image
+                    # msg, image, image_process_mode = msg
+                    # max_hw, min_hw = max(image.size), min(image.size)
+                    # aspect_ratio = max_hw / min_hw
+                    # max_len, min_len = 800, 400
+                    # shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
+                    # longest_edge = int(shortest_edge * aspect_ratio)
+                    # W, H = image.size
+                    # if H > W:
+                    #     H, W = longest_edge, shortest_edge
+                    # else:
+                    #     H, W = shortest_edge, longest_edge
+                    # image = image.resize((W, H))
+                    # buffered = BytesIO()
+                    # image.save(buffered, format="JPEG")
+                    # img_b64_str = base64.b64encode(buffered.getvalue()).decode()
+                    # img_str = f'<img src="data:image/png;base64,{img_b64_str}" alt="user upload image" />'
+                    # display image/video in the textbox
+                    msg, image_or_video, image_process_mode = msg
+                    ##print("imagebox:", image)
+                    if isinstance(image_or_video, Image.Image):
+                        # image is PIL object
+                        img_b64_str = self.process_image(image_or_video, "Default", return_pil=False, image_format='JPEG')
+                        img_str = f'<img src="data:image/jpeg;base64,{img_b64_str}" alt="user upload image" />'
+                        msg = img_str + msg.replace('<image>', '').strip()
+                    else:
+                        # video is file path
+                        vid_str = f'<video controls playsinline width="500" style="display: inline-block;" src="./file={image_or_video}"></video><br>'
+                        msg = vid_str + msg.replace('<video>', '').strip()
+                    ret.append([msg, None])
+                else:
+                    ret.append([msg, None])
+            else:
+                ret[-1][-1] = msg
+        return ret
+
+    def copy(self):
+        return Conversation(
+            system=self.system,
+            roles=self.roles,
+            messages=[[x, y] for x, y in self.messages],
+            offset=self.offset,
+            sep_style=self.sep_style,
+            sep=self.sep,
+            sep2=self.sep2,
+            version=self.version)
+
+    def dict(self):
+        if (self.modality == "image" and len(self.get_images()) > 0) or \
+            (self.modality == "video" and len(self.get_videos()) > 0):
+            return {
+                "system": self.system,
+                "roles": self.roles,
+                "messages": [[x, y[0] if type(y) is tuple else y] for x, y in self.messages],
+                "offset": self.offset,
+                "sep": self.sep,
+                "sep2": self.sep2,
+                "modality": self.modality
+            }
+        return {
+            "system": self.system,
+            "roles": self.roles,
+            "messages": self.messages,
+            "offset": self.offset,
+            "sep": self.sep,
+            "sep2": self.sep2,
+        }
+
+conv_mistral_instruct = Conversation(
+    system="A chat between a curious user and an artificial intelligence assistant. "
+    "The assistant gives helpful, detailed, and polite answers to the user's questions.",
+    roles=("USER", "ASSISTANT"),
+    version="llama_v2",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.LLAMA_2,
+    sep="",
+    sep2="</s>",
+)
+conv_vicuna_v0 = Conversation(
+    system="A chat between a curious human and an artificial intelligence assistant. "
+           "The assistant gives helpful, detailed, and polite answers to the human's questions.",
+    roles=("Human", "Assistant"),
+    messages=(
+        ("Human", "What are the key differences between renewable and non-renewable energy sources?"),
+        ("Assistant",
+            "Renewable energy sources are those that can be replenished naturally in a relatively "
+            "short amount of time, such as solar, wind, hydro, geothermal, and biomass. "
+            "Non-renewable energy sources, on the other hand, are finite and will eventually be "
+            "depleted, such as coal, oil, and natural gas. Here are some key differences between "
+            "renewable and non-renewable energy sources:\n"
+            "1. Availability: Renewable energy sources are virtually inexhaustible, while non-renewable "
+            "energy sources are finite and will eventually run out.\n"
+            "2. Environmental impact: Renewable energy sources have a much lower environmental impact "
+            "than non-renewable sources, which can lead to air and water pollution, greenhouse gas emissions, "
+            "and other negative effects.\n"
+            "3. Cost: Renewable energy sources can be more expensive to initially set up, but they typically "
+            "have lower operational costs than non-renewable sources.\n"
+            "4. Reliability: Renewable energy sources are often more reliable and can be used in more remote "
+            "locations than non-renewable sources.\n"
+            "5. Flexibility: Renewable energy sources are often more flexible and can be adapted to different "
+            "situations and needs, while non-renewable sources are more rigid and inflexible.\n"
+            "6. Sustainability: Renewable energy sources are more sustainable over the long term, while "
+            "non-renewable sources are not, and their depletion can lead to economic and social instability.\n")
+    ),
+    offset=2,
+    sep_style=SeparatorStyle.SINGLE,
+    sep="###",
+)
+
+conv_vicuna_v1 = Conversation(
+    system="A chat between a curious user and an artificial intelligence assistant. "
+    "The assistant gives helpful, detailed, and polite answers to the user's questions.",
+    roles=("USER", "ASSISTANT"),
+    version="v1",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.TWO,
+    sep=" ",
+    sep2="</s>",
+)
+
+conv_llama_2 = Conversation(
+    system="""You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe.  Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature.
+
+If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information.""",
+    roles=("USER", "ASSISTANT"),
+    version="llama_v2",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.LLAMA_2,
+    sep="<s>",
+    sep2="</s>",
+)
+
+conv_llava_llama_2 = Conversation(
+    system="You are a helpful language and vision assistant. "
+           "You are able to understand the visual content that the user provides, "
+           "and assist the user with a variety of tasks using natural language.",
+    roles=("USER", "ASSISTANT"),
+    version="llama_v2",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.LLAMA_2,
+    sep="<s>",
+    sep2="</s>",
+)
+
+conv_mpt = Conversation(
+    system="""<|im_start|>system
+A conversation between a user and an LLM-based AI assistant. The assistant gives helpful and honest answers.""",
+    roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
+    version="mpt",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.MPT,
+    sep="<|im_end|>",
+)
+
+conv_llava_plain = Conversation(
+    system="",
+    roles=("", ""),
+    messages=(
+    ),
+    offset=0,
+    sep_style=SeparatorStyle.PLAIN,
+    sep="\n",
+)
+
+conv_llava_v0 = Conversation(
+    system="A chat between a curious human and an artificial intelligence assistant. "
+           "The assistant gives helpful, detailed, and polite answers to the human's questions.",
+    roles=("Human", "Assistant"),
+    messages=(
+    ),
+    offset=0,
+    sep_style=SeparatorStyle.SINGLE,
+    sep="###",
+)
+
+conv_llava_v0_mmtag = Conversation(
+    system="A chat between a curious user and an artificial intelligence assistant. "
+           "The assistant is able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
+           "The visual content will be provided with the following format: <Image>visual content</Image>.",
+    roles=("Human", "Assistant"),
+    messages=(
+    ),
+    offset=0,
+    sep_style=SeparatorStyle.SINGLE,
+    sep="###",
+    version="v0_mmtag",
+)
+
+conv_llava_v1 = Conversation(
+    system="A chat between a curious human and an artificial intelligence assistant. "
+           "The assistant gives helpful, detailed, and polite answers to the human's questions.",
+    roles=("USER", "ASSISTANT"),
+    version="v1",
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.TWO,
+    sep=" ",
+    sep2="</s>",
+)
+
+conv_llava_v1_mmtag = Conversation(
+    system="A chat between a curious user and an artificial intelligence assistant. "
+           "The assistant is able to understand the visual content that the user provides, and assist the user with a variety of tasks using natural language."
+           "The visual content will be provided with the following format: <Image>visual content</Image>.",
+    roles=("USER", "ASSISTANT"),
+    messages=(),
+    offset=0,
+    sep_style=SeparatorStyle.TWO,
+    sep=" ",
+    sep2="</s>",
+    version="v1_mmtag",
+)
+
+default_conversation = conv_vicuna_v1
+conv_templates = {
+    "default": conv_vicuna_v0,
+    "v0": conv_vicuna_v0,
+    "v1": conv_vicuna_v1,
+    "vicuna_v1": conv_vicuna_v1,
+    "llama_2": conv_llama_2,
+
+    "plain": conv_llava_plain,
+    "v0_plain": conv_llava_plain,
+    "llava_v0": conv_llava_v0,
+    "v0_mmtag": conv_llava_v0_mmtag,
+    "llava_v1": conv_llava_v1,
+    "v1_mmtag": conv_llava_v1_mmtag,
+    "llava_llama_2": conv_llava_llama_2,
+
+    "video_llama_beta": conv_llava_llama_2,
+    "mistral_instruct": conv_mistral_instruct,
+    "mpt": conv_mpt,
+}
+
+
+if __name__ == "__main__":
+    print(default_conversation.get_prompt())

videollama2/eval/eval_benchmark_1_correctness.py

@@ -0,0 +1,210 @@
+import os
+import argparse
+import json
+import ast
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3
+    Returns a score for correctness.
+    """
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            message = [
+                    {
+                        "role": "system",
+                        "content": 
+                            "You are an intelligent chatbot designed for evaluating the factual accuracy of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with the correct answer and determine if they are factually consistent. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Focus on the factual consistency between the predicted answer and the correct answer. The predicted answer should not contain any misinterpretations or misinformation.\n"
+                            "- The predicted answer must be factually accurate and align with the video content.\n"
+                            "- Consider synonyms or paraphrases as valid matches.\n"
+                            "- Evaluate the factual accuracy of the prediction compared to the answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a factual accuracy score where the factual accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of factual consistency. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the factual accuracy score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question = sample['Q']
+        answer = sample['A']
+        pred = sample['P']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e:
+            traceback.print_exc()
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in tqdm(os.listdir(output_dir)):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score for correctness:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

videollama2/eval/eval_benchmark_2_detailed_orientation.py

@@ -0,0 +1,210 @@
+import os
+import argparse
+import json
+import ast
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3 and
+    returns a score for detailed orientation.
+    """
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            # Compute the detailed-orientation score
+            message = [
+                    {
+                        "role": "system",
+                        "content":
+                            "You are an intelligent chatbot designed for evaluating the detail orientation of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with the correct answer and determine its level of detail, considering both completeness and specificity. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Check if the predicted answer covers all major points from the video. The response should not leave out any key aspects.\n"
+                            "- Evaluate whether the predicted answer includes specific details rather than just generic points. It should provide comprehensive information that is tied to specific elements of the video.\n"
+                            "- Consider synonyms or paraphrases as valid matches.\n"
+                            "- Provide a single evaluation score that reflects the level of detail orientation of the prediction, considering both completeness and specificity."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a detail orientation score where the detail orientation score is an integer value between 0 and 5, with 5 indicating the highest level of detail orientation. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the detail orientation score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question = sample['Q']
+        answer = sample['A']
+        pred = sample['P']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in tqdm(os.listdir(output_dir)):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score for detailed orientation:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

videollama2/eval/eval_benchmark_3_context.py

@@ -0,0 +1,212 @@
+import os
+import argparse
+import json
+import ast
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3 and
+    returns a score for contextual understanding.
+    """
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            # Compute the contextual understanding score
+            message = [
+                    {
+                        "role": "system",
+                        "content":
+                            "You are an intelligent chatbot designed for evaluating the contextual understanding of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with the correct answer and determine if the generated response aligns with the overall context of the video content. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Evaluate whether the predicted answer aligns with the overall context of the video content. It should not provide information that is out of context or misaligned.\n"
+                            "- The predicted answer must capture the main themes and sentiments of the video.\n"
+                            "- Consider synonyms or paraphrases as valid matches.\n"
+                            "- Provide your evaluation of the contextual understanding of the prediction compared to the answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a contextual understanding score where the contextual understanding score is an integer value between 0 and 5, with 5 indicating the highest level of contextual understanding. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is contextual understanding score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question = sample['Q']
+        answer = sample['A']
+        pred = sample['P']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in tqdm(os.listdir(output_dir)):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score for contextual understanding:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

videollama2/eval/eval_benchmark_4_temporal.py

@@ -0,0 +1,206 @@
+import os
+import argparse
+import json
+import ast
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            message = [
+                    {
+                        "role": "system",
+                        "content":
+                            "You are an intelligent chatbot designed for evaluating the temporal understanding of generative outputs for video-based question-answer pairs. "
+                            "Your task is to compare the predicted answer with the correct answer and determine if they correctly reflect the temporal sequence of events in the video content. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Focus on the temporal consistency between the predicted answer and the correct answer. The predicted answer should correctly reflect the sequence of events or details as they are presented in the video content.\n"
+                            "- Consider synonyms or paraphrases as valid matches, but only if the temporal order is maintained.\n"
+                            "- Evaluate the temporal accuracy of the prediction compared to the answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question: {question}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer: {pred}\n\n"
+                            "Provide your evaluation only as a temporal accuracy score where the temporal accuracy score is an integer value between 0 and 5, with 5 indicating the highest level of temporal consistency. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the temporal accuracy score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question = sample['Q']
+        answer = sample['A']
+        pred = sample['P']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e: 
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in os.listdir(output_dir):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score temporal understanding:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

videollama2/eval/eval_benchmark_5_consistency.py

@@ -0,0 +1,218 @@
+import os
+import argparse
+import json
+import ast
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3 and
+    returns a score for consistency.
+    """
+
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question1 = qa_set['q1']
+        question2 = qa_set['q2']
+        answer = qa_set['a']
+        pred1 = qa_set['p1']
+        pred2 = qa_set['p2']
+        try:
+            message = [
+                    {
+                        "role": "system",
+                        "content":
+                            "You are an intelligent chatbot designed for evaluating the consistency of generative outputs for similar video-based question-answer pairs. "
+                            "You will be given two very similar questions, a common answer common to both the questions and predicted answers for the two questions ."
+                            "Your task is to compare the predicted answers for two very similar question, with a common correct answer and determine if they are consistent. Here's how you can accomplish the task:"
+                            "------"
+                            "##INSTRUCTIONS: "
+                            "- Focus on the consistency between the two predicted answers and the correct answer. Both predicted answers should correspond to the correct answer and to each other, and should not contain any contradictions or significant differences in the conveyed information.\n"
+                            "- Both predicted answers must be consistent with each other and the correct answer, in terms of the information they provide about the video content.\n"
+                            "- Consider synonyms or paraphrases as valid matches, but only if they maintain the consistency in the conveyed information.\n"
+                            "- Evaluate the consistency of the two predicted answers compared to the correct answer."
+                    },
+                    {
+                        "role": "user",
+                        "content":
+                            "Please evaluate the following video-based question-answer pair:\n\n"
+                            f"Question 1: {question1}\n"
+                            f"Question 2: {question2}\n"
+                            f"Correct Answer: {answer}\n"
+                            f"Predicted Answer to Question 1: {pred1}\n"
+                            f"Predicted Answer to Question 2: {pred2}\n\n"
+                            "Provide your evaluation only as a consistency score where the consistency score is an integer value between 0 and 5, with 5 indicating the highest level of consistency. "
+                            "Please generate the response in the form of a Python dictionary string with keys 'score', where its value is the consistency score in INTEGER, not STRING."
+                            "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                            "For example, your response should look like this: {''score': 4.8}."
+                    }
+                ]
+
+            completion = interaction(client, message)
+            # Convert response to a Python dictionary.
+            response_message = completion.choices[0].message.content
+            response_dict = ast.literal_eval(response_message)
+            result_qa_pair = [response_dict, qa_set]
+
+            # Save the question-answer pairs to a json file.
+            with open(f"{output_dir}/{key}.json", "w") as f:
+                json.dump(result_qa_pair, f)
+
+        except Exception as e:
+            print(f"Error processing file '{key}': {e}")
+
+
+def main(args):
+    pred_contents = [eval(line) for line in open(args.pred_path, 'r').readlines()]
+
+    # Dictionary to store the count of occurrences for each video_id
+    video_id_counts = {}
+    new_pred_contents = []
+
+    # Iterate through each sample in pred_contents
+    for sample in pred_contents:
+        video_id = sample['video_name']
+        if video_id in video_id_counts:
+            video_id_counts[video_id] += 1
+        else:
+            video_id_counts[video_id] = 0
+
+        # Create a new sample with the modified key
+        new_sample = sample
+        new_sample['video_name'] = f"{video_id}_{video_id_counts[video_id]}"
+        new_pred_contents.append(new_sample)
+
+    # Generating list of id's and corresponding files
+    id_list = [x['video_name'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['video_name']
+        question1 = sample['Q1']
+        question2 = sample['Q2']
+        answer = sample['A']
+        pred1 = sample['P1']
+        pred2 = sample['P2']
+        qa_set = {"q1": question1, "q2": question2, "a": answer, "p1": pred1, "p2": pred2}
+        prediction_set[id] = qa_set
+
+    # Set the OpenAI API key.
+    # openai.api_key = args.api_key
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e: 
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in os.listdir(output_dir):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                content = json.load(json_file)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score
+    score_sum = 0
+    count = 0
+    for key, result in combined_contents.items():
+        count += 1
+        score_match = result[0]['score']
+        score = int(score_match)
+        score_sum += score
+    average_score = score_sum / count
+
+    print("Average score for consistency:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

videollama2/eval/eval_video_qa_gpt.py

@@ -0,0 +1,219 @@
+import os
+import ast
+import json
+import time
+import argparse
+import traceback
+from tqdm import tqdm
+from multiprocessing.pool import Pool
+
+from openai import AzureOpenAI
+
+
+def init():
+    client = AzureOpenAI(
+        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
+        api_key=os.getenv("AZURE_OPENAI_KEY"),  
+        api_version="2024-02-15-preview"
+    )
+
+    return client
+
+
+def interaction(client, message_text):
+    completion = client.chat.completions.create(
+        model=os.getenv("AZURE_OPENAI_DEPLOYNAME"),
+        messages = message_text,
+        temperature=0.7,
+        max_tokens=800,
+        top_p=0.95,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+
+    return completion
+
+
+def prompt_gpt(question, answer, pred, key, qa_set, output_dir):
+    message = [
+        {
+            "role": "system",
+            "content":
+                "You are an intelligent chatbot designed for evaluating the correctness of generative outputs for question-answer pairs. "
+                "Your task is to compare the predicted answer with the correct answer and determine if they match meaningfully. Here's how you can accomplish the task:"
+                "------"
+                "##INSTRUCTIONS: "
+                "- Focus on the meaningful match between the predicted answer and the correct answer.\n"
+                "- Consider synonyms or paraphrases as valid matches.\n"
+                "- Evaluate the correctness of the prediction compared to the answer."
+        },
+        {
+            "role": "user",
+            "content":
+                "Please evaluate the following video-based question-answer pair:\n\n"
+                f"Question: {question}\n"
+                f"Correct Answer: {answer}\n"
+                f"Predicted Answer: {pred}\n\n"
+                "Provide your evaluation only as a yes/no and score where the score is an integer value between 0 and 5, with 5 indicating the highest meaningful match. "
+                "Please generate the response in the form of a Python dictionary string with keys 'pred' and 'score', where value of 'pred' is  a string of 'yes' or 'no' and value of 'score' is in INTEGER, not STRING."
+                "DO NOT PROVIDE ANY OTHER OUTPUT TEXT OR EXPLANATION. Only provide the Python dictionary string. "
+                "For example, your response should look like this: {'pred': 'yes', 'score': 4.8}."
+        }
+    ]
+    completion = interaction(client, message)
+    # Convert response to a Python dictionary.
+    response_message = completion.choices[0].message.content
+    response_dict = ast.literal_eval(response_message)
+    result_qa_pair = [response_dict, qa_set]
+    # # Save the question-answer pairs to a json file.
+    with open(f"{output_dir}/{key}.json", "w") as f:
+        json.dump(result_qa_pair, f)
+
+
+def annotate(prediction_set, caption_files, output_dir, args):
+    """
+    Evaluates question and answer pairs using GPT-3
+    Returns a score for correctness.
+    """
+    
+    for file in tqdm(caption_files):
+        key = file[:-5] # Strip file extension
+        qa_set = prediction_set[key]
+        question = qa_set['q']
+        answer = qa_set['a']
+        pred = qa_set['p']
+        try:
+            prompt_gpt(question, answer, pred, key, qa_set, output_dir)
+        except Exception as e:
+            traceback.print_exc()
+            prompt_gpt(question, answer, pred[:50], key, qa_set, output_dir)
+
+    time.sleep(1)
+
+
+def main(args):
+
+    file = open(args.pred_path)
+    new_pred_contents = [eval(i.strip()) for i in file.readlines()]
+
+    # Generating list of id's and corresponding files
+    id_list = [x['id'] for x in new_pred_contents]
+    caption_files = [f"{id}.json" for id in id_list]
+
+    output_dir = args.output_dir
+    # Generate output directory if not exists.
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Preparing dictionary of question-answer sets
+    prediction_set = {}
+    for sample in new_pred_contents:
+        id = sample['id']
+        question = sample['question']
+        answer = sample['answer']
+        pred = sample['pred']
+        qa_set = {"q": question, "a": answer, "p": pred}
+        prediction_set[id] = qa_set
+
+    num_tasks = args.num_tasks
+
+    # While loop to ensure that all captions are processed.
+    while True:
+        try:
+            # Files that have not been processed yet.
+            completed_files = os.listdir(output_dir)
+            print(f"completed_files: {len(completed_files)}")
+
+            # Files that have not been processed yet.
+            incomplete_files = [f for f in caption_files if f not in completed_files]
+            print(f"incomplete_files: {len(incomplete_files)}")
+
+            # Break the loop when there are no incomplete files
+            if len(incomplete_files) == 0:
+                break
+            if len(incomplete_files) <= num_tasks:
+                num_tasks = 1
+
+            # Split tasks into parts.
+            part_len = len(incomplete_files) // num_tasks
+            all_parts = [incomplete_files[i:i + part_len] for i in range(0, len(incomplete_files), part_len)]
+            task_args = [(prediction_set, part, args.output_dir, args) for part in all_parts]
+
+            # Use a pool of workers to process the files in parallel.
+            with Pool() as pool:
+                pool.starmap(annotate, task_args)
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+    # Combine all the processed files into one
+    combined_contents = {}
+    json_path = args.output_json
+
+    # Iterate through json files
+    for file_name in tqdm(os.listdir(output_dir)):
+        if file_name.endswith(".json"):
+            file_path = os.path.join(output_dir, file_name)
+            with open(file_path, "r") as json_file:
+                try:
+                    content = json.load(json_file)
+                except:
+                    print(json_file)
+                    exit(0)
+                combined_contents[file_name[:-5]] = content
+
+    # Write combined content to a json file
+    with open(json_path, "w") as json_file:
+        json.dump(combined_contents, json_file)
+    print("All evaluation completed!")
+
+    # Calculate average score and accuracy
+    score_sum = 0
+    count = 0
+    yes_count = 0
+    no_count = 0
+    for key, result in tqdm(combined_contents.items()):
+        try:
+            # Computing score
+            count += 1
+            score_match = result[0]['score']
+            score = int(score_match)
+            score_sum += score
+
+            # Computing accuracy
+            pred = result[0]['pred']
+            if "yes" in pred.lower():
+                yes_count += 1
+            elif "no" in pred.lower():
+                no_count += 1
+        except:
+            print(result)
+
+    average_score = score_sum / count
+    accuracy = yes_count / (yes_count + no_count)
+    print("Yes count:", yes_count)
+    print("No count:", no_count)
+    print("Accuracy:", accuracy)
+    print("Average score:", average_score)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="question-answer-generation-using-gpt-3")
+    parser.add_argument("--pred-path", required=True, help="The path to file containing prediction.")
+    parser.add_argument("--output-dir", required=True, help="The path to save annotation json files.")
+    parser.add_argument("--output-json", required=True, help="The path to save annotation final combined json file.")
+    parser.add_argument("--num-tasks", required=True, type=int, help="Number of splits.")
+    parser.add_argument("--api-key", required=True, type=str, help="Azure Openai API key.")
+    parser.add_argument("--api-endpoint", required=True, type=str, help="Azure Openai API endpoint.")
+    parser.add_argument("--api-deployname", required=True, type=str, help="Azure Openai API deployname.")
+    args = parser.parse_args()
+
+    # Set the OpenAI API key.
+    os.environ["AZURE_OPENAI_KEY"] = args.api_key
+    os.environ["AZURE_OPENAI_ENDPOINT"] = args.api_endpoint
+    os.environ["AZURE_OPENAI_DEPLOYNAME"] = args.api_deployname
+
+    client = init()
+
+    main(args)

videollama2/eval/eval_video_qa_mvbench.py

@@ -0,0 +1,64 @@
+import json
+import argparse
+from tabulate import tabulate
+
+
+tasks = {
+    "Action Sequence": ("action_sequence.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Action Prediction": ("action_prediction.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Action Antonym": ("action_antonym.json", "ssv2_video/", "video", False),
+    "Fine-grained Action": ("fine_grained_action.json", "pMoments_in_Time_Raw/videos/", "video", False),
+    "Unexpected Action": ("unexpected_action.json", "FunQA_test/test/", "video", False),
+    "Object Existence": ("object_existence.json", "clevrer/video_validation/", "video", False),
+    "Object Interaction": ("object_interaction.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Object Shuffle": ("object_shuffle.json", "perception/videos/", "video", False),
+    "Moving Direction": ("moving_direction.json", "clevrer/video_validation/", "video", False),
+    "Action Localization": ("action_localization.json", "sta/sta_video/", "video", True),  # has start & end
+    "Scene Transition": ("scene_transition.json", "scene_qa/video/", "video", False),
+    "Action Count": ("action_count.json", "perception/videos/", "video", False),
+    "Moving Count": ("moving_count.json", "clevrer/video_validation/", "video", False),
+    "Moving Attribute": ("moving_attribute.json", "clevrer/video_validation/", "video", False),
+    "State Change": ("state_change.json", "perception/videos/", "video", False),
+    "Fine-grained Pose": ("fine_grained_pose.json", "nturgbd/", "video", False),
+    "Character Order": ("character_order.json", "perception/videos/", "video", False),
+    "Egocentric Navigation": ("egocentric_navigation.json", "vlnqa/", "video", False),
+    "Episodic Reasoning": ("episodic_reasoning.json", "tvqa/frames_fps3_hq/", "frame", True),  # has start & end, read frame
+    "Counterfactual Inference": ("counterfactual_inference.json", "clevrer/video_validation/", "video", False),
+}
+
+
+def main():
+    args = parse_args()
+    res = [eval(x.strip()) for x in open(args.pred_path, 'r').readlines()]
+    task_types = tasks.keys()
+    task_acc = {x: [] for x in task_types}
+    acc = []
+    for i, x in enumerate(res):
+        value = 1
+        if x['pred'] != x['gt']:
+            value = 0
+        acc.append(value)
+        task_acc[x['task_type']].append(value)
+    acc = sum(acc) * 100 / len(acc)
+    task_acc = {x: sum(task_acc[x]) * 100 / len(task_acc[x]) for x in task_acc}
+    print(f"{args.pred_path}:", acc)
+    task_names = list(tasks.keys())
+    
+    table_data = []
+    for i in range(len(task_names) // 4):
+        row_task_names = task_names[i * 4: (i + 1) * 4]
+        row_task_acc = [task_acc[x] for x in row_task_names]
+        table_data.append(row_task_names)
+        table_data.append(row_task_acc)
+    print(tabulate(table_data, floatfmt=".1f"), '\n')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Evaluate video captioning.")
+    parser.add_argument("--pred_path", default=r'', help="The path to file containing prediction.")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    main()

videollama2/eval/run_inference_video_qa_batch.py

@@ -0,0 +1,563 @@
+import os
+import re
+import math
+import json
+import argparse
+import warnings
+
+import torch
+import decord
+import numpy as np
+import transformers
+from PIL import Image
+from tqdm import tqdm
+from decord import VideoReader, cpu
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms as T
+from torchvision.transforms import functional as F
+
+import sys
+sys.path.append('./')
+from videollama2.conversation import conv_templates, SeparatorStyle
+from videollama2.constants import NUM_FRAMES, DEFAULT_MMODAL_TOKEN, DEFAULT_MMODAL_START_TOKEN, DEFAULT_MMODAL_END_TOKEN, MMODAL_TOKEN_INDEX
+from videollama2.mm_utils import get_model_name_from_path, tokenizer_MMODAL_token, KeywordsStoppingCriteria, process_videos, expand2square
+from videollama2.model.builder import load_pretrained_model
+
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+default_mm_token = DEFAULT_MMODAL_TOKEN["VIDEO"]
+default_mm_start_token =  DEFAULT_MMODAL_START_TOKEN["VIDEO"]
+default_mm_end_token = DEFAULT_MMODAL_END_TOKEN["VIDEO"]
+modal_token_index = MMODAL_TOKEN_INDEX["VIDEO"]
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class MVBenchDataset(Dataset):
+
+    def __init__(self, data_list, processor, num_segments=8):
+        self.data_list = data_list
+
+        self.decord_method = {
+            'video': self.read_video,
+            'gif': self.read_gif,
+            'frame': self.read_frame,
+        }
+
+        self.processor = processor
+        self.num_segments = num_segments
+
+    def __str__(self):
+        len_list = {}
+        option_list = {}
+        for data in self.data_list:
+            if data['task_type'] not in len_list:
+                len_list[data['task_type']] = 0
+            len_list[data['task_type']] += 1
+            if data['task_type'] not in option_list:
+                option_list[data['task_type']] = 0
+            option_list[data['task_type']] += len(data['data']['candidates'])
+
+        correct = 0
+        total = 0
+        res = f"There are {len(self.data_list)} videos as follow:\n"
+        for k, v in len_list.items():
+            correct += len_list[k]
+            total += option_list[k]
+            res += f"{v} for {k} ({option_list[k]} options => {len_list[k]/option_list[k]*100:.2f}%)\n"
+            correct = correct + 1 / option_list[k]
+        res += f"Total random accuracy: {correct/total*100:.2f}%"
+        return res.rstrip()
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def get_index(self, bound, fps, max_frame, first_idx=0):
+        if bound:
+            start, end = bound[0], bound[1]
+        else:
+            start, end = -100000, 100000
+        start_idx = max(first_idx, round(start * fps))
+        end_idx = min(round(end * fps), max_frame)
+        seg_size = float(end_idx - start_idx) / self.num_segments
+        frame_indices = np.array([
+            int(start_idx + (seg_size / 2) + np.round(seg_size * idx))
+            for idx in range(self.num_segments)
+        ])
+        return frame_indices
+
+    def read_video(self, video_path, bound=None):
+        vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+        max_frame = len(vr) - 1
+        fps = float(vr.get_avg_fps())
+
+        images_group = list()
+        frame_indices = self.get_index(bound, fps, max_frame, first_idx=0) 
+        for frame_index in frame_indices:
+            img = Image.fromarray(vr[frame_index].asnumpy())
+            images_group.append(img)
+        # images_group = [expand2square(img, tuple(int(x*255) for x in self.processor.image_mean)) for img in images_group]
+        torch_imgs = self.processor(images_group, return_tensors='pt')['pixel_values']
+        return torch_imgs
+    
+    def read_gif(self, video_path, bound=None, fps=25):
+        gif = imageio.get_reader(video_path)
+        max_frame = len(gif) - 1
+        
+        images_group = list()
+        frame_indices = self.get_index(bound, fps, max_frame, first_idx=0) 
+        for index, frame in enumerate(gif):
+            if index in frame_indices:
+                img = cv2.cvtColor(frame, cv2.COLOR_RGBA2RGB)
+                img = Image.fromarray(img)
+                images_group.append(img)
+        # images_group = [expand2square(img, tuple(int(x*255) for x in self.processor.image_mean)) for img in images_group]
+        torch_imgs = self.processor(images_group, return_tensors='pt')['pixel_values']
+        return torch_imgs
+
+    def read_frame(self, video_path, bound=None, fps=3):
+        max_frame = len(os.listdir(video_path))
+        images_group = list()
+        frame_indices = self.get_index(bound, fps, max_frame, first_idx=1) # frame_idx starts from 1
+        for frame_index in frame_indices:
+            img = Image.open(os.path.join(video_path, f"{frame_index:05d}.jpg"))
+            images_group.append(img)
+        # images_group = [expand2square(img, tuple(int(x*255) for x in self.processor.image_mean)) for img in images_group]
+        torch_imgs = self.processor.preprocess(images_group, return_tensors='pt')['pixel_values']
+        return torch_imgs
+
+    def qa_template(self, data):
+        question = f"Question: {data['question']}\n"
+        question += "Options:\n"
+        answer = data['answer']
+        answer_idx = -1
+        for idx, c in enumerate(data['candidates']):
+            question += f"({chr(ord('A') + idx)}) {c}\n"
+            if c == answer:
+                answer_idx = idx
+        question = question.rstrip()
+        answer = f"({chr(ord('A') + answer_idx)}) {answer}"
+        return question, answer
+
+    def __getitem__(self, idx):
+        decord_method = self.decord_method[self.data_list[idx]['data_type']]
+        bound = None
+        if self.data_list[idx]['bound']:
+            bound = (
+                self.data_list[idx]['data']['start'],
+                self.data_list[idx]['data']['end'],
+            )
+        video_path = os.path.join(self.data_list[idx]['prefix'], self.data_list[idx]['data']['video'])
+        torch_imgs = decord_method(video_path, bound)
+        question = self.data_list[idx]['data']['question']
+        options = self.data_list[idx]['data']['candidates']
+        answer = self.data_list[idx]['data']['answer']
+        task_type = self.data_list[idx]['task_type']
+
+        # question, answer = self.qa_template(self.data_list[idx]['data'])
+
+        answer_idx = -1
+        letters = []
+        options_string = ''
+        for option_idx, c in enumerate(options):
+            letters.append(f"{chr(ord('A') + option_idx)}")
+            options_string += f"({chr(ord('A') + option_idx)}) {c}\n"
+            if c == answer:
+                answer_idx = option_idx
+
+        option_question = f'Question: {question}\nOptions:\n{options_string}Answer with the option\'s letter from the given choices directly and only give the best option.' 
+
+        return {
+            'video': torch_imgs, 
+            'video_path': video_path,
+            'question': option_question,
+            'letters': ','.join(letters),
+            'answer_idx': answer_idx,
+            'task_type': task_type
+        }
+
+
+tasks = {
+    "Action Sequence": ("action_sequence.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Action Prediction": ("action_prediction.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Action Antonym": ("action_antonym.json", "ssv2_video/", "video", False),
+    "Fine-grained Action": ("fine_grained_action.json", "Moments_in_Time_Raw/videos/", "video", False),
+    "Unexpected Action": ("unexpected_action.json", "FunQA_test/test/", "video", False),
+    "Object Existence": ("object_existence.json", "clevrer/video_validation/", "video", False),
+    "Object Interaction": ("object_interaction.json", "star/Charades_v1_480/", "video", True), # has start & end
+    "Object Shuffle": ("object_shuffle.json", "perception/videos/", "video", False),
+    "Moving Direction": ("moving_direction.json", "clevrer/video_validation/", "video", False),
+    "Action Localization": ("action_localization.json", "sta/sta_video/", "video", True),  # has start & end
+    "Scene Transition": ("scene_transition.json", "scene_qa/video/", "video", False),
+    "Action Count": ("action_count.json", "perception/videos/", "video", False),
+    "Moving Count": ("moving_count.json", "clevrer/video_validation/", "video", False),
+    "Moving Attribute": ("moving_attribute.json", "clevrer/video_validation/", "video", False),
+    "State Change": ("state_change.json", "perception/videos/", "video", False),
+    "Fine-grained Pose": ("fine_grained_pose.json", "nturgbd/", "video", False),
+    "Character Order": ("character_order.json", "perception/videos/", "video", False),
+    "Egocentric Navigation": ("egocentric_navigation.json", "vlnqa/", "video", False),
+    "Episodic Reasoning": ("episodic_reasoning.json", "tvqa/frames_fps3_hq/", "frame", True),  # has start & end, read frame
+    "Counterfactual Inference": ("counterfactual_inference.json", "clevrer/video_validation/", "video", False),
+}
+
+
+def build_mvbench_eval(args, processor, num_frames):
+    data_list = []
+    for task_name, task in tasks.items():
+        json_file = os.path.join(args.question_file, task[0])
+        vis_folder = os.path.join(args.video_folder, task[1])
+        with open(json_file, 'r') as f:
+            json_data = json.load(f)
+        for data in json_data:
+            data_list.append({
+                'task_type': task_name,
+                'prefix': vis_folder,
+                'data_type': task[2],
+                'bound': task[3],
+                'data': data
+            })
+    data_list = get_chunk(data_list, args.num_chunks, args.chunk_idx)
+    dataset = MVBenchDataset(data_list, processor, num_segments=num_frames)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers)
+    
+    return dataloader
+
+
+def mvbench_dump(ans_file, line, outputs):
+    for idx, output in enumerate(outputs):
+        vid = line['video_path'][idx]
+        task_type = line['task_type'][idx]
+        letters = line['letters'][idx].split(',')
+        answer_idx = line['answer_idx'][idx].item()
+
+        pred_answer = re.findall(f'[\(,\ ]*[{letters[0]}-{letters[-1]}][\),\ ]*', output)
+        if len(pred_answer) == 0:
+            pred_idx = (answer_idx + 1) % len(letters)
+        else:
+            pred_answer = pred_answer[0].strip()
+            if pred_answer.startswith('('):
+                pred_answer = pred_answer.strip('()')
+            pred_idx = letters.index(pred_answer)
+
+        ans_file.write(json.dumps({"vid": vid, "task_type": task_type, "pred": pred_idx, "gt": answer_idx}) + '\n')
+
+
+class NextoeDataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_list, processor, num_segments=8):
+        self.data_list = data_list
+        self.processor = processor
+        self.num_segments = num_segments
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        video_name = line['video']
+        question = line['question']
+        answer = line['answer']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+        
+        decord_vr = VideoReader(uri=video_path, ctx=cpu(0))
+        frames = decord_vr.get_batch(np.linspace(0, len(decord_vr) - 1, 8, dtype=int)).asnumpy()
+        video_tensor = self.processor.preprocess(frames, return_tensors='pt')['pixel_values']  # do not pad for video frames
+        
+        wrapped_question = f'Question: {question}\nAnswer the question using a single word or a short phrase with multiple words.'
+
+        return {
+            'video': video_tensor, 
+            'question': wrapped_question,
+            'answer': answer,
+            'qid': line['qid']
+        }
+
+
+def build_nextoe_eval(args, processor, num_frames):
+    questions = json.load(open(args.question_file, "r"))
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+    dataset = NextoeDataset(questions, processor, num_segments=num_frames)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers)
+    
+    return dataloader
+
+
+def nextoe_dump(ans_file, line, outputs):
+    for idx, output in enumerate(outputs):
+        vid, qid = line['qid'][idx].split('_')
+        ans_file.write(json.dumps({"vid": vid, "qid": qid, "prediction": output}) + '\n')
+
+
+class NextqaDataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_list, processor, num_segments=8):
+        self.data_list = data_list
+        self.processor = processor
+        self.num_segments = num_segments
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        video_name = line['video']
+        question = line['question']
+        answer = line['answer']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+        
+        decord_vr = VideoReader(uri=video_path, ctx=cpu(0))
+        frames = decord_vr.get_batch(np.linspace(0, len(decord_vr) - 1, 8, dtype=int)).asnumpy()
+        video_tensor = self.processor.preprocess(frames, return_tensors='pt')['pixel_values']  # do not pad for video frames
+        
+        assert line['num_option'] == 5
+        a0 = line['a0']
+        a1 = line['a1']
+        a2 = line['a2']
+        a3 = line['a3']
+        a4 = line['a4']
+
+        option_question = f'Question: {question}\nOptions:\n(A) {a0}\n(B) {a1}\n(C) {a2}\n(D) {a3}\n(E) {a4}\nAnswer with the option\'s letter from the given choices directly and only give the best option.' 
+
+        return {
+            'video': video_tensor, 
+            'question': option_question,
+            'answer': answer,
+            'qid': line['qid']
+        }
+
+
+def build_nextqa_eval(args, processor, num_frames):
+    questions = json.load(open(args.question_file, "r"))
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+    dataset = NextqaDataset(questions, processor, num_segments=num_frames)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers)
+    
+    return dataloader
+
+
+def nextqa_dump(ans_file, line, outputs):
+    for idx, output in enumerate(outputs):
+        qid = line['qid'][idx]
+        answer = line['answer'][idx].item()
+
+        letters = ['A', 'B', 'C', 'D', 'E']
+
+        pred_answer = re.findall('[\(,\ ]*[A-E][\),\ ]*', output)
+        if len(pred_answer) == 0:
+            pred_idx = 2
+        else:
+            pred_answer = pred_answer[0].strip()
+            if pred_answer.startswith('('):
+                pred_answer = pred_answer.strip('()')
+            pred_idx = letters.index(pred_answer)
+
+        ans_file.write(json.dumps({"id": qid, "prediction": pred_idx, "answer": answer}) + '\n')
+
+
+class EgoschemaDataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_list, processor, num_segments=8):
+        self.data_list = data_list
+        self.processor = processor
+        self.num_segments = num_segments
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        q_uid = line['q_uid']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"{q_uid}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        decord_vr = VideoReader(uri=video_path, ctx=cpu(0))
+        frames = decord_vr.get_batch(np.linspace(0, len(decord_vr) - 1, self.num_segments, dtype=int)).asnumpy()
+        video_tensor = self.processor.preprocess(frames, return_tensors='pt')['pixel_values']  # do not pad for video frames
+        
+        question = line['question']
+        a0 = line['option 0']
+        a1 = line['option 1']
+        a2 = line['option 2']
+        a3 = line['option 3']
+        a4 = line['option 4']
+        axs = [a0, a1, a2, a3, a4]
+        ops = ['(A)', '(B)', '(C)', '(D)', '(E)']
+
+        option_question = f'Question: {question}\nOptions:\n(A) {a0}\n(B) {a1}\n(C) {a2}\n(D) {a3}\n(E) {a4}\n.Answer with the option\'s letter from the given choices directly and only give the best option.' 
+
+        return {
+            'q_uid': q_uid,
+            'video': video_tensor, 
+            'question': option_question,
+        }
+
+
+def build_egoschema_eval(args, processor, num_frames):
+    questions = json.load(open(args.question_file, "r"))
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+    dataset = EgoschemaDataset(questions, processor, num_segments=num_frames)
+    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers)
+    
+    return dataloader
+
+
+def egoschema_dump(ans_file, line, outputs):
+    for idx, output in enumerate(outputs):
+        q_uid = line['q_uid'][idx]
+        letters = ['A', 'B', 'C', 'D', 'E']
+
+        pred_answer = re.findall('[\(\ ]*[A-E][\)\ ]*', output)
+        if len(pred_answer) == 0:
+            pred_idx = 2
+        else:
+            pred_answer = pred_answer[0].strip()
+            # if pred_answer.startswith('('):
+            pred_answer = pred_answer.strip('()')
+            pred_idx = letters.index(pred_answer)
+        ans_file.write(f'{q_uid}, {pred_idx}\n')
+
+
+def get_model_output(model, video_tensor, tokenizer, questions, conv_mode="v1", device='cuda'):
+
+    input_ids = []
+    modal_list = []
+    for qs in questions:
+        if model.config.mm_use_im_start_end:
+            qs = default_mm_start_token + default_mm_token + default_mm_end_token + "\n" + qs
+        else:
+            qs = default_mm_token + "\n" + qs
+
+        conv = conv_templates[conv_mode].copy()
+        conv.append_message(conv.roles[0], qs)
+        conv.append_message(conv.roles[1], None)
+        prompt = conv.get_prompt()
+
+        input_id = tokenizer_MMODAL_token(prompt, tokenizer, modal_token_index, return_tensors='pt')
+        input_ids.append(input_id)
+        modal_list.append("video")
+
+    # left pad sequence
+    input_ids = torch.nn.utils.rnn.pad_sequence(
+        [x.flip(dims=[0]) for x in input_ids],
+        batch_first=True,
+        padding_value=tokenizer.pad_token_id).flip(dims=[1]).to(device)
+
+    attention_mask=input_ids.ne(tokenizer.pad_token_id).to(device)
+
+    video_tensor = video_tensor.half().to(args.device)
+
+    with torch.inference_mode():
+        output_ids = model.generate(
+            input_ids,
+            attention_mask=attention_mask,
+            images_or_videos=video_tensor,
+            modal_list=modal_list,
+            do_sample=False,
+            max_new_tokens=1024,
+            use_cache=True,
+            pad_token_id=tokenizer.eos_token_id)
+
+    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
+    return outputs
+
+
+def run_inference(args):
+    """
+    Run inference on ActivityNet QA DataSet using the Video-ChatGPT model.
+
+    Args:
+        args: Command-line arguments.
+    """
+    # Initialize the model
+    model_name = get_model_name_from_path(args.model_path)
+    tokenizer, model, processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name)
+
+    num_frames = model.config.num_frames if hasattr(model.config, "num_frames") else NUM_FRAMES
+
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    output_list = []  # List to store the output results
+
+    if args.dataset == 'mvbench':
+        val_loader = build_mvbench_eval(args, processor, num_frames)
+    elif args.dataset == 'nextoe':
+        val_loader = build_nextoe_eval(args, processor, num_frames)
+    elif args.dataset == 'nextqa':
+        val_loader = build_nextqa_eval(args, processor, num_frames)
+    elif args.dataset == 'egoschema':
+        val_loader = build_egoschema_eval(args, processor, num_frames)
+    else:
+        raise NotImplementedError(f"Dataset {args.dataset} not implemented.")
+
+    # Iterate over each sample in the ground truth file
+    for i, line in enumerate(tqdm(val_loader)):
+        video_tensor = line['video']
+        questions = line['question']
+
+        outputs = get_model_output(model, video_tensor, tokenizer, questions, args.conv_mode, args.device)
+
+        if args.dataset == 'mvbench':
+            mvbench_dump(ans_file, line, outputs)
+        elif args.dataset == 'nextoe':
+            nextoe_dump(ans_file, line, outputs)
+        elif args.dataset == 'nextqa':
+            nextqa_dump(ans_file, line, outputs)
+        elif args.dataset == 'egoschema':
+            egoschema_dump(ans_file, line, outputs)
+        else:
+            raise NotImplementedError(f"Dataset {args.dataset} not implemented.")
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Multiple-Choice Video QA Evaluation Script.')
+
+    parser.add_argument('--dataset', help='Dataset to evaluate on.', required=True)
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--model_base', help='', default=None, type=str, required=False)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--conv-mode", type=str, default="llava_v1")
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--model_max_length", type=int, required=False, default=2048)
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--num-workers", type=int, default=8)
+    args = parser.parse_args()
+    run_inference(args)

videollama2/eval/run_inference_video_qa_gpt.py

@@ -0,0 +1,151 @@
+import math
+import os
+import argparse
+import json
+import warnings
+from tqdm import tqdm
+
+import torch
+import numpy as np
+import transformers
+import decord
+from decord import VideoReader, cpu
+
+import sys
+sys.path.append('./')
+from videollama2.conversation import conv_templates, SeparatorStyle
+from videollama2.constants import NUM_FRAMES, DEFAULT_MMODAL_TOKEN, DEFAULT_MMODAL_START_TOKEN, DEFAULT_MMODAL_END_TOKEN, MMODAL_TOKEN_INDEX
+from videollama2.mm_utils import get_model_name_from_path, tokenizer_MMODAL_token, KeywordsStoppingCriteria, process_video
+from videollama2.model.builder import load_pretrained_model
+
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+default_mm_token = DEFAULT_MMODAL_TOKEN["VIDEO"]
+default_mm_start_token =  DEFAULT_MMODAL_START_TOKEN["VIDEO"]
+default_mm_end_token = DEFAULT_MMODAL_END_TOKEN["VIDEO"]
+modal_token_index = MMODAL_TOKEN_INDEX["VIDEO"]
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+def get_model_output(model, tokenizer, video_tensor, questions, conv_mode="v1", device='cuda'):
+
+    input_ids = []
+    modal_list = []
+    for qs in questions:
+        if model.config.mm_use_im_start_end:
+            qs = default_mm_start_token + default_mm_token + default_mm_end_token + "\n" + qs
+        else:
+            qs = default_mm_token + "\n" + qs
+
+        conv = conv_templates[conv_mode].copy()
+        conv.append_message(conv.roles[0], qs)
+        conv.append_message(conv.roles[1], None)
+        prompt = conv.get_prompt()
+
+        input_id = tokenizer_MMODAL_token(prompt, tokenizer, modal_token_index, return_tensors='pt')
+        input_ids.append(input_id)
+        modal_list.append("video")
+
+    # left pad sequence
+    input_ids = torch.nn.utils.rnn.pad_sequence(
+        [x.flip(dims=[0]) for x in input_ids],
+        batch_first=True,
+        padding_value=tokenizer.pad_token_id).flip(dims=[1]).to(device)
+
+    attention_mask=input_ids.ne(tokenizer.pad_token_id).to(device)
+
+    video_tensor = video_tensor.half().to(args.device)
+
+    with torch.inference_mode():
+        output_ids = model.generate(
+            input_ids,
+            attention_mask=attention_mask,
+            images_or_videos=video_tensor,
+            modal_list=modal_list,
+            do_sample=False,
+            max_new_tokens=1024,
+            use_cache=True,
+            pad_token_id=tokenizer.eos_token_id)
+
+    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
+    return outputs
+
+
+def run_inference(args):
+    # Initialize the model
+    model_name = get_model_name_from_path(args.model_path)
+    tokenizer, model, processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name)
+
+    num_frames = model.config.num_frames if hasattr(model.config, "num_frames") else NUM_FRAMES
+
+    gt_questions = json.load(open(args.question_file, "r"))
+    gt_questions = get_chunk(gt_questions, args.num_chunks, args.chunk_idx)
+    gt_answers = json.load(open(args.answer_file, "r"))
+    gt_answers = get_chunk(gt_answers, args.num_chunks, args.chunk_idx)
+
+    answer_file = os.path.join(args.output_file)
+    os.makedirs(os.path.dirname(args.output_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    # Iterate over each sample in the ground truth file
+    for idx, sample in enumerate(tqdm(gt_questions)):
+        video_name = sample['video_name']
+        question = sample['question']
+        id = sample['question_id']
+        answer = gt_answers[idx]['answer']
+
+        # Load the video file
+        for fmt in video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"v_{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+            # BUG: compatibility for MSVD, MSRVTT, TGIF
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        # question = question + '\n' + 'Answer the question using a single word or a short phrase with multiple words.'
+
+        video_tensor = process_video(video_path, processor, aspect_ratio=None, sample_scheme='uniform', num_frames=num_frames)
+        output = get_model_output(model, tokenizer, video_tensor[None], [question], args.conv_mode, args.device)[0]
+
+        sample_set = {'id': id, 'question': question, 'answer': answer, 'pred': output}
+        ans_file.write(json.dumps(sample_set) + "\n")
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    # Define the command-line arguments
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--model_base', help='', default=None, type=str, required=False)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument('--output-file', help='Directory to save the model results JSON.', required=True)
+    parser.add_argument("--conv-mode", type=str, default="llava_v1")
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--model_max_length", type=int, required=False, default=2048)
+
+    args = parser.parse_args()
+    run_inference(args)

videollama2/eval/run_inference_video_qa_gpt_consistency.py

@@ -0,0 +1,182 @@
+import os
+import re
+import math
+import json
+import argparse
+import warnings
+from tqdm import tqdm
+
+import torch
+import decord
+import numpy as np
+import transformers
+from decord import VideoReader, cpu
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2.conversation import conv_templates, SeparatorStyle
+from videollama2.constants import NUM_FRAMES, DEFAULT_MMODAL_TOKEN, DEFAULT_MMODAL_START_TOKEN, DEFAULT_MMODAL_END_TOKEN, MMODAL_TOKEN_INDEX
+from videollama2.mm_utils import get_model_name_from_path, tokenizer_MMODAL_token, KeywordsStoppingCriteria, process_video
+from videollama2.model.builder import load_pretrained_model
+
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+default_mm_token = DEFAULT_MMODAL_TOKEN["VIDEO"]
+default_mm_start_token =  DEFAULT_MMODAL_START_TOKEN["VIDEO"]
+default_mm_end_token = DEFAULT_MMODAL_END_TOKEN["VIDEO"]
+modal_token_index = MMODAL_TOKEN_INDEX["VIDEO"]
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class VCGPTDataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_list, processor, num_frames):
+        self.data_list = data_list
+        self.processor = processor
+        self.num_frames = num_frames
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        question1 = line['Q1']
+        question2 = line['Q2']
+        answer = line['A']
+        video_name = line['video_name']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        video_tensor = process_video(video_path, self.processor, aspect_ratio=None, sample_scheme='uniform', num_frames=self.num_frames)
+
+        return {
+            'video': video_tensor,
+            'video_name': video_name,
+            'question1': question1,
+            'question2': question2,
+            'answer': answer,
+        }
+
+
+def collate_fn(batch):
+    vid = [x['video'] for x in batch]
+    v_id = [x['video_name'] for x in batch]
+    qus1 = [x['question1'] for x in batch]
+    qus2 = [x['question2'] for x in batch]
+    ans = [x['answer'] for x in batch]
+    vid = torch.stack(vid, dim=0)
+    return vid, v_id, qus1, qus2, ans
+
+
+def get_model_output(model, tokenizer, qs, video_tensor, args):
+    if model.config.mm_use_im_start_end:
+        qs = default_mm_start_token + default_mm_token + default_mm_end_token + "\n" + qs
+    else:
+        qs = default_mm_token + "\n" + qs
+
+    conv = conv_templates[args.conv_mode].copy()
+    conv.append_message(conv.roles[0], qs)
+    conv.append_message(conv.roles[1], None)
+    prompt = conv.get_prompt()
+
+    # input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(args.device)
+    input_ids = tokenizer_MMODAL_token(prompt, tokenizer, modal_token_index, return_tensors='pt').to(args.device)
+
+    attention_mask=input_ids.ne(tokenizer.pad_token_id).to(args.device)
+
+    modal_list = ["video"]
+    video_tensor = video_tensor.to(dtype=torch.float16, device=args.device, non_blocking=True)
+
+    with torch.inference_mode():
+        output_ids = model.generate(
+            input_ids.unsqueeze(0),
+            attention_mask=attention_mask.unsqueeze(0),
+            images_or_videos=[video_tensor],
+            modal_list=modal_list,
+            do_sample=False,
+            max_new_tokens=1024,
+            use_cache=True,
+            pad_token_id=tokenizer.eos_token_id)
+
+    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+    return outputs
+
+
+def run_inference(args):
+    model_name = get_model_name_from_path(args.model_path)
+    tokenizer, model, processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name)
+
+    num_frames = model.config.num_frames if hasattr(model.config, "num_frames") else NUM_FRAMES
+
+    questions = json.load(open(args.question_file, "r"))
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+
+    assert args.batch_size == 1, "Batch size must be 1 for inference"
+    dataset = VCGPTDataset(questions, processor, num_frames)
+    dataloader = DataLoader(dataset, shuffle=False, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn)
+
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    output_list = []  # List to store the output results
+
+    # Iterate over each sample in the ground truth file
+    for i, (video_tensors, video_names, questions1, questions2, answers) in enumerate(tqdm(dataloader)):
+
+        # reduce batch dimension
+        video_tensor = video_tensors[0]
+        video_name = video_names[0]
+        question1 = questions1[0]
+        question2 = questions2[0]
+        answer = answers[0]
+
+        output1 = get_model_output(model, tokenizer, question1, video_tensor, args)
+        output2 = get_model_output(model, tokenizer, question2, video_tensor, args)
+
+        qa = {'video_name': video_name, 'Q1': question1, 'Q2': question2, 'A': answer, 'P1': output1, 'P2': output2}
+
+        ans_file.write(json.dumps(qa) + "\n")
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    # Define the command-line arguments
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--model_base', help='', default=None, type=str, required=False)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--conv-mode", type=str, default="llava_v1")
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--model_max_length", type=int, required=False, default=2048)
+    parser.add_argument("--batch-size", type=int, required=False, default=1)
+    parser.add_argument("--num-workers", type=int, required=False, default=8)
+
+    args = parser.parse_args()
+
+    run_inference(args)

videollama2/eval/run_inference_video_qa_gpt_general.py

@@ -0,0 +1,177 @@
+import os
+import re
+import math
+import json
+import argparse
+import warnings
+from tqdm import tqdm
+
+import torch
+import decord
+import numpy as np
+import transformers
+from decord import VideoReader, cpu
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2.conversation import conv_templates, SeparatorStyle
+from videollama2.constants import NUM_FRAMES, DEFAULT_MMODAL_TOKEN, DEFAULT_MMODAL_START_TOKEN, DEFAULT_MMODAL_END_TOKEN, MMODAL_TOKEN_INDEX
+from videollama2.mm_utils import get_model_name_from_path, tokenizer_MMODAL_token, KeywordsStoppingCriteria, process_video
+from videollama2.model.builder import load_pretrained_model
+
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+default_mm_token = DEFAULT_MMODAL_TOKEN["VIDEO"]
+default_mm_start_token =  DEFAULT_MMODAL_START_TOKEN["VIDEO"]
+default_mm_end_token = DEFAULT_MMODAL_END_TOKEN["VIDEO"]
+modal_token_index = MMODAL_TOKEN_INDEX["VIDEO"]
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class VCGPTDataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_list, processor, num_frames):
+        self.data_list = data_list
+        self.processor = processor
+        self.num_frames = num_frames
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        question = line['Q']
+        answer = line['A']
+        video_name = line['video_name']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        video_tensor = process_video(video_path, self.processor, aspect_ratio=None, sample_scheme='uniform', num_frames=self.num_frames)
+
+        return {
+            'video': video_tensor,
+            'video_name': video_name,
+            'question': question,
+            'answer': answer,
+        }
+
+
+def collate_fn(batch):
+    vid = [x['video'] for x in batch]
+    v_id = [x['video_name'] for x in batch]
+    qus = [x['question'] for x in batch]
+    ans = [x['answer'] for x in batch]
+    vid = torch.stack(vid, dim=0)
+    return vid, v_id, qus, ans
+
+
+def get_model_output(model, tokenizer, qs, video_tensor, args):
+    if model.config.mm_use_im_start_end:
+        qs = default_mm_start_token + default_mm_token + default_mm_end_token + "\n" + qs
+    else:
+        qs = default_mm_token + "\n" + qs
+
+    conv = conv_templates[args.conv_mode].copy()
+    conv.append_message(conv.roles[0], qs)
+    conv.append_message(conv.roles[1], None)
+    prompt = conv.get_prompt()
+
+    # input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(args.device)
+    input_ids = tokenizer_MMODAL_token(prompt, tokenizer, modal_token_index, return_tensors='pt').to(args.device)
+
+    attention_mask=input_ids.ne(tokenizer.pad_token_id).to(args.device)
+
+    modal_list = ["video"]
+    video_tensor = video_tensor.to(dtype=torch.float16, device=args.device, non_blocking=True)
+
+    with torch.inference_mode():
+        output_ids = model.generate(
+            input_ids.unsqueeze(0),
+            attention_mask=attention_mask.unsqueeze(0),
+            images_or_videos=[video_tensor],
+            modal_list=modal_list,
+            do_sample=False,
+            max_new_tokens=1024,
+            use_cache=True,
+            pad_token_id=tokenizer.eos_token_id)
+
+    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+    return outputs
+
+
+def run_inference(args):
+    model_name = get_model_name_from_path(args.model_path)
+    tokenizer, model, processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name)
+
+    num_frames = model.config.num_frames if hasattr(model.config, "num_frames") else NUM_FRAMES
+
+    questions = json.load(open(args.question_file, "r"))
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+
+    assert args.batch_size == 1, "Batch size must be 1 for inference"
+    dataset = VCGPTDataset(questions, processor, num_frames)
+    dataloader = DataLoader(dataset, shuffle=False, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn)
+
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    output_list = []  # List to store the output results
+
+    # Iterate over each sample in the ground truth file
+    for i, (video_tensors, video_names, questions, answers) in enumerate(tqdm(dataloader)):
+
+        # reduce batch dimension
+        video_tensor = video_tensors[0]
+        video_name = video_names[0]
+        question = questions[0]
+        answer = answers[0]
+
+        output = get_model_output(model, tokenizer, question, video_tensor, args)
+
+        qa = {'video_name': video_name, 'Q': question, 'A': answer, 'P': output}
+
+        ans_file.write(json.dumps(qa) + "\n")
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    # Define the command-line arguments
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--model_base', help='', default=None, type=str, required=False)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--conv-mode", type=str, default="llava_v1")
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--model_max_length", type=int, required=False, default=2048)
+    parser.add_argument("--batch-size", type=int, required=False, default=1)
+    parser.add_argument("--num-workers", type=int, required=False, default=8)
+
+    args = parser.parse_args()
+
+    run_inference(args)

videollama2/eval/run_inference_video_qa_perception_test_mcqa.py

@@ -0,0 +1,214 @@
+import os
+import re
+import math
+import json
+import argparse
+import warnings
+from tqdm import tqdm
+
+import torch
+import decord
+import numpy as np
+import transformers
+from decord import VideoReader, cpu
+from torch.utils.data import Dataset, DataLoader
+
+import sys
+sys.path.append('./')
+from videollama2.conversation import conv_templates, SeparatorStyle
+from videollama2.constants import NUM_FRAMES, DEFAULT_MMODAL_TOKEN, DEFAULT_MMODAL_START_TOKEN, DEFAULT_MMODAL_END_TOKEN, MMODAL_TOKEN_INDEX
+from videollama2.mm_utils import get_model_name_from_path, tokenizer_MMODAL_token, KeywordsStoppingCriteria, process_videos
+from videollama2.model.builder import load_pretrained_model
+
+
+# NOTE: Ignore TypedStorage warning, which refers to this link~(https://github.com/pytorch/pytorch/issues/97207#issuecomment-1494781560)
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+default_mm_token = DEFAULT_MMODAL_TOKEN["VIDEO"]
+default_mm_start_token =  DEFAULT_MMODAL_START_TOKEN["VIDEO"]
+default_mm_end_token = DEFAULT_MMODAL_END_TOKEN["VIDEO"]
+modal_token_index = MMODAL_TOKEN_INDEX["VIDEO"]
+
+
+def split_list(lst, n):
+    """Split a list into n (roughly) equal-sized chunks"""
+    chunk_size = math.ceil(len(lst) / n)  # integer division
+    return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)]
+
+
+def get_chunk(lst, n, k):
+    chunks = split_list(lst, n)
+    return chunks[k]
+
+
+class PerceptionTestMCQADataset(Dataset):
+
+    video_formats = ['.mp4', '.avi', '.mov', '.mkv']
+
+    def __init__(self, data_list, processor, num_segments=8):
+        self.data_list = data_list
+        self.processor = processor
+        self.num_segments = num_segments
+
+    def __len__(self):
+        return len(self.data_list)
+    
+    def __getitem__(self, idx):
+        line = self.data_list[idx]
+        video_name = line['metadata']['video_id']
+        mc_questions = line['mc_question']
+
+        for fmt in self.video_formats:  # Added this line
+            temp_path = os.path.join(args.video_folder, f"{video_name}{fmt}")
+            if os.path.exists(temp_path):
+                video_path = temp_path
+                break
+
+        decord_vr = VideoReader(uri=video_path, ctx=cpu(0))
+        frames = decord_vr.get_batch(np.linspace(0, len(decord_vr) - 1, self.num_segments, dtype=int)).asnumpy()
+        video_tensor = self.processor.preprocess(frames, return_tensors='pt')['pixel_values']  # do not pad for video frames
+
+        qs = []
+        qids = []
+        ops = []
+        for q in mc_questions:
+            question = q['question']
+            qid = q['id']
+            options = q['options']
+            option_question = f'Question: {question}\nOptions:\n(A) {options[0]}\n(B) {options[1]}\n(C) {options[2]}\nAnswer with the option\'s letter from the given choices directly and only give the best option.'
+
+            qs.append(option_question)
+            qids.append(qid)
+            ops.append(options)
+
+        return {
+            'video': video_tensor,
+            'video_id': video_name,
+            'questions': qs,
+            'question_ids': qids,
+            'options': ops,
+        }
+
+
+def collate_fn(batch):
+    vid = [x['video'] for x in batch]
+    v_id = [x['video_id'] for x in batch]
+    qs = [x['questions'] for x in batch]
+    q_ids = [x['question_ids'] for x in batch]
+    ops = [x['options'] for x in batch]
+    vid = torch.stack(vid, dim=0)
+    return vid, v_id, qs, q_ids, ops
+
+
+def get_model_output(model, tokenizer, qs, video_tensor, args):
+    if model.config.mm_use_im_start_end:
+        qs = default_mm_start_token + default_mm_token + default_mm_end_token + "\n" + qs
+    else:
+        qs = default_mm_token + "\n" + qs
+
+    conv = conv_templates[args.conv_mode].copy()
+    conv.append_message(conv.roles[0], qs)
+    conv.append_message(conv.roles[1], None)
+    prompt = conv.get_prompt()
+
+    # input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(args.device)
+    input_ids = tokenizer_MMODAL_token(prompt, tokenizer, modal_token_index, return_tensors='pt').to(args.device)
+
+    attention_mask=input_ids.ne(tokenizer.pad_token_id).to(args.device)
+
+    modal_list = ["video"]
+    video_tensor = video_tensor.to(dtype=torch.float16, device=args.device, non_blocking=True)
+
+    with torch.inference_mode():
+        output_ids = model.generate(
+            input_ids.unsqueeze(0),
+            attention_mask=attention_mask.unsqueeze(0),
+            images_or_videos=[video_tensor],
+            modal_list=modal_list,
+            do_sample=False,
+            max_new_tokens=1024,
+            use_cache=True,
+            pad_token_id=tokenizer.eos_token_id)
+
+    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+    return outputs
+
+
+def run_inference(args):
+    # Initialize the model
+    model_name = get_model_name_from_path(args.model_path)
+    tokenizer, model, processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name)
+
+    questions = json.load(open(args.question_file, "r"))
+    questions = list(questions.values())
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+
+    num_frames = model.config.num_frames if hasattr(model.config, "num_frames") else NUM_FRAMES
+
+    assert args.batch_size == 1, "Batch size must be 1 for inference"
+    dataset = PerceptionTestMCQADataset(questions, processor, num_frames)
+    dataloader = DataLoader(dataset, shuffle=False, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_fn)
+
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "w")
+
+    output_list = []  # List to store the output results
+
+    # Iterate over each sample in the ground truth file
+    for i, (video_tensor, video_id, questions, question_ids, options) in enumerate(tqdm(dataloader)):
+
+        # reduce batch dimension
+        video_tensor = video_tensor[0]
+        video_id = video_id[0]
+        questions = questions[0]
+        question_ids = question_ids[0]
+        options = options[0]
+
+        qas = []
+        for idx, question in enumerate(questions):
+            letters = ['(A)', '(B)', '(C)']
+            question_id = question_ids[idx]
+            _options = options[idx]
+
+            output = get_model_output(model, tokenizer, question, video_tensor, args)
+            pred_answer = re.findall('\(*[A-C]\)*', output)
+            if len(pred_answer) == 0:
+                tmp_options = [x.lower() for x in _options]
+                if output.lower() in tmp_options:
+                    tmp_options = [x.lower() for x in _options]
+                    pred_idx = tmp_options.index(output.lower())
+                else:
+                    pred_idx = 2
+            else:
+                pred_answer = pred_answer[0].strip()
+                if not pred_answer.startswith('('):
+                    pred_answer = f'({pred_answer})'
+                pred_idx = letters.index(pred_answer)
+
+            qas.append({'id': question_id, 'answer_id': pred_idx, 'answer': _options[pred_idx]})
+
+        ans_file.write('\"{}\": {},\n'.format(video_id, json.dumps(qas)))
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    # Define the command-line arguments
+    parser.add_argument('--model-path', help='', required=True)
+    parser.add_argument('--model_base', help='', default=None, type=str, required=False)
+    parser.add_argument('--video-folder', help='Directory containing video files.', required=True)
+    parser.add_argument('--question-file', help='Path to the ground truth file containing question.', required=True)
+    parser.add_argument('--answer-file', help='Path to the ground truth file containing answers.', required=True)
+    parser.add_argument("--conv-mode", type=str, default="llava_v1")
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--device", type=str, required=False, default='cuda:0')
+    parser.add_argument("--model_max_length", type=int, required=False, default=2048)
+    parser.add_argument("--batch-size", type=int, required=False, default=1)
+    parser.add_argument("--num-workers", type=int, required=False, default=8)
+    args = parser.parse_args()
+
+    run_inference(args)

videollama2/mm_utils.py

@@ -0,0 +1,535 @@
+import ast
+import math
+import base64
+from io import BytesIO
+
+import torch
+import decord
+import imageio
+import numpy as np
+from PIL import Image
+from decord import VideoReader, cpu
+from moviepy.editor import VideoFileClip
+from transformers import StoppingCriteria
+
+from scenedetect import open_video, SceneManager
+from scenedetect.detectors import ContentDetector
+from scenedetect.stats_manager import StatsManager
+
+from .constants import NUM_FRAMES, MAX_FRAMES, NUM_FRAMES_PER_SECOND, MMODAL_INDEX_TOKEN, IMAGE_TOKEN_INDEX
+
+
+def merge_scenes(cut_list, cut_scores, scene_list,num_frames,max_scene_num=4, num_frame_per_scene=8, min_frames_per_scene=30):
+    if len(scene_list) == len(cut_list) and len(scene_list) == 0:
+        frame_ids = np.linspace(0, num_frames-1, num_frame_per_scene, dtype=int)  # only one scene for current video
+        return [frame_ids]
+
+    scene_list, cut_results = merge_scenes_not_exeed_max_scene_num(cut_list,cut_scores,scene_list, max_scene_num)
+
+    prev_cut_point = 0
+    list_of_scene_frames = [] 
+    for (cur_cut_point, _) in cut_results:
+        frame_ids = list(np.linspace(prev_cut_point, cur_cut_point-1, num_frame_per_scene, dtype=int))
+        list_of_scene_frames.append(frame_ids)
+        prev_cut_point = cur_cut_point
+    if cur_cut_point < num_frames:
+        frame_ids = np.linspace(cur_cut_point, num_frames-1, num_frame_per_scene, dtype=int)
+        list_of_scene_frames.append(frame_ids)
+
+    return list_of_scene_frames
+
+
+def merge_scenes_not_exeed_max_scene_num(cut_list,cut_scores, scene_list, max_scene_num):
+    cut_frames = [ele.get_frames() for ele in cut_list]
+    cut_results = list(zip(cut_frames, cut_scores))
+    while len(scene_list) > max_scene_num:
+        min_idx = np.argmin(cut_scores)
+        cut_frames = [ele for idx, ele in enumerate(cut_frames) if idx != min_idx]
+        cut_scores = [ele for idx, ele in enumerate(cut_scores) if idx != min_idx]
+
+        # merge scene list
+        num_scenes = len(scene_list)
+        #print("Current min_idx:", min_idx)
+        s1 = scene_list[min_idx]
+        s2 = scene_list[min_idx+1]
+        new_scene = (s1[0], s2[1])
+        if min_idx == 0:
+            # merge the first two scenes
+            new_scene_list = [new_scene] + scene_list[2:]
+        elif min_idx == num_scenes - 1:
+            # # merge the last two scenes
+            new_scene_list = scene_list[:min_idx-1] + [new_scene]
+        else:
+            new_scene_list = scene_list[:min_idx] + [new_scene] + scene_list[min_idx+2:]
+        scene_list = new_scene_list
+        cut_results = list(zip(cut_frames, cut_scores))
+    return scene_list, cut_results
+
+
+def split_video_into_scenes(video_path, threshold=27.0, max_scene_num=10, num_frame_per_scene=8):
+    # Open video, create a scene manager, and add a detector.
+    video = open_video(video_path)
+    stats_manager = StatsManager()
+    scene_manager = SceneManager(stats_manager)
+    detector = ContentDetector(threshold=threshold)
+    scene_manager.add_detector(detector)
+    scene_manager.detect_scenes(video)
+    scene_list = scene_manager.get_scene_list()
+    cut_list = scene_manager.get_cut_list()
+    num_frames = video.duration.get_frames()
+    if len(scene_list) == len(cut_list) and len(scene_list) == 0:
+        frame_ids = np.linspace(0, num_frames-1, num_frame_per_scene, dtype=int)  # only one scene for current video
+        return [frame_ids]
+    assert len(scene_list) == len(cut_list) + 1, f"inconsistent lengths for scene list ({len(scene_list)}) vs. cut list ({len(cut_list)})"
+    cut_frames = [ele.get_frames() for ele in cut_list]
+    cut_scores = [stats_manager.get_metrics(f, ["delta_lum"])[0] for f in cut_frames]
+    cut_results = list(zip(cut_frames, cut_scores))
+    #print(f"Original cut scores: {cut_scores}, original scene list: {scene_list}")
+    while len(scene_list) > max_scene_num:
+        min_idx = np.argmin(cut_scores)
+        cut_frames = [ele for idx, ele in enumerate(cut_frames) if idx != min_idx]
+        cut_scores = [ele for idx, ele in enumerate(cut_scores) if idx != min_idx]
+
+        # merge scene list
+        num_scenes = len(scene_list)
+        #print("Current min_idx:", min_idx)
+        s1 = scene_list[min_idx]
+        s2 = scene_list[min_idx+1]
+        new_scene = (s1[0], s2[1])
+        if min_idx == 0:
+            # merge the first two scenes
+            new_scene_list = [new_scene] + scene_list[2:]
+        elif min_idx == num_scenes - 1:
+            # # merge the last two scenes
+            new_scene_list = scene_list[:min_idx-1] + [new_scene]
+        else:
+            new_scene_list = scene_list[:min_idx] + [new_scene] + scene_list[min_idx+2:]
+        scene_list = new_scene_list
+        cut_results = list(zip(cut_frames, cut_scores))
+    #print(f"Cut scores after merging: {cut_scores}, scene list: {scene_list}")
+    prev_cut_point = 0
+    list_of_scene_frames = [] 
+    for (cur_cut_point, _) in cut_results:
+        frame_ids = list(np.linspace(prev_cut_point, cur_cut_point-1, num_frame_per_scene, dtype=int))
+        list_of_scene_frames.append(frame_ids)
+        prev_cut_point = cur_cut_point
+    if cur_cut_point < num_frames:
+        frame_ids = np.linspace(cur_cut_point, num_frames-1, num_frame_per_scene, dtype=int)
+        list_of_scene_frames.append(frame_ids)
+    # print(f"Finally got {len(list_of_scene_frames)} scenes where we evenly sampled {num_frame_per_scene} frames for each scene")
+    return list_of_scene_frames
+
+
+def select_best_resolution(original_size, possible_resolutions):
+    """
+    Selects the best resolution from a list of possible resolutions based on the original size.
+    Args:
+        original_size (tuple): The original size of the image in the format (width, height).
+        possible_resolutions (list): A list of possible resolutions in the format [(width1, height1), (width2, height2), ...].
+    Returns:
+        tuple: The best fit resolution in the format (width, height).
+    """
+    original_width, original_height = original_size
+    best_fit = None
+    max_effective_resolution = 0
+    min_wasted_resolution = float('inf')
+    for width, height in possible_resolutions:
+        scale = min(width / original_width, height / original_height)
+        downscaled_width, downscaled_height = int(original_width * scale), int(original_height * scale)
+        effective_resolution = min(downscaled_width * downscaled_height, original_width * original_height)
+        wasted_resolution = (width * height) - effective_resolution
+        if effective_resolution > max_effective_resolution or (effective_resolution == max_effective_resolution and wasted_resolution < min_wasted_resolution):
+            max_effective_resolution = effective_resolution
+            min_wasted_resolution = wasted_resolution
+            best_fit = (width, height)
+    return best_fit
+
+
+def resize_and_pad_image(image, target_resolution):
+    """
+    Resize and pad an image to a target resolution while maintaining aspect ratio.
+    Args:
+        image (PIL.Image.Image): The input image.
+        target_resolution (tuple): The target resolution (width, height) of the image.
+    Returns:
+        PIL.Image.Image: The resized and padded image.
+    """
+    original_width, original_height = image.size
+    target_width, target_height = target_resolution
+    scale_w = target_width / original_width
+    scale_h = target_height / original_height
+    if scale_w < scale_h:
+        new_width = target_width
+        new_height = min(math.ceil(original_height * scale_w), target_height)
+    else:
+        new_height = target_height
+        new_width = min(math.ceil(original_width * scale_h), target_width)
+    # Resize the image
+    resized_image = image.resize((new_width, new_height))
+    new_image = Image.new('RGB', (target_width, target_height), (0, 0, 0))
+    paste_x = (target_width - new_width) // 2
+    paste_y = (target_height - new_height) // 2
+    new_image.paste(resized_image, (paste_x, paste_y))
+    return new_image
+
+
+def divide_to_patches(image, patch_size):
+    """
+    Divides an image into patches of a specified size.
+    Args:
+        image (PIL.Image.Image): The input image.
+        patch_size (int): The size of each patch.
+    Returns:
+        list: A list of PIL.Image.Image objects representing the patches.
+    """
+    patches = []
+    width, height = image.size
+    for i in range(0, height, patch_size):
+        for j in range(0, width, patch_size):
+            box = (j, i, j + patch_size, i + patch_size)
+            patch = image.crop(box)
+            patches.append(patch)
+    return patches
+
+
+def get_anyres_image_grid_shape(image_size, grids, patch_size):
+    """
+    Calculate the shape of the image patch grid after the preprocessing for images of any resolution.
+    Args:
+        image_size (tuple): The size of the input image in the format (width, height).
+        grids (str, List[tuple[int]]): Patch segmentation grid.
+        patch_size (int): The size of each image patch.
+    Returns:
+        tuple: The shape of the image patch grid in the format (width, height).
+    """
+    if type(grids) is list:
+        possible_resolutions = [(x * patch_size, y * patch_size) for x, y in grids]
+    else:
+        possible_resolutions = [(x * patch_size, y * patch_size) for x, y in ast.literal_eval(grids)]
+    width, height = select_best_resolution(image_size, possible_resolutions)
+    return width // patch_size, height // patch_size
+
+
+def process_anyres_image(image, grids, patch_size):
+    """
+    Process an image with variable resolutions.
+    Args:
+        image (PIL.Image.Image): The input image to be processed.
+        grids (str, List[tuple[int]]): Patch segmentation grid.
+        patch_size (int): The size of the patches to be extracted.
+    Returns:
+        torch.Tensor: A tensor containing the processed image patches.
+    """
+    if type(grids) is list:
+        possible_resolutions = [(x * patch_size, y * patch_size) for x, y in grids]
+    else:
+        possible_resolutions = [(x * patch_size, y * patch_size) for x, y in ast.literal_eval(grids)]
+    best_resolution = select_best_resolution(image.size, possible_resolutions)
+    image_padded = resize_and_pad_image(image, best_resolution)
+    patches = divide_to_patches(image_padded, patch_size)
+    image_original_resize = resize_and_pad_image(image, (patch_size, patch_size))
+    image_patches = [image_original_resize] + patches
+    return image_patches
+
+
+def chunk_list(input_list, chunk_size):
+    return [input_list[i:i + chunk_size] for i in range(0, len(input_list), chunk_size)]
+
+
+def frame_expansion(frame_list, n):
+    assert len(frame_list) == n * n
+    width, height = frame_list[0].width, frame_list[0].height
+    expanded_width = n * width
+    expanded_height = n * height
+    expanded_frame = Image.new('RGB', (expanded_width, expanded_height))
+    for i in range(n):
+        for j in range(n):
+            frame = frame_list[i * n + j]
+            coordinate = (j*width, i*height)
+            expanded_frame.paste(frame, coordinate)
+    return expanded_frame
+
+
+def load_image_from_base64(image):
+    return Image.open(BytesIO(base64.b64decode(image)))
+
+
+def expand2square(pil_img, background_color):
+    width, height = pil_img.size
+    if width == height:
+        return pil_img
+    elif width > height:
+        result = Image.new(pil_img.mode, (width, width), background_color)
+        result.paste(pil_img, (0, (width - height) // 2))
+        return result
+    else:
+        result = Image.new(pil_img.mode, (height, height), background_color)
+        result.paste(pil_img, ((height - width) // 2, 0))
+        return result
+
+
+def process_images(images, image_processor, model_cfg):
+    image_aspect_ratio = getattr(model_cfg, "image_aspect_ratio", None)
+    new_images = []
+    #print("Current image_aspect_ratio:", image_aspect_ratio)
+    if image_aspect_ratio == 'pad':
+        for image in images:
+            image = expand2square(image, tuple(int(x*255) for x in image_processor.image_mean))
+            image = image_processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
+            new_images.append(image)
+    else:
+        return image_processor(images, return_tensors='pt')['pixel_values']
+    if all(x.shape == new_images[0].shape for x in new_images):
+        new_images = torch.stack(new_images, dim=0)
+    return new_images
+
+
+def process_videos(frames, image_processor, model_cfg):
+    # this function only used during inference
+    # image_aspect_ratio = getattr(model_cfg, "image_aspect_ratio", None)
+    # new_frames = []
+    # print("Current image_aspect_ratio:", image_aspect_ratio)
+    # if image_aspect_ratio == 'pad':
+    #     for image in frames:
+    #         image = Image.fromarray(image)
+    #         image = expand2square(image, tuple(int(x*255) for x in image_processor.image_mean))
+    #         image = image_processor.preprocess(image, return_tensors='pt')['pixel_values'][0]
+    #         new_frames.append(image)
+    # else:
+    #     return image_processor(frames, return_tensors='pt')['pixel_values']
+    # if all(x.shape == new_frames[0].shape for x in new_frames):
+    #     new_frames = torch.stack(new_frames, dim=0)
+    new_frames = image_processor.preprocess(frames, return_tensors='pt')['pixel_values']  # do not pad for video frames
+    return new_frames
+
+
+def create_photo_grid(arr, rows=None, cols=None):
+    """
+    Create a photo grid from a 4D numpy array with shape [t, h, w, c].
+
+    Parameters:
+        arr (numpy.ndarray): Input array with shape [t, h, w, c].
+        rows (int): Optional. Number of rows in the grid. If not set, it will be determined based on `cols` or the square root of `t`.
+        cols (int): Optional. Number of columns in the grid. If not set, it will be determined based on `rows` or the square root of `t`.
+
+    Returns:
+        numpy.ndarray: A 3D numpy array representing the photo grid.
+    """
+
+    if isinstance(arr, list):
+        if isinstance(arr[0], Image.Image):
+            arr = np.stack([np.array(img) for img in arr])
+        elif isinstance(arr[0], np.ndarray):
+            arr = np.stack(arr)
+        else:
+            raise ValueError("Invalid input type. Expected list of Images or numpy arrays.")
+
+    t, h, w, c = arr.shape
+    
+    # Calculate the number of rows and columns if not provided
+    if rows is None and cols is None:
+        rows = math.ceil(math.sqrt(t))
+        cols = math.ceil(t / rows)
+    elif rows is None:
+        rows = math.ceil(t / cols)
+    elif cols is None:
+        cols = math.ceil(t / rows)
+
+    # Check if the grid can hold all the images
+    if rows * cols < t:
+        raise ValueError(f"Not enough grid cells ({rows}x{cols}) to hold all images ({t}).")
+    
+    # Create the grid array with appropriate height and width
+    grid_height = h * rows
+    grid_width = w * cols
+    grid = np.zeros((grid_height, grid_width, c), dtype=arr.dtype)
+    
+    # Fill the grid with images
+    for i in range(t):
+        row_idx = i // cols
+        col_idx = i % cols
+        grid[row_idx*h:(row_idx+1)*h, col_idx*w:(col_idx+1)*w, :] = arr[i]
+    
+    return grid
+
+
+def process_image(image_path, processor, aspect_ratio='pad', num_frames=NUM_FRAMES, image_grid=False):
+    image = Image.open(image_path).convert('RGB')
+
+    if image_grid:
+        pg = np.stack([np.array(image)] * num_frames)
+        grid_h = grid_w = math.ceil(math.sqrt(num_frames))
+        pg = create_photo_grid(pg, grid_h, grid_w)
+        images = [pg, np.array(image)]
+    else:
+        images = [np.array(image)]
+
+    if aspect_ratio == 'pad':
+        images = [Image.fromarray(f) for f in images]
+        images = [expand2square(image, tuple(int(x*255) for x in processor.image_mean)) for image in images]
+    else:
+        images = [Image.fromarray(f) for f in images]
+
+    images = processor.preprocess(images, return_tensors='pt')['pixel_values']
+    return images
+
+
+def process_video(video_path, processor, aspect_ratio='pad', num_frames=NUM_FRAMES, image_grid=False, sample_scheme='uniform'):
+    def frame_sample(duration, mode='uniform', local_fps=None):
+        if mode == 'uniform':
+            return np.linspace(0, duration-1, num_frames, dtype=int)
+        elif mode == 'fps':
+            assert local_fps is not None
+            segment_len = min(local_fps // NUM_FRAMES_PER_SECOND, duration)
+            return np.arange(segment_len // 2, duration, segment_len, dtype=int)
+        else:
+            raise ImportError(f'Unsupported frame sampling mode: {mode}')
+
+    if isinstance(video_path, str):
+        if video_path.endswith('.gif'):
+            video_gif = imageio.get_reader(video_path)
+            duration, local_fps = len(video_gif), 10
+
+            frame_id_list = frame_sample(duration, mode=sample_scheme, local_fps=local_fps)
+            # limit the max input frames
+            if len(frame_id_list) > MAX_FRAMES:
+                frame_id_list = np.linspace(0, duration-1, MAX_FRAMES, dtype=int)
+            video_data = [frame for index, frame in enumerate(video_gif) if index in frame_id_list]
+        # added by lixin4ever, include the support of .webm files from sthsthv2
+        elif video_path.endswith('.webm'):
+            video_webm = VideoFileClip(video_path)
+            video_frames = np.array(list(video_webm.iter_frames()))
+
+            duration, local_fps = len(video_frames), video_webm.fps
+
+            frame_id_list = frame_sample(duration, mode=sample_scheme, local_fps=local_fps)
+            # limit the max input frames
+            if len(frame_id_list) > MAX_FRAMES:
+                frame_id_list = np.linspace(0, duration-1, MAX_FRAMES, dtype=int)
+            video_data = video_frames[frame_id_list]
+        else:
+            decord_vr = VideoReader(uri=video_path, ctx=cpu(0)) if "Valley/finetune/source_videos" not in video_path else VideoReader(uri=video_path, ctx=cpu(0), num_threads=1)  # add num_threads=1 for Valley videos
+            duration, local_fps = len(decord_vr), float(decord_vr.get_avg_fps())
+        
+            frame_id_list = frame_sample(duration, mode=sample_scheme, local_fps=local_fps)
+            # limit the max input frames
+            if len(frame_id_list) > MAX_FRAMES:
+                frame_id_list = np.linspace(0, duration-1, MAX_FRAMES, dtype=int)
+            try:
+                video_data = decord_vr.get_batch(frame_id_list).numpy()
+            except:
+                video_data = decord_vr.get_batch(frame_id_list).asnumpy()
+
+            # if self.data_args.use_temp_aug:
+            #     frame_id_list = np.linspace(0, duration-1, num_frames * 2 * 2, dtype=int)
+            #     video_data = decord_vr.get_batch(frame_id_list)
+            #     video_frames = [Image.fromarray(f) for f in video_data.numpy()]
+            #     chunked_video_frames = chunk_list(video_frames, 2*2)
+            #     video_data = [frame_expansion(frame_list, 2) for frame_list in chunked_video_frames]
+    else:
+        video = video_path
+        frame_id_list = frame_sample(duration, mode='uniform')
+        video_data = [video.get_data(frame_id) for frame_id in frame_id_list]
+
+    if image_grid:
+        grid_h = grid_w = math.ceil(math.sqrt(num_frames))
+        pg = create_photo_grid(video_data, grid_h, grid_w)
+        video_data = [pg, *video_data]
+
+    if aspect_ratio == 'pad':
+        images = [Image.fromarray(f.numpy() if isinstance(f, torch.Tensor) else f) for f in video_data]
+        images = [expand2square(image, tuple(int(x*255) for x in processor.image_mean)) for image in images]
+        video = processor.preprocess(images, return_tensors='pt')['pixel_values']
+    else:
+        images = [Image.fromarray(f.numpy() if isinstance(f, torch.Tensor) else f) for f in video_data]
+        video = processor.preprocess(images, return_tensors='pt')['pixel_values']
+
+    return video
+
+
+def tokenizer_image_token(prompt, tokenizer, image_token_index=IMAGE_TOKEN_INDEX, return_tensors=None):
+    prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split('<image>')]
+
+    def insert_separator(X, sep):
+        return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
+
+    input_ids = []
+    offset = 0
+    if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
+        offset = 1
+        input_ids.append(prompt_chunks[0][0])
+
+    for x in insert_separator(prompt_chunks, [image_token_index] * (offset + 1)):
+        input_ids.extend(x[offset:])
+
+    if return_tensors is not None:
+        if return_tensors == 'pt':
+            return torch.tensor(input_ids, dtype=torch.long)
+        raise ValueError(f'Unsupported tensor type: {return_tensors}')
+    return input_ids
+
+
+def tokenizer_MMODAL_token(prompt, tokenizer, MMODAL_token_index=IMAGE_TOKEN_INDEX, return_tensors=None):
+    prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split(f'<{MMODAL_INDEX_TOKEN[MMODAL_token_index].lower()}>')]
+    num_prompt_chunks = len(prompt.split(f'<{MMODAL_INDEX_TOKEN[MMODAL_token_index].lower()}>'))
+
+    def insert_separator(X, sep):
+        return [ele for sublist in zip(X, [sep]*len(X)) for ele in sublist][:-1]
+
+    input_ids = []
+    offset = 0
+    if len(prompt_chunks) > 0 and len(prompt_chunks[0]) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:
+        offset = 1
+        input_ids.append(prompt_chunks[0][0])
+
+    for x in insert_separator(prompt_chunks, [MMODAL_token_index] * (offset + 1)):
+        input_ids.extend(x[offset:])
+
+    if return_tensors is not None:
+        if return_tensors == 'pt':
+            return torch.tensor(input_ids, dtype=torch.long)
+        raise ValueError(f'Unsupported tensor type: {return_tensors}')
+    return input_ids
+
+
+def get_model_name_from_path(model_path):
+    model_path = model_path.strip("/")
+    model_paths = model_path.split("/")
+    if model_paths[-1].startswith('checkpoint-'):
+        return model_paths[-2] + "_" + model_paths[-1]
+    else:
+        return model_paths[-1]
+
+
+class KeywordsStoppingCriteria(StoppingCriteria):
+    def __init__(self, keywords, tokenizer, input_ids):
+        self.keywords = keywords
+        self.keyword_ids = []
+        self.max_keyword_len = 0
+        for keyword in keywords:
+            cur_keyword_ids = tokenizer(keyword).input_ids
+            if len(cur_keyword_ids) > 1 and cur_keyword_ids[0] == tokenizer.bos_token_id:
+                cur_keyword_ids = cur_keyword_ids[1:]
+            if len(cur_keyword_ids) > self.max_keyword_len:
+                self.max_keyword_len = len(cur_keyword_ids)
+            self.keyword_ids.append(torch.tensor(cur_keyword_ids))
+        self.tokenizer = tokenizer
+        self.start_len = input_ids.shape[1]
+    
+    def call_for_batch(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
+        offset = min(output_ids.shape[1] - self.start_len, self.max_keyword_len)
+        self.keyword_ids = [keyword_id.to(output_ids.device) for keyword_id in self.keyword_ids]
+        for keyword_id in self.keyword_ids:
+            if (output_ids[0, -keyword_id.shape[0]:] == keyword_id).all():
+                return True
+        outputs = self.tokenizer.batch_decode(output_ids[:, -offset:], skip_special_tokens=True)[0]
+        for keyword in self.keywords:
+            if keyword in outputs:
+                return True
+        return False
+    
+    def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
+        outputs = []
+        for i in range(output_ids.shape[0]):
+            outputs.append(self.call_for_batch(output_ids[i].unsqueeze(0), scores))
+        return all(outputs)

videollama2/model/__init__.py

@@ -0,0 +1,3 @@
+from .language_model.videollama2_llama import Videollama2LlamaForCausalLM, Videollama2Config
+from .language_model.videollama2_mistral import Videollama2MistralForCausalLM, Videollama2MistralConfig
+from .language_model.videollama2_mixtral import Videollama2MixtralForCausalLM, Videollama2MixtralConfig

videollama2/model/builder.py

@@ -0,0 +1,170 @@
+# Adopted from https://github.com/haotian-liu/LLaVA. Below is the original copyright:
+#    Copyright 2023 Haotian Liu
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+
+import os
+import warnings
+import shutil
+
+import torch
+from transformers import PretrainedConfig, AutoTokenizer, AutoModelForCausalLM, AutoConfig, BitsAndBytesConfig
+
+from . import *
+from .multimodal_projector import load_mm_projector
+from ..constants import DEFAULT_IMAGE_PATCH_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+
+
+def load_pretrained_model(model_path, model_base, model_name, load_8bit=False, load_4bit=False, device_map="auto", device="cuda", use_flash_attn=False, **kwargs):
+    if 'token' in kwargs:
+        token = kwargs['token']
+    else:
+        token = None
+    
+    kwargs = {"device_map": device_map, **kwargs}
+
+    if device != "cuda":
+        kwargs['device_map'] = {"": device}
+
+    if load_8bit:
+        kwargs['load_in_8bit'] = True
+    elif load_4bit:
+        kwargs['load_in_4bit'] = True
+        kwargs['quantization_config'] = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type='nf4'
+        )
+    else:
+        kwargs['torch_dtype'] = torch.float16
+
+    if use_flash_attn:
+        kwargs['attn_implementation'] = 'flash_attention_2'
+
+    if "videollama" in model_name.lower():
+        # Load LLaVA model
+        if 'lora' in model_name.lower() and model_base is None:
+            warnings.warn('There is `lora` in model name but no `model_base` is provided. If you are loading a LoRA model, please provide the `model_base` argument. Detailed instruction: https://github.com/haotian-liu/LLaVA#launch-a-model-worker-lora-weights-unmerged.')
+        if 'lora' in model_name.lower() and model_base is not None:
+            lora_cfg_pretrained = AutoConfig.from_pretrained(model_path)
+            tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False)
+            print('Loading VideoLLaMA from base model...')
+            model = Videollama2LlamaForCausalLM.from_pretrained(model_base, low_cpu_mem_usage=True, config=lora_cfg_pretrained, **kwargs)
+            token_num, tokem_dim = model.lm_head.out_features, model.lm_head.in_features
+            if model.lm_head.weight.shape[0] != token_num:
+                model.lm_head.weight = torch.nn.Parameter(torch.empty(token_num, tokem_dim, device=model.device, dtype=model.dtype))
+                model.model.embed_tokens.weight = torch.nn.Parameter(torch.empty(token_num, tokem_dim, device=model.device, dtype=model.dtype))
+
+            print('Loading additional VideoLLaMA weights...')
+            if os.path.exists(os.path.join(model_path, 'non_lora_trainables.bin')):
+                non_lora_trainables = torch.load(os.path.join(model_path, 'non_lora_trainables.bin'), map_location='cpu')
+            else:
+                # this is probably from HF Hub
+                from huggingface_hub import hf_hub_download
+                def load_from_hf(repo_id, filename, subfolder=None):
+                    cache_file = hf_hub_download(
+                        repo_id=repo_id,
+                        filename=filename,
+                        subfolder=subfolder)
+                    return torch.load(cache_file, map_location='cpu')
+                non_lora_trainables = load_from_hf(model_path, 'non_lora_trainables.bin')
+            non_lora_trainables = {(k[11:] if k.startswith('base_model.') else k): v for k, v in non_lora_trainables.items()}
+            if any(k.startswith('model.model.') for k in non_lora_trainables):
+                non_lora_trainables = {(k[6:] if k.startswith('model.') else k): v for k, v in non_lora_trainables.items()}
+            model.load_state_dict(non_lora_trainables, strict=False)
+
+            from peft import PeftModel
+            print('Loading LoRA weights...')
+            model = PeftModel.from_pretrained(model, model_path)
+            print('Merging LoRA weights...')
+            model = model.merge_and_unload()
+            print('Model is loaded...')
+        elif model_base is not None or '-base' in model_name.lower():
+            # loading vision-language projector
+            print('Loading VideoLLaMA 2 from base model...')
+            cfg_pretrained = PretrainedConfig.from_pretrained(model_path, token=token)
+            # NOTE: AutoConfig will modify `_name_or_path` property to `model_path` if `model_path` is not None.
+            # cfg_pretrained = AutoConfig.from_pretrained(model_path, token=token)
+            model_base = model_base if model_base is not None else cfg_pretrained._name_or_path
+
+            tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False, token=token)
+
+            if 'vicuna' in model_name.lower():
+                model = Videollama2LlamaForCausalLM.from_pretrained(model_base, low_cpu_mem_usage=True, config=cfg_pretrained, **kwargs)
+            elif 'mixtral' in model_name.lower():
+                model = Videollama2MixtralForCausalLM.from_pretrained(model_base, low_cpu_mem_usage=True, config=cfg_pretrained, **kwargs)
+            else:
+                model = Videollama2MistralForCausalLM.from_pretrained(model_base, low_cpu_mem_usage=True, config=cfg_pretrained, **kwargs)
+
+            # NOTE: old codes for loading local mm_projector.bin
+            # mm_projector_weights = torch.load(os.path.join(model_path, 'mm_projector.bin'), map_location='cpu')
+            # mm_projector_weights = {k: v.to(torch.float16) for k, v in mm_projector_weights.items()}
+            # model.load_state_dict(mm_projector_weights, strict=False)
+            # NOTE: new codes which supports loading mm_projector.bin both offline and online 
+            mm_projector_weights = load_mm_projector(model_path, token=token)
+            model.load_state_dict(mm_projector_weights, strict=False)
+        else:
+            if 'vicuna' in model_name.lower():
+                tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False, token=token)
+                model = Videollama2LlamaForCausalLM.from_pretrained(model_path, low_cpu_mem_usage=True, **kwargs)
+            elif 'mixtral' in model_name.lower():
+                tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False, token=token)
+                model = Videollama2MixtralForCausalLM.from_pretrained(model_path, low_cpu_mem_usage=True, **kwargs)
+            else:
+                # NOTE: mistral-based model is our default model.
+                tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False, token=token)
+                model = Videollama2MistralForCausalLM.from_pretrained(model_path, low_cpu_mem_usage=True, **kwargs)
+    else:
+        # Load language model
+        if model_base is not None:
+            # PEFT model
+            from peft import PeftModel
+            tokenizer = AutoTokenizer.from_pretrained(model_base, use_fast=False)
+            model = AutoModelForCausalLM.from_pretrained(model_base, low_cpu_mem_usage=True, **kwargs)
+            print(f"Loading LoRA weights from {model_path}")
+            model = PeftModel.from_pretrained(model, model_path)
+            print(f"Merging weights")
+            model = model.merge_and_unload()
+            print('Convert to FP16...')
+            model.to(torch.float16)
+        else:
+            use_fast = False
+            tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False)
+            model = AutoModelForCausalLM.from_pretrained(model_path, low_cpu_mem_usage=True, **kwargs)
+
+    processor = None
+
+    if "videollama" in model_name.lower():
+        mm_use_im_start_end = getattr(model.config, "mm_use_im_start_end", False)
+        mm_use_im_patch_token = getattr(model.config, "mm_use_im_patch_token", True)
+        if mm_use_im_patch_token:
+            tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
+        if mm_use_im_start_end:
+            tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
+        model.resize_token_embeddings(len(tokenizer))
+
+        vision_tower = model.get_vision_tower()
+        if not vision_tower.is_loaded:
+            vision_tower.load_model()
+        vision_tower.to(device=device, dtype=torch.float16)
+        # NOTE: videollama2 adopts the same processor for processing image and video.
+        processor = vision_tower.image_processor
+
+    if hasattr(model.config, "max_sequence_length"):
+        context_len = model.config.max_sequence_length
+    else:
+        context_len = 2048
+
+    return tokenizer, model, processor, context_len

videollama2/model/language_model/videollama2_llama.py

@@ -0,0 +1,147 @@
+# Adopted from: https://github.com/haotian-liu/LLaVA. Below is the original copyright:
+#    Copyright 2023 Haotian Liu
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+from transformers import AutoConfig, AutoModelForCausalLM, \
+                         LlamaConfig, LlamaModel, LlamaForCausalLM
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from transformers.generation.utils import GenerateOutput
+
+from ..videollama2_arch import Videollama2MetaModel, Videollama2MetaForCausalLM
+
+
+class Videollama2Config(LlamaConfig):
+    model_type = "videollama2_llama"
+
+
+class Videollama2LlamaModel(Videollama2MetaModel, LlamaModel):
+    config_class = Videollama2Config
+
+    def __init__(self, config: LlamaConfig):
+        super(Videollama2LlamaModel, self).__init__(config)
+
+
+class Videollama2LlamaForCausalLM(LlamaForCausalLM, Videollama2MetaForCausalLM):
+    config_class = Videollama2Config
+
+    def __init__(self, config, **kwargs):
+        super(LlamaForCausalLM, self).__init__(config)
+        self.model = Videollama2LlamaModel(config)
+        self.pretraining_tp = config.pretraining_tp
+        self.vocab_size = config.vocab_size
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_model(self):
+        return self.model
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        images: Optional[torch.FloatTensor] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+
+        if inputs_embeds is None:
+            (
+                input_ids,
+                attention_mask,
+                past_key_values,
+                inputs_embeds,
+                labels
+            ) = self.prepare_inputs_labels_for_multimodal(
+                input_ids,
+                attention_mask,
+                past_key_values,
+                labels,
+                images
+            )
+
+        return super().forward(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            labels=labels,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict
+        )
+
+    @torch.no_grad()
+    def generate(
+        self,
+        inputs: Optional[torch.Tensor] = None,
+        images_or_videos: Optional[torch.Tensor] = None,
+        modal_list: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> Union[GenerateOutput, torch.LongTensor]:
+        position_ids = kwargs.pop("position_ids", None)
+        attention_mask = kwargs.pop("attention_mask", None)
+        if "inputs_embeds" in kwargs:
+            raise NotImplementedError("`inputs_embeds` is not supported")
+
+        if images_or_videos is not None:
+            (
+                input_ids,
+                attention_mask,
+                past_key_values,
+                inputs_embeds,
+                _
+            ) = self.prepare_inputs_labels_for_multimodal(
+                input_ids=inputs,
+                attention_mask=attention_mask,
+                past_key_values=None,
+                labels=None,
+                X_modalities=[images_or_videos, modal_list]
+            )
+        else:
+            inputs_embeds = self.get_model().embed_tokens(inputs)
+
+        return super().generate(
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            **kwargs
+        )
+
+    def prepare_inputs_for_generation(self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs):
+        images = kwargs.pop("images", None)
+        _inputs = super().prepare_inputs_for_generation(
+            input_ids, past_key_values=past_key_values, inputs_embeds=inputs_embeds, **kwargs
+        )
+        if images is not None:
+            _inputs['images'] = images
+        return _inputs
+
+
+AutoConfig.register("videollama2_llama", Videollama2Config)
+AutoModelForCausalLM.register(Videollama2Config, Videollama2LlamaForCausalLM)

videollama2/model/language_model/videollama2_mistral.py

@@ -0,0 +1,149 @@
+# Adopted from: https://github.com/haotian-liu/LLaVA. Below is the original copyright:
+#    Copyright 2023 Haotian Liu
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss
+
+from transformers import AutoConfig, AutoModelForCausalLM, \
+                         MistralConfig, MistralModel, MistralForCausalLM
+
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from transformers.generation.utils import GenerateOutput
+
+from ..videollama2_arch import Videollama2MetaModel, Videollama2MetaForCausalLM
+
+
+class Videollama2MistralConfig(MistralConfig):
+    model_type = "videollama2_mistral"
+
+
+class Videollama2MistralModel(Videollama2MetaModel, MistralModel):
+    config_class = Videollama2MistralConfig
+
+    def __init__(self, config: MistralConfig):
+        super(Videollama2MistralModel, self).__init__(config)
+
+
+class Videollama2MistralForCausalLM(MistralForCausalLM, Videollama2MetaForCausalLM):
+    config_class = Videollama2MistralConfig
+
+    def __init__(self, config, **kwargs):
+        super(MistralForCausalLM, self).__init__(config)
+        self.model = Videollama2MistralModel(config)
+        # self.pretraining_tp = config.pretraining_tp
+        self.vocab_size = config.vocab_size
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_model(self):
+        return self.model
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        images: Optional[torch.FloatTensor] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+
+        if inputs_embeds is None:
+            (
+                input_ids,
+                attention_mask,
+                past_key_values,
+                inputs_embeds,
+                labels
+            ) = self.prepare_inputs_labels_for_multimodal(
+                input_ids,
+                attention_mask,
+                past_key_values,
+                labels,
+                images
+            )
+
+        return super().forward(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            labels=labels,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict
+        )
+
+    @torch.no_grad()
+    def generate(
+        self,
+        inputs: Optional[torch.Tensor] = None,
+        images_or_videos: Optional[torch.Tensor] = None,
+        modal_list: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> Union[GenerateOutput, torch.LongTensor]:
+        position_ids = kwargs.pop("position_ids", None)
+        attention_mask = kwargs.pop("attention_mask", None)
+        if "inputs_embeds" in kwargs:
+            raise NotImplementedError("`inputs_embeds` is not supported")
+
+        if images_or_videos is not None:
+            (
+                input_ids,
+                attention_mask,
+                past_key_values,
+                inputs_embeds,
+                _
+            ) = self.prepare_inputs_labels_for_multimodal(
+                input_ids=inputs,
+                attention_mask=attention_mask,
+                past_key_values=None,
+                labels=None,
+                X_modalities=[images_or_videos, modal_list]
+            )
+        else:
+            inputs_embeds = self.get_model().embed_tokens(inputs)
+
+        return super().generate(
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            **kwargs
+        )
+
+    def prepare_inputs_for_generation(self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs):
+        images = kwargs.pop("images", None)
+        _inputs = super().prepare_inputs_for_generation(
+            input_ids, past_key_values=past_key_values, inputs_embeds=inputs_embeds, **kwargs
+        )
+        if images is not None:
+            _inputs['images'] = images
+        return _inputs
+
+
+AutoConfig.register("videollama2_mistral", Videollama2MistralConfig)
+AutoModelForCausalLM.register(Videollama2MistralConfig, Videollama2MistralForCausalLM)

videollama2/model/language_model/videollama2_mixtral.py

@@ -0,0 +1,149 @@
+#    Copyright 2023 Haotian Liu
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss
+
+from transformers import AutoConfig, AutoModelForCausalLM, \
+                         MixtralConfig, MixtralModel, MixtralForCausalLM
+
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from transformers.generation.utils import GenerateOutput
+
+from ..videollama2_arch import Videollama2MetaModel, Videollama2MetaForCausalLM
+
+
+class Videollama2MixtralConfig(MixtralConfig):
+    model_type = "videollama2_mixtral"
+
+
+class Videollama2MixtralModel(Videollama2MetaModel, MixtralModel):
+    config_class = Videollama2MixtralConfig
+
+    def __init__(self, config: MixtralConfig):
+        super(Videollama2MixtralModel, self).__init__(config)
+
+
+class Videollama2MixtralForCausalLM(MixtralForCausalLM, Videollama2MetaForCausalLM):
+    config_class = Videollama2MixtralConfig
+
+    def __init__(self, config, **kwargs):
+        super(MixtralForCausalLM, self).__init__(config)
+        self.model = Videollama2MixtralModel(config)
+        # self.pretraining_tp = config.pretraining_tp
+        self.vocab_size = config.vocab_size
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_model(self):
+        return self.model
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        images: Optional[torch.FloatTensor] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+
+        if inputs_embeds is None:
+            (
+                input_ids,
+                attention_mask,
+                past_key_values,
+                inputs_embeds,
+                labels
+            ) = self.prepare_inputs_labels_for_multimodal(
+                input_ids,
+                attention_mask,
+                past_key_values,
+                labels,
+                images
+            )
+
+        return super().forward(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            labels=labels,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict
+        )
+
+    @torch.no_grad()
+    def generate(
+        self,
+        inputs: Optional[torch.Tensor] = None,
+        images_or_videos: Optional[torch.Tensor] = None,
+        timestamps: Optional[torch.Tensor] = None,
+        modal_list: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> Union[GenerateOutput, torch.LongTensor]:
+        position_ids = kwargs.pop("position_ids", None)
+        attention_mask = kwargs.pop("attention_mask", None)
+        if "inputs_embeds" in kwargs:
+            raise NotImplementedError("`inputs_embeds` is not supported")
+
+        if images_or_videos is not None:
+            X_modalities = [images_or_videos, modal_list] if timestamps is None else [images_or_videos, modal_list, timestamps]
+            (
+                input_ids,
+                attention_mask,
+                past_key_values,
+                inputs_embeds,
+                _
+            ) = self.prepare_inputs_labels_for_multimodal(
+                input_ids=inputs,
+                attention_mask=attention_mask,
+                past_key_values=None,
+                labels=None,
+                X_modalities=X_modalities
+            )
+        else:
+            inputs_embeds = self.get_model().embed_tokens(inputs)
+
+        return super().generate(
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            **kwargs
+        )
+
+    def prepare_inputs_for_generation(self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs):
+        images = kwargs.pop("images", None)
+        _inputs = super().prepare_inputs_for_generation(
+            input_ids, past_key_values=past_key_values, inputs_embeds=inputs_embeds, **kwargs
+        )
+        if images is not None:
+            _inputs['images'] = images
+        return _inputs
+
+AutoConfig.register("videollama2_mixtral", Videollama2MixtralConfig)
+AutoModelForCausalLM.register(Videollama2MixtralConfig, Videollama2MixtralForCausalLM)

videollama2/model/multimodal_encoder/builder.py

@@ -0,0 +1,15 @@
+import os
+
+from .clip_encoder import CLIPVisionTower
+
+
+def build_vision_tower(vision_tower_cfg, **kwargs):
+    vision_tower = getattr(vision_tower_cfg, 'mm_vision_tower', getattr(vision_tower_cfg, 'vision_tower', None))
+
+    is_absolute_path_exists = os.path.exists(vision_tower)
+    if  vision_tower.startswith("openai") or vision_tower.startswith("laion") or 'clip' in vision_tower:
+        vision_tower = CLIPVisionTower(vision_tower, args=vision_tower_cfg, **kwargs)
+    else:
+        raise ValueError(f'Unknown vision tower: {vision_tower}')
+
+    return vision_tower

videollama2/model/multimodal_encoder/clip_encoder.py

@@ -0,0 +1,84 @@
+import torch
+import torch.nn as nn
+
+from transformers import CLIPVisionModel, CLIPImageProcessor, CLIPVisionConfig
+
+
+class CLIPVisionTower(nn.Module):
+
+    def __init__(self, vision_tower, args, delay_load=False):
+        super().__init__()
+
+        self.is_loaded = False
+
+        self.vision_tower_name = vision_tower
+        self.select_layer = args.mm_vision_select_layer
+        self.select_feature = getattr(args, 'mm_vision_select_feature', 'patch')
+
+        if not delay_load:
+            self.load_model()
+        else:
+            self.cfg_only = CLIPVisionConfig.from_pretrained(self.vision_tower_name)
+
+    def load_model(self):
+        self.image_processor = CLIPImageProcessor.from_pretrained(self.vision_tower_name)
+
+        self.vision_tower = CLIPVisionModel.from_pretrained(self.vision_tower_name)
+        self.vision_tower.requires_grad_(False)
+
+        self.is_loaded = True
+
+    def feature_select(self, image_forward_outs):
+        image_features = image_forward_outs.hidden_states[self.select_layer]
+        if self.select_feature == 'patch':
+            image_features = image_features[:, 1:]
+        elif self.select_feature == 'cls_patch':
+            image_features = image_features
+        else:
+            raise ValueError(f'Unexpected select feature: {self.select_feature}')
+        return image_features
+
+    @torch.no_grad()
+    def forward(self, images):
+        if type(images) is list:
+            image_features = []
+            for image in images:
+                image_forward_out = self.vision_tower(image.to(device=self.device, dtype=self.dtype).unsqueeze(0), output_hidden_states=True)
+                image_feature = self.feature_select(image_forward_out).to(image.dtype)
+                image_features.append(image_feature)
+        else:
+            image_forward_outs = self.vision_tower(images.to(device=self.device, dtype=self.dtype), output_hidden_states=True)
+            image_features = self.feature_select(image_forward_outs).to(images.dtype)
+
+        return image_features
+
+    @property
+    def dummy_feature(self):
+        return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype)
+
+    @property
+    def dtype(self):
+        return self.vision_tower.dtype
+
+    @property
+    def device(self):
+        return self.vision_tower.device
+
+    @property
+    def config(self):
+        if self.is_loaded:
+            return self.vision_tower.config
+        else:
+            return self.cfg_only
+
+    @property
+    def hidden_size(self):
+        return self.config.hidden_size
+
+    @property
+    def num_patches(self):
+        return (self.config.image_size // self.config.patch_size) ** 2
+
+    @property
+    def num_patches_per_side(self):
+        return self.config.image_size // self.config.patch_size

videollama2/model/multimodal_projector/__init__.py

@@ -0,0 +1 @@
+from .builder import load_mm_projector

videollama2/model/multimodal_projector/builder.py

@@ -0,0 +1,250 @@
+#    Copyright 2024 Alibaba DAMO Academy
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+import os
+import re
+
+import einops
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from timm.models.regnet import RegStage
+from timm.models.layers import LayerNorm, LayerNorm2d
+from transformers import TRANSFORMERS_CACHE
+
+
+def parse_snapshot_folder(repo_id, cache_dir=None, repo_type="model"):
+    revision = "main"
+    # 1. parse the downloaded cache folder
+    if cache_dir is None:
+        cache_dir = TRANSFORMERS_CACHE
+    else:
+        cache_dir = cache_dir
+    object_id = repo_id.replace("/", "--")
+    repo_cache = os.path.join(cache_dir, f"{repo_type}s--{object_id}")
+    # 2. resolve refs (for instance to convert main to the associated commit sha)
+    refs_dir = os.path.join(repo_cache, "refs")
+    if os.path.isdir(refs_dir):
+        revision_file = os.path.join(refs_dir, revision)
+        if os.path.isfile(revision_file):
+            with open(revision_file) as f:
+                revision = f.read()
+    # 3. acquire the snapshot folder
+    folder = os.path.join(repo_cache, "snapshots", revision)
+
+    return folder
+
+
+def load_mm_projector(model_path, cache_dir=None, token=None):
+    if os.path.exists(os.path.join(model_path, 'mm_projector.bin')):
+        is_local = True
+        folder = model_path
+    else:
+        is_local = False
+        folder = parse_snapshot_folder(model_path, cache_dir=cache_dir, repo_type="model")
+        if not os.path.exists(os.path.join(folder, 'mm_projector.bin')):
+            # downloading from remote repo
+            from huggingface_hub import snapshot_download
+            snapshot_download(repo_id=model_path, cache_dir=cache_dir, token=token)
+
+    mm_projector_weights = torch.load(os.path.join(folder, 'mm_projector.bin'), map_location='cpu')
+    mm_projector_weights = {k: v.to(torch.float16) for k, v in mm_projector_weights.items()}
+    return mm_projector_weights
+
+
+class IdentityMap(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, *args, **kwargs):
+        return x
+
+    @property
+    def config(self):
+        return {"mm_projector_type": 'identity'}
+
+
+class SimpleResBlock(nn.Module):
+
+    def __init__(self, channels):
+        super().__init__()
+        self.pre_norm = nn.LayerNorm(channels)
+
+        self.proj = nn.Sequential(
+            nn.Linear(channels, channels),
+            nn.GELU(),
+            nn.Linear(channels, channels)
+        )
+    def forward(self, x):
+        x = self.pre_norm(x)
+        return x + self.proj(x)
+
+
+def build_vision_projector(config, delay_load=False, **kwargs):
+    projector_type = getattr(config, 'mm_projector_type', 'linear')
+    mlp_gelu_match = re.match(r'^mlp(\d+)x_gelu$', projector_type)
+    if mlp_gelu_match:
+        mlp_depth = int(mlp_gelu_match.group(1))
+        modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)]
+        for _ in range(1, mlp_depth):
+            modules.append(nn.GELU())
+            modules.append(nn.Linear(config.hidden_size, config.hidden_size))
+        return nn.Sequential(*modules)
+
+    if projector_type == "linear":
+        # NOTE: for both linear and mlp2x_gelu projector type, mean pooling is adopted to aggreate video features
+        return nn.Linear(config.mm_hidden_size, config.hidden_size)
+    elif projector_type == "stc_connector":
+        return STCConnector(config)
+    elif projector_type == "stp_connector":
+        return STPConnector(config)
+    elif projector_type == "stc_connector_v35":
+        return STCConnectorV35(config)
+    elif projector_type == "spatial_conv":
+        return SpatialConv(config)
+    elif projector_type == "spatial_pool":
+        return SpatialPool(config)
+    if projector_type == 'identity':
+        return IdentityMap()
+
+    raise ValueError(f'Unknown projector type: {projector_type}')
+
+
+def build_mlp(depth, hidden_size, output_hidden_size):
+    modules = [nn.Linear(hidden_size, output_hidden_size)]
+    for _ in range(1, depth):
+        modules.append(nn.GELU())
+        modules.append(nn.Linear(output_hidden_size, output_hidden_size))
+    return nn.Sequential(*modules)
+
+
+class STCConnector(nn.Module):
+
+    def __init__(self, config, downsample=(2, 2, 2), depth=4, mlp_depth=2):
+        """Temporal Convolutional Vision-Language Connector.
+        
+        Args:
+            config: config object.
+            downsample: (temporal, height, width) downsample rate.
+            depth: depth of the spatial interaction blocks.
+            mlp_depth: depth of the vision-language projector layers.
+        """
+        super().__init__()
+        self.encoder_hidden_size = encoder_hidden_size = config.mm_hidden_size
+        self.hidden_size = hidden_size = config.hidden_size
+        self.output_hidden_size = output_hidden_size = config.hidden_size
+        # TODO: make these as config arguments
+        self.depth = depth
+        self.mlp_depth = mlp_depth
+        self.downsample = downsample
+        if depth != 0:
+            self.s1 = RegStage(
+                depth=depth,
+                in_chs=encoder_hidden_size,
+                out_chs=hidden_size,
+                stride=1,
+                dilation=1,
+                act_layer=nn.SiLU,
+                norm_layer=LayerNorm2d,
+            )
+        else:
+            self.s1 = nn.Identity()
+        self.sampler = nn.Sequential(
+            nn.Conv3d(
+                in_channels=hidden_size,
+                out_channels=hidden_size,
+                kernel_size=downsample,
+                stride=downsample,
+                padding=1,
+                bias=True
+            ),
+            nn.SiLU()
+        )
+        if depth != 0:
+            self.s2 = RegStage(
+                depth=depth,
+                in_chs=hidden_size,
+                out_chs=hidden_size,
+                stride=1,
+                dilation=1,
+                act_layer=nn.SiLU,
+                norm_layer=LayerNorm2d,
+            )
+        else:
+            self.s2 = nn.Identity()
+        self.readout = build_mlp(mlp_depth, hidden_size, output_hidden_size)
+
+    def forward(self, x):
+        """Aggregate tokens on the temporal and spatial dimensions.
+        Args:
+            x: input tokens [b, t, h, w, d] / [b, t, l, d]
+        Returns:
+            aggregated tokens [b, l, d]
+        """
+        t = x.size(1)
+        if x.ndim == 4:
+            hw = int(x.size(2) ** 0.5)
+            x = einops.rearrange(x, "b t (h w) d -> b d t h w", h=hw, w=hw)
+        elif x.ndim == 5:
+            x = einops.rearrange(x, "b t h w d -> b d t h w")
+
+        x = einops.rearrange(x, "b d t h w -> (b t) d h w")
+        # 1. the first stage of the adapter
+        x = self.s1(x)
+        x = einops.rearrange(x, "(b t) d h w -> b d t h w", t=t)
+        # 2. downsampler
+        x = self.sampler(x)
+        new_t = x.size(2)
+        # 3. the second stage of the adapter
+        x = einops.rearrange(x, "b d t h w -> (b t) d h w")
+        x = self.s2(x)
+        x = einops.rearrange(x, "(b t) d h w -> b (t h w) d", t=new_t)
+        x = self.readout(x)
+        return x
+
+
+class STPConnector(STCConnector):
+
+    def __init__(self, config, downsample=(2, 2, 2), depth=4, mlp_depth=2):
+        super().__init__(config=config, downsample=downsample, depth=depth, mlp_depth=mlp_depth)
+        self.sampler = nn.Sequential(nn.AvgPool3d(downsample), nn.SiLU())
+
+
+class STCConnectorV35(STCConnector):
+
+    def __init__(self, config, downsample=(2, 2, 2), depth=4, mlp_depth=2):
+        super().__init__(config=config, downsample=downsample, depth=depth, mlp_depth=mlp_depth)
+        self.sampler = nn.Sequential(
+            nn.Conv3d(
+                in_channels=self.hidden_size,
+                out_channels=self.hidden_size,
+                kernel_size=downsample,
+                stride=downsample,
+                padding=0,
+                bias=True
+            ),
+            nn.SiLU())
+
+
+class SpatialConv(STCConnector):
+
+    def __init__(self, config, downsample=(1, 2, 2), depth=0, mlp_depth=2):
+        super().__init__(config=config, downsample=downsample, depth=depth, mlp_depth=mlp_depth)
+
+
+class SpatialPool(STPConnector):
+
+    def __init__(self, config, downsample=(1, 2, 2), depth=0, mlp_depth=2):
+        super().__init__(config=config, downsample=downsample, depth=depth, mlp_depth=mlp_depth)

videollama2/model/videollama2_arch.py

@@ -0,0 +1,346 @@
+# Adopted from https://github.com/haotian-liu/LLaVA. Below is the original copyright:
+#    Copyright 2023 Haotian Liu
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+import os
+from abc import ABC, abstractmethod
+
+import einops
+import torch
+import torch.nn as nn
+
+from .multimodal_encoder.builder import build_vision_tower
+from .multimodal_projector.builder import build_vision_projector
+from ..mm_utils import get_anyres_image_grid_shape
+from ..constants import NUM_FRAMES, IGNORE_INDEX, IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_PATCH_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN,DEFAULT_MMODAL_PATCH_TOKEN, DEFAULT_MMODAL_START_TOKEN, DEFAULT_MMODAL_END_TOKEN, MMODAL_TOKEN_INDEX
+
+
+class Videollama2MetaModel:
+
+    def __init__(self, config):
+        super(Videollama2MetaModel, self).__init__(config)
+
+        if hasattr(config, "mm_vision_tower"):
+            self.vision_tower = build_vision_tower(config, delay_load=True)
+            self.mm_projector = build_vision_projector(config)
+
+    def get_vision_tower(self):
+        vision_tower = getattr(self, 'vision_tower', None)
+        if type(vision_tower) is list:
+            vision_tower = vision_tower[0]
+        return vision_tower
+
+    def initialize_vision_modules(self, model_args, fsdp=None):
+        vision_tower = model_args.vision_tower
+        mm_vision_select_layer = model_args.mm_vision_select_layer
+        mm_vision_select_feature = model_args.mm_vision_select_feature
+        pretrain_mm_mlp_adapter = model_args.pretrain_mm_mlp_adapter
+
+        self.config.mm_vision_tower = vision_tower
+
+        if self.get_vision_tower() is None:
+            vision_tower = build_vision_tower(model_args)
+
+            if fsdp is not None and len(fsdp) > 0:
+                self.vision_tower = [vision_tower]
+            else:
+                self.vision_tower = vision_tower
+        else:
+            if fsdp is not None and len(fsdp) > 0:
+                vision_tower = self.vision_tower[0]
+            else:
+                vision_tower = self.vision_tower
+            vision_tower.load_model()
+
+        self.config.use_mm_proj = True
+        self.config.mm_projector_type = getattr(model_args, 'mm_projector_type', 'linear')
+        self.config.mm_hidden_size = vision_tower.hidden_size
+        self.config.mm_vision_select_layer = mm_vision_select_layer
+        self.config.mm_vision_select_feature = mm_vision_select_feature
+
+        if getattr(self, 'mm_projector', None) is None:
+            self.mm_projector = build_vision_projector(self.config)
+        else:
+            # In case it is frozen by LoRA
+            for p in self.mm_projector.parameters():
+                p.requires_grad = True
+
+        if pretrain_mm_mlp_adapter is not None:
+            if os.path.exists(pretrain_mm_mlp_adapter):
+                is_local = True
+                mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
+            else:
+                # Support loading projector weights from remote HuggingFace model hub
+                is_local = False
+                pretrain_mm_mlp_adapter = pretrain_mm_mlp_adapter.replace('mm_projector.bin', '')
+                pretrain_mm_mlp_adapter = pretrain_mm_mlp_adapter.strip('/').strip('\\').strip()
+                mm_projector_weights = load_mm_projector(pretrain_mm_mlp_adapter)
+
+            def get_w(weights, keyword):
+                return {k.split(keyword + '.')[1]: v for k, v in weights.items() if keyword in k}
+
+            # self.mm_projector.load_state_dict(get_w(mm_projector_weights, 'mm_projector'))
+            # set strict=False to avoid missing key error regarding bert.embeddings.position_ids
+            self.mm_projector.load_state_dict(get_w(mm_projector_weights, 'mm_projector'), strict=False)
+
+
+class Videollama2MetaForCausalLM(ABC):
+
+    @abstractmethod
+    def get_model(self):
+        pass
+
+    def num_frames(self):
+        if hasattr(self.config, 'num_frames'):
+            return self.config.num_frames
+        else:
+            return NUM_FRAMES
+
+    def get_vision_tower(self):
+        return self.get_model().get_vision_tower()
+
+    def encode_images_or_videos(self, images_or_videos, modalities):
+        num_frames = self.config.num_frames if hasattr(self.config, 'num_frames') else NUM_FRAMES
+
+        videos = [x.unsqueeze(0).expand(num_frames, -1, -1, -1) if modal == 'image' else x for x, modal in zip(images_or_videos, modalities)]
+        videos = torch.stack(videos, dim=0)
+
+        assert len(videos.size()) == 5
+        batch_size = videos.size(0)
+
+        frames = einops.rearrange(videos, 'b t c h w -> (b t) c h w')
+        frames_features = self.get_model().get_vision_tower()(frames)
+        frames_features = einops.rearrange(frames_features, '(b t) n h -> b t n h', b = batch_size)
+
+        return self.temporal_aggregator(frames_features)
+
+    def temporal_aggregator(self, frames_features):
+        """Temporal aggregation of frame features.
+        Args:
+            frames_features (torch.Tensor): Frame features with shape (b, t, n, h).
+        Returns:
+            torch.Tensor: Video features with shape (b, n, h).
+        """
+        # TODO: improve the merging method.
+        # *********** mean pooling *************
+        if self.config.mm_projector_type == "mlp2x_gelu" or self.config.mm_projector_type == "linear":
+            video_features = self.get_model().mm_projector(frames_features.mean(1))
+        # *********** spatial convolution *************
+        elif self.config.mm_projector_type == "spatial_conv":
+            video_features = self.get_model().mm_projector(frames_features)
+        # *********** spatial pooling *************
+        elif self.config.mm_projector_type == "spatial_pool":
+            video_features = self.get_model().mm_projector(frames_features)
+        # *********** time  ************
+        elif "tc_connector" in self.config.mm_projector_type or "tp_connector" in self.config.mm_projector_type:
+            video_features = self.get_model().mm_projector(frames_features)
+        else:
+            raise Exception(f"Unsupported projector type {self.config.mm_projector_type}!!!")
+
+        return video_features
+
+    def prepare_inputs_labels_for_multimodal(
+        self, input_ids, attention_mask, past_key_values, labels, X_modalities
+    ):
+        vision_tower = self.get_vision_tower()
+        # NOTE: text-only situation
+        if vision_tower is None or X_modalities is None or input_ids.shape[1] == 1:
+            # if past_key_values is not None and vision_tower is not None and Xs is not None and input_ids.shape[1] == 1:
+            #    attention_mask = torch.ones((attention_mask.shape[0], past_key_values[-1][-1].shape[-2] + 1), dtype=attention_mask.dtype, device=attention_mask.device)
+            return input_ids, attention_mask, past_key_values, None, labels
+
+        Xs, keys = X_modalities
+        X_features = self.encode_images_or_videos(Xs, keys)
+
+        new_input_embeds = []
+        new_labels = [] if labels is not None else None
+        cur_X_idx = 0
+        # replace image/video/audio tokens with pre-computed embeddings
+        for batch_idx, cur_input_ids in enumerate(input_ids):
+            # cur_X_features = X_features[batch_idx]
+            if (torch.any(torch.stack([cur_input_ids == MMODAL_TOKEN_INDEX[key.upper()] for key in keys]), dim=0)).sum() == 0:
+                half_len = cur_input_ids.shape[0] // 2
+                cur_X_features = X_features[cur_X_idx]
+                cur_input_embeds_1 = self.get_model().embed_tokens(cur_input_ids[:half_len])
+                cur_input_embeds_2 = self.get_model().embed_tokens(cur_input_ids[half_len:])
+                cur_input_embeds = torch.cat([cur_input_embeds_1, cur_X_features[0:0], cur_input_embeds_2], dim=0)
+                new_input_embeds.append(cur_input_embeds)
+                if labels is not None:
+                    new_labels.append(labels[batch_idx])
+                cur_X_idx += 1 
+                continue
+
+            X_token_indices = torch.where(torch.any(torch.stack([cur_input_ids == MMODAL_TOKEN_INDEX[key.upper()] for key in keys]), dim=0))[0] 
+            cur_new_input_embeds = []
+            if labels is not None:
+                cur_labels = labels[batch_idx]
+                cur_new_labels = []
+                assert cur_labels.shape == cur_input_ids.shape
+            
+            # X_index_inonesample = 0
+            while X_token_indices.numel() > 0:
+                cur_X_features = X_features[cur_X_idx]
+                X_token_start = X_token_indices[0]
+
+                cur_new_input_embeds.append(self.get_model().embed_tokens(cur_input_ids[:X_token_start])) 
+                cur_new_input_embeds.append(cur_X_features)
+                if labels is not None:
+                    cur_new_labels.append(cur_labels[:X_token_start])
+                    cur_new_labels.append(torch.full((cur_X_features.shape[0],), IGNORE_INDEX, device=labels.device, dtype=labels.dtype))
+                    cur_labels = cur_labels[X_token_start+1:]
+
+                cur_X_idx += 1
+                cur_input_ids = cur_input_ids[X_token_start+1:] 
+                X_token_indices = torch.where(torch.any(torch.stack([cur_input_ids == MMODAL_TOKEN_INDEX[key.upper()] for key in keys]), dim=0))[0]
+
+            if cur_input_ids.numel() > 0:
+                cur_new_input_embeds.append(self.get_model().embed_tokens(cur_input_ids))
+                if labels is not None:
+                    cur_new_labels.append(cur_labels)
+            cur_new_input_embeds = [x.to(device=self.device) for x in cur_new_input_embeds]
+            # NOTE: one cur_new_input_embeds per each  
+            cur_new_input_embeds = torch.cat(cur_new_input_embeds, dim=0)
+            new_input_embeds.append(cur_new_input_embeds)
+            if labels is not None:
+                cur_new_labels = torch.cat(cur_new_labels, dim=0)
+                new_labels.append(cur_new_labels)
+
+        # padding
+        if any(x.shape != new_input_embeds[0].shape for x in new_input_embeds):
+            max_len = max(x.shape[0] for x in new_input_embeds)
+
+            new_input_embeds_align = []
+            for cur_new_embed in new_input_embeds:
+                cur_new_embed = torch.cat((cur_new_embed, torch.zeros((max_len - cur_new_embed.shape[0], cur_new_embed.shape[1]), dtype=cur_new_embed.dtype, device=cur_new_embed.device)), dim=0)
+                new_input_embeds_align.append(cur_new_embed)
+            new_input_embeds = torch.stack(new_input_embeds_align, dim=0)
+
+            if labels is not None:
+                new_labels_align = []
+                _new_labels = new_labels
+                for cur_new_label in new_labels:
+                    cur_new_label = torch.cat((cur_new_label, torch.full((max_len - cur_new_label.shape[0],), IGNORE_INDEX, dtype=cur_new_label.dtype, device=cur_new_label.device)), dim=0)
+                    new_labels_align.append(cur_new_label)
+                new_labels = torch.stack(new_labels_align, dim=0)
+
+            if attention_mask is not None:
+                new_attention_mask = []
+                for cur_attention_mask, cur_new_labels, cur_new_labels_align in zip(attention_mask, _new_labels, new_labels):
+                    new_attn_mask_pad_left = torch.full((cur_new_labels.shape[0] - labels.shape[1],), True, dtype=attention_mask.dtype, device=attention_mask.device)
+                    new_attn_mask_pad_right = torch.full((cur_new_labels_align.shape[0] - cur_new_labels.shape[0],), False, dtype=attention_mask.dtype, device=attention_mask.device)
+                    cur_new_attention_mask = torch.cat((new_attn_mask_pad_left, cur_attention_mask, new_attn_mask_pad_right), dim=0)
+                    new_attention_mask.append(cur_new_attention_mask)
+                attention_mask = torch.stack(new_attention_mask, dim=0)
+                assert attention_mask.shape == new_labels.shape
+        else:
+            new_input_embeds = torch.stack(new_input_embeds, dim=0)
+            if labels is not None:
+                new_labels  = torch.stack(new_labels, dim=0)
+
+            if attention_mask is not None:
+                new_attn_mask_pad_left = torch.full((attention_mask.shape[0], new_input_embeds.shape[1] - input_ids.shape[1]), True, dtype=attention_mask.dtype, device=attention_mask.device)
+                attention_mask = torch.cat((new_attn_mask_pad_left, attention_mask), dim=1)
+                assert attention_mask.shape == new_input_embeds.shape[:2]
+
+        return None, attention_mask, past_key_values, new_input_embeds, new_labels
+
+    def initialize_vision_tokenizer(self, model_args, tokenizer):
+        if model_args.mm_use_im_patch_token:
+            tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
+            self.resize_token_embeddings(len(tokenizer))
+
+        if model_args.mm_use_im_start_end:
+            num_new_tokens = tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True)
+            self.resize_token_embeddings(len(tokenizer))
+
+            if num_new_tokens > 0:
+                input_embeddings  = self.get_input_embeddings().weight.data
+                output_embeddings = self.get_output_embeddings().weight.data
+
+                input_embeddings_avg  = input_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True)
+                output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True)
+
+                input_embeddings[-num_new_tokens:]  = input_embeddings_avg
+                output_embeddings[-num_new_tokens:] = output_embeddings_avg
+
+            if model_args.tune_mm_mlp_adapter:
+                for p in self.get_input_embeddings().parameters():
+                    p.requires_grad = True
+                for p in self.get_output_embeddings().parameters():
+                    p.requires_grad = False
+
+            if model_args.pretrain_mm_mlp_adapter:
+                mm_projector_weights = torch.load(model_args.pretrain_mm_mlp_adapter, map_location='cpu')
+                embed_tokens_weight = mm_projector_weights['model.embed_tokens.weight']
+                assert num_new_tokens == 2
+                if input_embeddings.shape == embed_tokens_weight.shape:
+                    input_embeddings[-num_new_tokens:] = embed_tokens_weight[-num_new_tokens:]
+                elif embed_tokens_weight.shape[0] == num_new_tokens:
+                    input_embeddings[-num_new_tokens:] = embed_tokens_weight
+                else:
+                    raise ValueError(f"Unexpected embed_tokens_weight shape. Pretrained: {embed_tokens_weight.shape}. Current: {input_embeddings.shape}. Numer of new tokens: {num_new_tokens}.")
+        elif model_args.mm_use_im_patch_token:
+            if model_args.tune_mm_mlp_adapter:
+                for p in self.get_input_embeddings().parameters():
+                    p.requires_grad = False
+                for p in self.get_output_embeddings().parameters():
+                    p.requires_grad = False
+
+    def initialize_MM_tokenizer(self, model_args, tokenizer):
+        if model_args.mm_use_im_patch_token:
+            for modal in ['IMAGE', 'VIDEO', 'AUDIO']:
+                tokenizer.add_tokens([DEFAULT_MMODAL_PATCH_TOKEN[modal.upper()]], special_tokens=True)
+            # tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True)
+            self.resize_token_embeddings(len(tokenizer))
+
+        if model_args.mm_use_im_start_end:
+            num_new_tokens = 0
+            for modal in ['IMAGE', 'VIDEO', 'AUDIO']:
+                num_new_tokens += tokenizer.add_tokens([DEFAULT_MMODAL_START_TOKEN[modal.upper()], DEFAULT_MMODAL_END_TOKEN[modal.upper()]], special_tokens=True)
+            self.resize_token_embeddings(len(tokenizer))
+
+            if num_new_tokens > 0:
+                input_embeddings = self.get_input_embeddings().weight.data
+                output_embeddings = self.get_output_embeddings().weight.data
+
+                input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(
+                    dim=0, keepdim=True)
+                output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(
+                    dim=0, keepdim=True)
+
+                input_embeddings[-num_new_tokens:] = input_embeddings_avg
+                output_embeddings[-num_new_tokens:] = output_embeddings_avg
+
+            if model_args.tune_mm_mlp_adapter:
+                for p in self.get_input_embeddings().parameters():
+                    p.requires_grad = True
+                for p in self.get_output_embeddings().parameters():
+                    p.requires_grad = False
+
+            if model_args.pretrain_mm_mlp_adapter:
+                mm_projector_weights = torch.load(model_args.pretrain_mm_mlp_adapter, map_location='cpu')
+                embed_tokens_weight = mm_projector_weights['model.embed_tokens.weight']
+                assert num_new_tokens == 6  # start/end tokens for image/video/audio
+                if input_embeddings.shape == embed_tokens_weight.shape:
+                    input_embeddings[-num_new_tokens:] = embed_tokens_weight[-num_new_tokens:]
+                elif embed_tokens_weight.shape[0] == num_new_tokens:
+                    input_embeddings[-num_new_tokens:] = embed_tokens_weight
+                else:
+                    raise ValueError(f"Unexpected embed_tokens_weight shape. Pretrained: {embed_tokens_weight.shape}. Current: {input_embeddings.shape}. Numer of new tokens: {num_new_tokens}.")
+        elif model_args.mm_use_im_patch_token:
+            if model_args.tune_mm_mlp_adapter:
+                for p in self.get_input_embeddings().parameters():
+                    p.requires_grad = False
+                for p in self.get_output_embeddings().parameters():
+                    p.requires_grad = False

videollama2/serve/cli.py

@@ -0,0 +1,144 @@
+import argparse
+import torch
+
+from videollama2.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN, NUM_FRAMES
+from videollama2.conversation import conv_templates, SeparatorStyle
+from videollama2.model.builder import load_pretrained_model
+from videollama2.utils import disable_torch_init
+from videollama2.mm_utils import process_images, tokenizer_image_token, get_model_name_from_path, tokenizer_MMODAL_token
+
+from PIL import Image
+from decord import VideoReader, cpu
+
+import requests
+from io import BytesIO
+from transformers import TextStreamer
+
+
+def load_image(image_file):
+    if image_file.startswith('http://') or image_file.startswith('https://'):
+        response = requests.get(image_file)
+        image = Image.open(BytesIO(response.content)).convert('RGB')
+    else:
+        image = Image.open(image_file).convert('RGB')
+    return image
+
+def load_video(video_file):
+    decord_vr = VideoReader(uri=video_file, ctx=cpu(0))
+    duration = len(decord_vr)
+    frame_id_list = np.linspace(0, duration-1, NUM_FRAMES, dtype=int)
+    video = decord_vr.get_batch(frame_id_list)
+    return video
+
+def load_image_or_video(image_or_video_file):
+    if file_path.endswith(('.jpg', '.jpeg', '.png', '.bmp')):
+        return load_image(image_file=image_or_video_file)
+    elif file_path.endswith(('.mp4', '.avi', '.mov')):
+        return load_video(video_file=image_or_video_file)
+    else:
+        raise Exception(f"File type of {image_or_video_file} not supported!!!")
+
+
+def main(args):
+    # Model
+    disable_torch_init()
+
+    model_name = get_model_name_from_path(args.model_path)
+    tokenizer, model, image_processor, context_len = load_pretrained_model(args.model_path, args.model_base, model_name, args.load_8bit, args.load_4bit, device=args.device)
+
+    # if "llama-2" in model_name.lower():
+    #     conv_mode = "llava_llama_2"
+    # elif "mistral" in model_name.lower():
+    #     conv_mode = "mistral_instruct"
+    # elif "v1.6-34b" in model_name.lower():
+    #     conv_mode = "chatml_direct"
+    # elif "v1" in model_name.lower():
+    #     conv_mode = "llava_v1"
+    # elif "mpt" in model_name.lower():
+    #     conv_mode = "mpt"
+    # else:
+    #     conv_mode = "llava_v0"
+    conv_mode = "llava_v1" # fix conversation mode for now
+
+    if args.conv_mode is not None and conv_mode != args.conv_mode:
+        print('[WARNING] the auto inferred conversation mode is {}, while `--conv-mode` is {}, using {}'.format(conv_mode, args.conv_mode, args.conv_mode))
+    else:
+        args.conv_mode = conv_mode
+
+    conv = conv_templates[args.conv_mode].copy()
+    if "mpt" in model_name.lower():
+        roles = ('user', 'assistant')
+    else:
+        roles = conv.roles
+
+    image = load_image(args.image_file)
+    image_size = image.size
+    # Similar operation in model_worker.py
+    image_tensor = process_images([image], image_processor, model.config)
+    if type(image_tensor) is list:
+        image_tensor = [image.to(model.device, dtype=torch.float16) for image in image_tensor]
+    else:
+        image_tensor = image_tensor.to(model.device, dtype=torch.float16)
+
+    while True:
+        try:
+            inp = input(f"{roles[0]}: ")
+        except EOFError:
+            inp = ""
+        if not inp:
+            print("exit...")
+            break
+
+        print(f"{roles[1]}: ", end="")
+
+        if image is not None:
+            # first message
+            if model.config.mm_use_im_start_end:
+                inp = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n' + inp
+            else:
+                inp = DEFAULT_IMAGE_TOKEN + '\n' + inp
+            conv.append_message(conv.roles[0], inp)
+            image = None
+        else:
+            # later messages
+            conv.append_message(conv.roles[0], inp)
+        conv.append_message(conv.roles[1], None)
+        prompt = conv.get_prompt()
+
+        input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(model.device)
+        stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2
+        keywords = [stop_str]
+        streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+        with torch.inference_mode():
+            output_ids = model.generate(
+                input_ids,
+                images=image_tensor,
+                image_sizes=[image_size],
+                do_sample=True if args.temperature > 0 else False,
+                temperature=args.temperature,
+                max_new_tokens=args.max_new_tokens,
+                streamer=streamer,
+                use_cache=True)
+
+        outputs = tokenizer.decode(output_ids[0, input_ids.shape[1]:]).strip()
+        conv.messages[-1][-1] = outputs
+
+        if args.debug:
+            print("\n", {"prompt": prompt, "outputs": outputs}, "\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-path", type=str, default="facebook/opt-350m")
+    parser.add_argument("--model-base", type=str, default=None)
+    parser.add_argument("--image-file", type=str, required=True)
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--conv-mode", type=str, default=None)
+    parser.add_argument("--temperature", type=float, default=0.2)
+    parser.add_argument("--max-new-tokens", type=int, default=512)
+    parser.add_argument("--load-8bit", action="store_true")
+    parser.add_argument("--load-4bit", action="store_true")
+    parser.add_argument("--debug", action="store_true")
+    args = parser.parse_args()
+    main(args)

videollama2/serve/controller.py

@@ -0,0 +1,298 @@
+"""
+A controller manages distributed workers.
+It sends worker addresses to clients.
+"""
+import argparse
+import asyncio
+import dataclasses
+from enum import Enum, auto
+import json
+import logging
+import time
+from typing import List, Union
+import threading
+
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
+import numpy as np
+import requests
+import uvicorn
+
+from videollama2.constants import CONTROLLER_HEART_BEAT_EXPIRATION
+from videollama2.utils import build_logger, server_error_msg
+
+
+logger = build_logger("controller", "controller.log")
+
+
+class DispatchMethod(Enum):
+    LOTTERY = auto()
+    SHORTEST_QUEUE = auto()
+
+    @classmethod
+    def from_str(cls, name):
+        if name == "lottery":
+            return cls.LOTTERY
+        elif name == "shortest_queue":
+            return cls.SHORTEST_QUEUE
+        else:
+            raise ValueError(f"Invalid dispatch method")
+
+
+@dataclasses.dataclass
+class WorkerInfo:
+    model_names: List[str]
+    speed: int
+    queue_length: int
+    check_heart_beat: bool
+    last_heart_beat: str
+
+
+def heart_beat_controller(controller):
+    while True:
+        time.sleep(CONTROLLER_HEART_BEAT_EXPIRATION)
+        controller.remove_stable_workers_by_expiration()
+
+
+class Controller:
+    def __init__(self, dispatch_method: str):
+        # Dict[str -> WorkerInfo]
+        self.worker_info = {}
+        self.dispatch_method = DispatchMethod.from_str(dispatch_method)
+
+        self.heart_beat_thread = threading.Thread(
+            target=heart_beat_controller, args=(self,), daemon=True)
+        self.heart_beat_thread.start()
+
+        logger.info("Init controller")
+
+    def register_worker(self, worker_name: str, check_heart_beat: bool,
+                        worker_status: dict):
+        if worker_name not in self.worker_info:
+            logger.info(f"Register a new worker: {worker_name}")
+        else:
+            logger.info(f"Register an existing worker: {worker_name}")
+
+        if not worker_status:
+            worker_status = self.get_worker_status(worker_name)
+        if not worker_status:
+            return False
+
+        self.worker_info[worker_name] = WorkerInfo(
+            worker_status["model_names"], worker_status["speed"], worker_status["queue_length"],
+            check_heart_beat, time.time())
+
+        logger.info(f"Register done: {worker_name}, {worker_status}")
+        return True
+
+    def get_worker_status(self, worker_name: str):
+        try:
+            r = requests.post(worker_name + "/worker_get_status", timeout=5)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Get status fails: {worker_name}, {e}")
+            return None
+
+        if r.status_code != 200:
+            logger.error(f"Get status fails: {worker_name}, {r}")
+            return None
+
+        return r.json()
+
+    def remove_worker(self, worker_name: str):
+        del self.worker_info[worker_name]
+
+    def refresh_all_workers(self):
+        old_info = dict(self.worker_info)
+        self.worker_info = {}
+
+        for w_name, w_info in old_info.items():
+            if not self.register_worker(w_name, w_info.check_heart_beat, None):
+                logger.info(f"Remove stale worker: {w_name}")
+
+    def list_models(self):
+        model_names = set()
+
+        for w_name, w_info in self.worker_info.items():
+            model_names.update(w_info.model_names)
+
+        return list(model_names)
+
+    def get_worker_address(self, model_name: str):
+        if self.dispatch_method == DispatchMethod.LOTTERY:
+            worker_names = []
+            worker_speeds = []
+            for w_name, w_info in self.worker_info.items():
+                if model_name in w_info.model_names:
+                    worker_names.append(w_name)
+                    worker_speeds.append(w_info.speed)
+            worker_speeds = np.array(worker_speeds, dtype=np.float32)
+            norm = np.sum(worker_speeds)
+            if norm < 1e-4:
+                return ""
+            worker_speeds = worker_speeds / norm
+            if True:  # Directly return address
+                pt = np.random.choice(np.arange(len(worker_names)),
+                    p=worker_speeds)
+                worker_name = worker_names[pt]
+                return worker_name
+
+            # Check status before returning
+            while True:
+                pt = np.random.choice(np.arange(len(worker_names)),
+                    p=worker_speeds)
+                worker_name = worker_names[pt]
+
+                if self.get_worker_status(worker_name):
+                    break
+                else:
+                    self.remove_worker(worker_name)
+                    worker_speeds[pt] = 0
+                    norm = np.sum(worker_speeds)
+                    if norm < 1e-4:
+                        return ""
+                    worker_speeds = worker_speeds / norm
+                    continue
+            return worker_name
+        elif self.dispatch_method == DispatchMethod.SHORTEST_QUEUE:
+            worker_names = []
+            worker_qlen = []
+            for w_name, w_info in self.worker_info.items():
+                if model_name in w_info.model_names:
+                    worker_names.append(w_name)
+                    worker_qlen.append(w_info.queue_length / w_info.speed)
+            if len(worker_names) == 0:
+                return ""
+            min_index = np.argmin(worker_qlen)
+            w_name = worker_names[min_index]
+            self.worker_info[w_name].queue_length += 1
+            logger.info(f"names: {worker_names}, queue_lens: {worker_qlen}, ret: {w_name}")
+            return w_name
+        else:
+            raise ValueError(f"Invalid dispatch method: {self.dispatch_method}")
+
+    def receive_heart_beat(self, worker_name: str, queue_length: int):
+        if worker_name not in self.worker_info:
+            logger.info(f"Receive unknown heart beat. {worker_name}")
+            return False
+
+        self.worker_info[worker_name].queue_length = queue_length
+        self.worker_info[worker_name].last_heart_beat = time.time()
+        logger.info(f"Receive heart beat. {worker_name}")
+        return True
+
+    def remove_stable_workers_by_expiration(self):
+        expire = time.time() - CONTROLLER_HEART_BEAT_EXPIRATION
+        to_delete = []
+        for worker_name, w_info in self.worker_info.items():
+            if w_info.check_heart_beat and w_info.last_heart_beat < expire:
+                to_delete.append(worker_name)
+
+        for worker_name in to_delete:
+            self.remove_worker(worker_name)
+
+    def worker_api_generate_stream(self, params):
+        worker_addr = self.get_worker_address(params["model"])
+        if not worker_addr:
+            logger.info(f"no worker: {params['model']}")
+            ret = {
+                "text": server_error_msg,
+                "error_code": 2,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+
+        try:
+            response = requests.post(worker_addr + "/worker_generate_stream",
+                json=params, stream=True, timeout=5)
+            for chunk in response.iter_lines(decode_unicode=False, delimiter=b"\0"):
+                if chunk:
+                    yield chunk + b"\0"
+        except requests.exceptions.RequestException as e:
+            logger.info(f"worker timeout: {worker_addr}")
+            ret = {
+                "text": server_error_msg,
+                "error_code": 3,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+
+
+    # Let the controller act as a worker to achieve hierarchical
+    # management. This can be used to connect isolated sub networks.
+    def worker_api_get_status(self):
+        model_names = set()
+        speed = 0
+        queue_length = 0
+
+        for w_name in self.worker_info:
+            worker_status = self.get_worker_status(w_name)
+            if worker_status is not None:
+                model_names.update(worker_status["model_names"])
+                speed += worker_status["speed"]
+                queue_length += worker_status["queue_length"]
+
+        return {
+            "model_names": list(model_names),
+            "speed": speed,
+            "queue_length": queue_length,
+        }
+
+
+app = FastAPI()
+
+
+@app.post("/register_worker")
+async def register_worker(request: Request):
+    data = await request.json()
+    controller.register_worker(
+        data["worker_name"], data["check_heart_beat"],
+        data.get("worker_status", None))
+
+
+@app.post("/refresh_all_workers")
+async def refresh_all_workers():
+    models = controller.refresh_all_workers()
+
+
+@app.post("/list_models")
+async def list_models():
+    models = controller.list_models()
+    return {"models": models}
+
+
+@app.post("/get_worker_address")
+async def get_worker_address(request: Request):
+    data = await request.json()
+    addr = controller.get_worker_address(data["model"])
+    return {"address": addr}
+
+
+@app.post("/receive_heart_beat")
+async def receive_heart_beat(request: Request):
+    data = await request.json()
+    exist = controller.receive_heart_beat(
+        data["worker_name"], data["queue_length"])
+    return {"exist": exist}
+
+
+@app.post("/worker_generate_stream")
+async def worker_api_generate_stream(request: Request):
+    params = await request.json()
+    generator = controller.worker_api_generate_stream(params)
+    return StreamingResponse(generator)
+
+
+@app.post("/worker_get_status")
+async def worker_api_get_status(request: Request):
+    return controller.worker_api_get_status()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="localhost")
+    parser.add_argument("--port", type=int, default=21001)
+    parser.add_argument("--dispatch-method", type=str, choices=[
+        "lottery", "shortest_queue"], default="shortest_queue")
+    args = parser.parse_args()
+    logger.info(f"args: {args}")
+
+    controller = Controller(args.dispatch_method)
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")

videollama2/serve/gradio_web_server.py

@@ -0,0 +1,503 @@
+import os
+import json
+import time
+import hashlib
+import requests
+import argparse
+import datetime
+
+import numpy as np
+import gradio as gr
+from decord import VideoReader, cpu
+
+from videollama2.constants import LOGDIR, NUM_FRAMES
+from videollama2.conversation import (default_conversation, conv_templates,SeparatorStyle)
+from videollama2.utils import (build_logger, server_error_msg, violates_moderation, moderation_msg)
+
+
+logger = build_logger("gradio_web_server", "gradio_web_server.log")
+
+headers = {"User-Agent": "Videollama2 Client"}
+
+no_change_btn = gr.Button.update()
+enable_btn = gr.Button.update(interactive=True)
+disable_btn = gr.Button.update(interactive=False)
+
+priority = {
+    "vicuna-13b": "aaaaaaa",
+    "koala-13b": "aaaaaab",
+}
+
+
+def get_conv_log_filename():
+    t = datetime.datetime.now()
+    name = os.path.join(LOGDIR, f"{t.year}-{t.month:02d}-{t.day:02d}-conv.json")
+    return name
+
+
+def get_model_list():
+    ret = requests.post(args.controller_url + "/refresh_all_workers")
+    assert ret.status_code == 200
+    ret = requests.post(args.controller_url + "/list_models")
+    models = ret.json()["models"]
+    models.sort(key=lambda x: priority.get(x, x))
+    logger.info(f"Models: {models}")
+    return models
+
+
+get_window_url_params = """
+function() {
+    const params = new URLSearchParams(window.location.search);
+    url_params = Object.fromEntries(params);
+    console.log(url_params);
+    return url_params;
+    }
+"""
+
+
+def load_demo(url_params, request: gr.Request):
+    logger.info(f"load_demo. ip: {request.client.host}. params: {url_params}")
+
+    dropdown_update = gr.Dropdown.update(visible=True)
+    if "model" in url_params:
+        model = url_params["model"]
+        if model in models:
+            dropdown_update = gr.Dropdown.update(
+                value=model, visible=True)
+
+    state = default_conversation.copy()
+    return state, dropdown_update
+
+
+def load_demo_refresh_model_list(request: gr.Request):
+    logger.info(f"load_demo. ip: {request.client.host}")
+    models = get_model_list()
+    state = default_conversation.copy()
+    dropdown_update = gr.Dropdown.update(
+        choices=models,
+        value=models[0] if len(models) > 0 else ""
+    )
+    return state, dropdown_update
+
+
+def vote_last_response(state, vote_type, model_selector, request: gr.Request):
+    with open(get_conv_log_filename(), "a") as fout:
+        data = {
+            "tstamp": round(time.time(), 4),
+            "type": vote_type,
+            "model": model_selector,
+            "state": state.dict(),
+            "ip": request.client.host,
+        }
+        fout.write(json.dumps(data) + "\n")
+
+
+def upvote_last_response(state, model_selector, request: gr.Request):
+    logger.info(f"upvote. ip: {request.client.host}")
+    vote_last_response(state, "upvote", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+
+def downvote_last_response(state, model_selector, request: gr.Request):
+    logger.info(f"downvote. ip: {request.client.host}")
+    vote_last_response(state, "downvote", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+
+def flag_last_response(state, model_selector, request: gr.Request):
+    logger.info(f"flag. ip: {request.client.host}")
+    vote_last_response(state, "flag", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+
+def regenerate(state, image_process_mode, request: gr.Request):
+    logger.info(f"regenerate. ip: {request.client.host}")
+    state.messages[-1][-1] = None
+    prev_human_msg = state.messages[-2]
+    if type(prev_human_msg[1]) in (tuple, list):
+        prev_human_msg[1] = (*prev_human_msg[1][:2], image_process_mode)
+    state.skip_next = False
+    # (state, chatbot, textbox, imagebox, videobox, upvote, downvote, flag, generate, clear)
+    return (state, state.to_gradio_chatbot(), "", None, None) + (disable_btn,) * 5
+
+
+def clear_history(request: gr.Request):
+    logger.info(f"clear_history. ip: {request.client.host}")
+    state = default_conversation.copy()
+    # (state, chatbot, textbox, imagebox, videobox, upvote, downvote, flag, generate, clear)
+    return (state, state.to_gradio_chatbot(), "", None, None) + (disable_btn,) * 5
+
+
+def add_text_ori(state, text, image, video, image_process_mode, request: gr.Request):
+    # note: imagebox itself is PIL object while videobox is filepath
+    logger.info(f"add_text. ip: {request.client.host}. len: {len(text)}")
+    if len(text) <= 0 and image is None:
+        state.skip_next = True
+        return (state, state.to_gradio_chatbot(), "", None) + (no_change_btn,) * 5
+    if args.moderate:
+        flagged = violates_moderation(text)
+        if flagged:
+            state.skip_next = True
+            return (state, state.to_gradio_chatbot(), moderation_msg, None) + (
+                no_change_btn,) * 5
+    assert image is None or video is None, "Please don't feed image and video inputs at the same time!!!"
+    text = text[:1536]  # Hard cut-off
+    if image is not None:
+        # here image is the PIL object itself
+        text = text[:1200]  # Hard cut-off for images
+        if '<image>' not in text:
+            # text = '<Image><image></Image>' + text
+            text = text + '\n<image>'
+        text = (text, image, image_process_mode)
+        if len(state.get_images(return_pil=True)) > 0:
+            state = default_conversation.copy()
+        state.modality = "image"
+    if video is not None:
+        print("Video box:", video)
+        # here video is the file path of video
+        text = text[:1200]  # Hard cut-off for images
+        if '<video>' not in text:
+            # text = '<Image><image></Image>' + text
+            text = text + '\n<video>'
+        text = (text, video, image_process_mode)
+        if len(state.get_videos(return_pil=True)) > 0:
+            state = default_conversation.copy()
+        state.modality = "video"
+        print("Set modality as video...")
+    state.append_message(state.roles[0], text)
+    state.append_message(state.roles[1], None)
+    state.skip_next = False
+    # (state, chatbot, textbox, imagebox, videobox, upvote, downvote, flag, generate, clear)
+    return (state, state.to_gradio_chatbot(), "", None, None) + (disable_btn,) * 5
+
+
+def add_text(state, text, image, video, image_process_mode, request: gr.Request):
+    logger.info(f"add_text. ip: {request.client.host}. len: {len(text)}")
+
+    # if input is new video or image ,reset the state
+    if image is not None or video is not None:
+        state = default_conversation.copy()
+
+    if len(text) <= 0 and image is None and video is None:
+        state.skip_next = True
+        return (state, state.to_gradio_chatbot(), "", None, None) + (no_change_btn,) * 5
+
+    if args.moderate:
+        flagged = violates_moderation(text)
+        if flagged:
+            state.skip_next = True
+            return (state, state.to_gradio_chatbot(), moderation_msg, None) + (no_change_btn,) * 5
+
+    # process the input video
+    if video is not None:
+        text = text[:1200]  # 
+        if '<video>' not in text:
+            text = text + '\n<video>'
+        text = (text, video, image_process_mode)
+        state.modality = "video"
+    # process the input image
+    elif image is not None:
+        text = text[:1200]  # 
+        if '<image>' not in text:
+            text = text + '\n<image>'
+        text = (text, image, image_process_mode)
+        state.modality = "image"
+    elif state.modality == "image" and len(text)>0:
+        state.modality = "image_text"  
+        text = text[:1536]  # Hard cut-off
+    elif state.modality == "video" and len(text)>0:
+        state.modality = "video_text"  
+        text = text[:1536]  # Hard cut-off
+
+    state.append_message(state.roles[0], text)
+    state.append_message(state.roles[1], None)
+    state.skip_next = False
+
+    return (state, state.to_gradio_chatbot(), "", None, None) + (disable_btn,) * 5
+
+
+def http_bot(state, model_selector, temperature, top_p, max_new_tokens, request: gr.Request):
+    logger.info(f"http_bot. ip: {request.client.host}")
+    start_tstamp = time.time()
+    model_name = model_selector
+
+    if state.skip_next:
+        # This generate call is skipped due to invalid inputs
+        yield (state, state.to_gradio_chatbot()) + (no_change_btn,) * 5
+        return
+
+    if len(state.messages) == state.offset + 2:
+        # First round of conversation
+        if "llava" in model_name.lower():
+            if 'llama-2' in model_name.lower():
+                template_name = "llava_llama_2"
+            elif "v1" in model_name.lower():
+                if 'mmtag' in model_name.lower():
+                    template_name = "v1_mmtag"
+                elif 'plain' in model_name.lower() and 'finetune' not in model_name.lower():
+                    template_name = "v1_mmtag"
+                else:
+                    template_name = "llava_v1"
+            elif "mpt" in model_name.lower():
+                template_name = "mpt"
+            else:
+                if 'mmtag' in model_name.lower():
+                    template_name = "v0_mmtag"
+                elif 'plain' in model_name.lower() and 'finetune' not in model_name.lower():
+                    template_name = "v0_mmtag"
+                else:
+                    template_name = "llava_v0"
+        elif "mpt" in model_name:
+            template_name = "mpt_text"
+        elif "llama-2" in model_name:
+            template_name = "llama_2"
+        else:
+            template_name = "vicuna_v1"
+        template_name = "llava_v1"
+        new_state = conv_templates[template_name].copy()
+        new_state.append_message(new_state.roles[0], state.messages[-2][1])
+        new_state.append_message(new_state.roles[1], None)
+        new_state.modality = state.modality
+        state = new_state
+
+    # Query worker address
+    controller_url = args.controller_url
+    ret = requests.post(controller_url + "/get_worker_address",
+            json={"model": model_name})
+    worker_addr = ret.json()["address"]
+    logger.info(f"model_name: {model_name}, worker_addr: {worker_addr}")
+
+    # No available worker
+    if worker_addr == "":
+        state.messages[-1][-1] = server_error_msg
+        yield (state, state.to_gradio_chatbot(), disable_btn, disable_btn, disable_btn, enable_btn, enable_btn)
+        return
+
+    # Construct prompt
+    prompt = state.get_prompt()
+    if state.modality == "image" or state.modality == "image_text":
+        all_images = state.get_images(return_pil=True) # return PIL.Image object
+    elif state.modality == "video" or state.modality == "video_text":
+        all_images = state.get_videos(return_pil=True) # return video frames where each frame is a PIL.Image object
+    all_image_hash = [hashlib.md5(image.tobytes()).hexdigest() for image in all_images]
+    for idx, (image, hash) in enumerate(zip(all_images, all_image_hash)):
+        t = datetime.datetime.now()
+        if state.modality == "image" or state.modality == "image_text":
+            filename = os.path.join(LOGDIR, "serve_images", f"{t.year}-{t.month:02d}-{t.day:02d}", f"{hash}.jpg")
+        elif state.modality == "video" or state.modality == "video_text":
+            filename = os.path.join(LOGDIR, "serve_videos", f"{t.year}-{t.month:02d}-{t.day:02d}", f"{hash}_{idx}.jpg")
+        if not os.path.isfile(filename):
+            os.makedirs(os.path.dirname(filename), exist_ok=True)
+            image.save(filename)
+
+    # Make requests
+    pload = {
+        "model": model_name,
+        "prompt": prompt,
+        "temperature": float(temperature),
+        "top_p": float(top_p),
+        "max_new_tokens": min(int(max_new_tokens), 1536),
+        "stop": state.sep if state.sep_style in [SeparatorStyle.SINGLE, SeparatorStyle.MPT] else state.sep2,
+        #"images": f'List of {len(state.get_images())} images: {all_image_hash}',
+        "images": f'List of {len(all_image_hash)} images: {all_image_hash}',
+    }
+    logger.info(f"==== request ====\n{pload}")
+
+    if state.modality == "image" or state.modality == "image_text":
+        pload['images'] = state.get_images()
+    elif state.modality == "video" or state.modality == "video_text":
+        pload['images'] = state.get_videos()
+
+    state.messages[-1][-1] = "▌"
+    yield (state, state.to_gradio_chatbot()) + (disable_btn,) * 5
+
+    try:
+        # Stream output
+        response = requests.post(worker_addr + "/worker_generate_stream",
+            headers=headers, json=pload, stream=True, timeout=10)
+        for chunk in response.iter_lines(decode_unicode=False, delimiter=b"\0"):
+            if chunk:
+                data = json.loads(chunk.decode())
+                if data["error_code"] == 0:
+                    output = data["text"][len(prompt):].strip()
+                    state.messages[-1][-1] = output + "▌"
+                    yield (state, state.to_gradio_chatbot()) + (disable_btn,) * 5
+                else:
+                    output = data["text"] + f" (error_code: {data['error_code']})"
+                    state.messages[-1][-1] = output
+                    yield (state, state.to_gradio_chatbot()) + (disable_btn, disable_btn, disable_btn, enable_btn, enable_btn)
+                    return
+                time.sleep(0.03)
+    except requests.exceptions.RequestException as e:
+        state.messages[-1][-1] = server_error_msg
+        yield (state, state.to_gradio_chatbot()) + (disable_btn, disable_btn, disable_btn, enable_btn, enable_btn)
+        return
+
+    state.messages[-1][-1] = state.messages[-1][-1][:-1]
+    yield (state, state.to_gradio_chatbot()) + (enable_btn,) * 5
+
+    finish_tstamp = time.time()
+    logger.info(f"{output}")
+
+    with open(get_conv_log_filename(), "a") as fout:
+        data = {
+            "tstamp": round(finish_tstamp, 4),
+            "type": "chat",
+            "model": model_name,
+            "start": round(start_tstamp, 4),
+            "finish": round(start_tstamp, 4),
+            #"state": state.dict(),
+            "images": all_image_hash,
+            "ip": request.client.host,
+        }
+        fout.write(json.dumps(data) + "\n")
+
+title_markdown = ("""
+# The publicl release of VideoLLaMA2
+""")
+
+tos_markdown = ("""
+### Terms of use
+By using this service, users are required to agree to the following terms:
+The service is a research preview intended for non-commercial use only. It only provides limited safety measures and may generate offensive content. It must not be used for any illegal, harmful, violent, racist, or sexual purposes. The service may collect user dialogue data for future research.
+Please click the "Flag" button if you get any inappropriate answer! We will collect those to keep improving our moderator.
+For an optimal experience, please use desktop computers for this demo, as mobile devices may compromise its quality.
+""")
+
+
+learn_more_markdown = ("""
+### License
+The service is a research preview intended for non-commercial use only, subject to the model [License](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md) of LLaMA, [Terms of Use](https://openai.com/policies/terms-of-use) of the data generated by OpenAI, and [Privacy Practices](https://chrome.google.com/webstore/detail/sharegpt-share-your-chatg/daiacboceoaocpibfodeljbdfacokfjb) of ShareGPT. Please contact us if you find any potential violation.
+""")
+
+block_css = """
+
+#buttons button {
+    min-width: min(120px,100%);
+}
+
+"""
+
+def build_demo(embed_mode):
+    textbox = gr.Textbox(show_label=False, placeholder="Enter text and press ENTER", container=False)
+    with gr.Blocks(title="Video-Llama", theme=gr.themes.Default(), css=block_css) as demo:
+        state = gr.State()
+
+        if not embed_mode:
+            gr.Markdown(title_markdown)
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                with gr.Row(elem_id="model_selector_row"):
+                    model_selector = gr.Dropdown(
+                        choices=models,
+                        value=models[0] if len(models) > 0 else "",
+                        interactive=True,
+                        show_label=False,
+                        container=False)
+
+                imagebox = gr.Image(type="pil")
+                videobox = gr.Video()
+                image_process_mode = gr.Radio(
+                    ["Crop", "Resize", "Pad", "Default"],
+                    value="Default",
+                    label="Preprocess for non-square image", visible=False)
+
+                cur_dir = os.path.dirname(os.path.abspath(__file__))
+                gr.Examples(examples=[
+                    [f"{cur_dir}/examples/extreme_ironing.jpg", "What is unusual about this image?"],
+                    [f"{cur_dir}/examples/waterview.jpg", "What are the things I should be cautious about when I visit here?"],
+                    [f"{cur_dir}/examples/desert.jpg", "If there are factual errors in the questions, point it out; if not, proceed answering the question. What’s happening in the desert?"],
+                ], inputs=[imagebox, textbox], label="Image examples")
+
+                # video example inputs
+                gr.Examples(examples=[
+                [f"{cur_dir}/examples/sample_demo_1.mp4", "Why is this video funny?"],
+                [f"{cur_dir}/examples/sample_demo_3.mp4", "Can you identify any safety hazards in this video?"],
+                [f"{cur_dir}/examples/1034346401.mp4", "What is this young woman doing?"]
+                ], inputs=[videobox, textbox], label="Video examples")
+                #[f"{cur_dir}/examples/sample_demo_9.mp4", "Describe the video in detail and please do not generate repetitive content."]
+
+                with gr.Accordion("Parameters", open=False) as parameter_row:
+                    temperature = gr.Slider(minimum=0.0, maximum=1.0, value=0.2, step=0.1, interactive=True, label="Temperature",)
+                    top_p = gr.Slider(minimum=0.0, maximum=1.0, value=0.7, step=0.1, interactive=True, label="Top P",)
+                    max_output_tokens = gr.Slider(minimum=0, maximum=1024, value=512, step=64, interactive=True, label="Max output tokens",)
+
+            with gr.Column(scale=8):
+                chatbot = gr.Chatbot(elem_id="chatbot", label="Videollama2 Chatbot", height=550)
+                with gr.Row():
+                    with gr.Column(scale=8):
+                        textbox.render()
+                    with gr.Column(scale=1, min_width=50):
+                        submit_btn = gr.Button(value="Send", variant="primary")
+                with gr.Row(elem_id="buttons") as button_row:
+                    upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+                    downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+                    flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+                    #stop_btn = gr.Button(value="⏹️  Stop Generation", interactive=False)
+                    regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+                    clear_btn = gr.Button(value="🗑️  Clear", interactive=False)
+
+        if not embed_mode:
+            gr.Markdown(tos_markdown)
+            gr.Markdown(learn_more_markdown)
+        url_params = gr.JSON(visible=False)
+
+        # Register listeners
+        btn_list = [upvote_btn, downvote_btn, flag_btn, regenerate_btn, clear_btn]
+        upvote_btn.click(upvote_last_response,
+            [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn])
+        downvote_btn.click(downvote_last_response,
+            [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn])
+        flag_btn.click(flag_last_response,
+            [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn])
+        regenerate_btn.click(regenerate, [state, image_process_mode],
+            [state, chatbot, textbox, imagebox, videobox] + btn_list).then(
+            http_bot, [state, model_selector, temperature, top_p, max_output_tokens],
+            [state, chatbot] + btn_list)
+        clear_btn.click(clear_history, None, [state, chatbot, textbox, imagebox, videobox] + btn_list)
+
+        textbox.submit(add_text, [state, textbox, imagebox, videobox, image_process_mode], [state, chatbot, textbox, imagebox, videobox] + btn_list
+            ).then(http_bot, [state, model_selector, temperature, top_p, max_output_tokens],
+                   [state, chatbot] + btn_list)
+        submit_btn.click(add_text, [state, textbox, imagebox, videobox, image_process_mode], [state, chatbot, textbox, imagebox, videobox] + btn_list
+            ).then(http_bot, [state, model_selector, temperature, top_p, max_output_tokens],
+                   [state, chatbot] + btn_list)
+
+        if args.model_list_mode == "once":
+            demo.load(load_demo, [url_params], [state, model_selector],
+                _js=get_window_url_params)
+        elif args.model_list_mode == "reload":
+            demo.load(load_demo_refresh_model_list, None, [state, model_selector])
+        else:
+            raise ValueError(f"Unknown model list mode: {args.model_list_mode}")
+
+    return demo
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="0.0.0.0")
+    parser.add_argument("--port", type=int)
+    parser.add_argument("--controller-url", type=str, default="http://localhost:21001")
+    parser.add_argument("--concurrency-count", type=int, default=10)
+    parser.add_argument("--model-list-mode", type=str, default="once",
+        choices=["once", "reload"])
+    parser.add_argument("--share", action="store_true")
+    parser.add_argument("--moderate", action="store_true")
+    parser.add_argument("--embed", action="store_true")
+    args = parser.parse_args()
+    logger.info(f"args: {args}")
+
+    models = get_model_list()
+
+    logger.info(args)
+    demo = build_demo(args.embed)
+    demo.queue(
+        concurrency_count=args.concurrency_count,
+        api_open=False
+    ).launch(
+        server_name=args.host,
+        server_port=args.port,
+        share=args.share
+    )

videollama2/serve/model_worker.py

@@ -0,0 +1,397 @@
+"""
+A model worker executes the model.
+"""
+import os
+import json
+import time
+import uuid
+import asyncio
+import requests
+import argparse
+import threading
+from threading import Thread
+from functools import partial
+from typing import Iterator, List, Optional, Tuple
+
+import uvicorn
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.responses import StreamingResponse
+
+import torch
+import decord
+import numpy as np
+from PIL import Image
+from decord import VideoReader, cpu
+from transformers import TextIteratorStreamer
+
+from videollama2.constants import WORKER_HEART_BEAT_INTERVAL
+from videollama2.utils import (build_logger, server_error_msg, pretty_print_semaphore)
+from videollama2.model.builder import load_pretrained_model
+from videollama2.mm_utils import process_images, process_videos, load_image_from_base64, tokenizer_image_token, KeywordsStoppingCriteria, tokenizer_MMODAL_token
+from videollama2.mm_utils import chunk_list, frame_expansion
+from videollama2.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN, DEFAULT_VIDEO_TOKEN, NUM_FRAMES, MMODAL_TOKEN_INDEX
+
+
+GB = 1 << 30
+
+worker_id = str(uuid.uuid4())[:6]
+logger = build_logger("model_worker", f"model_worker_{worker_id}.log")
+global_counter = 0
+
+model_semaphore = None
+
+
+# variable_content = os.getenv('MY_VARIABLE', '')
+# KEYWORDS_LIST = set(variable_content.split('\n'))
+KEYWORDS_LIST = []
+path = 'assets/keywords.txt'
+if os.path.exists(path):
+    with open(path, 'r', encoding='utf-8') as file:
+        for line in file:
+            
+            KEYWORDS_LIST.append(line.strip()) 
+else:
+    KEYWORDS_LIST = []
+
+
+KEYWORD_BLOCK_MESSAGE2 = "The output contains political, erotic and other unsafe content that violates local laws. Please re-enter your question."
+KEYWORD_BLOCK_MESSAGE1 = "Your input question contains political, erotic and other unsafe content that violates local laws. Please re-enter your question."
+STREAM_CHECK_MULTIPLE = 20
+
+
+def heart_beat_worker(controller):
+
+    while True:
+        time.sleep(WORKER_HEART_BEAT_INTERVAL)
+        controller.send_heart_beat()
+
+
+def safety_check(text, history=None, ) -> Optional[str]:
+
+    if len(KEYWORDS_LIST) > 0 and any(x in text.lower() for x in KEYWORDS_LIST):
+        print('############')
+        return KEYWORD_BLOCK_MESSAGE2
+    
+    return None
+
+
+def input_safety_check(text) -> Optional[str]:
+    if len(KEYWORDS_LIST) > 0 and any(x in text.lower() for x in KEYWORDS_LIST):
+        print('######## Input keyword alarm triggered:', text)
+        return KEYWORD_BLOCK_MESSAGE1
+    return None
+
+
+class ModelWorker:
+
+    def __init__(self, controller_addr, worker_addr,
+                 worker_id, no_register,
+                 model_path, model_base, model_name,
+                 load_8bit, load_4bit, device):
+        self.controller_addr = controller_addr
+        self.worker_addr = worker_addr
+        self.worker_id = worker_id
+        self.model_path = model_path
+        if model_path.endswith("/"):
+            model_path = model_path[:-1]
+        if model_name is None:
+            model_paths = model_path.split("/")
+            if model_paths[-1].startswith('checkpoint-'):
+                self.model_name = model_paths[-2] + "_" + model_paths[-1]
+            else:
+                self.model_name = model_paths[-1]
+        else:
+            self.model_name = model_name
+
+        self.device = device
+        logger.info(f"Loading the model {self.model_name} on worker {worker_id} ...")
+        self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model(
+            model_path, model_base, self.model_name, load_8bit, load_4bit, device=self.device)
+        self.is_multimodal = 'videollama2' in self.model_name.lower() or 'vlb' in self.model_name.lower()
+
+        if not no_register:
+            self.register_to_controller()
+            self.heart_beat_thread = threading.Thread(
+                target=heart_beat_worker, args=(self,))
+            self.heart_beat_thread.start()
+
+    def register_to_controller(self):
+        logger.info("Register to controller")
+
+        url = self.controller_addr + "/register_worker"
+        data = {
+            "worker_name": self.worker_addr,
+            "check_heart_beat": True,
+            "worker_status": self.get_status()
+        }
+        r = requests.post(url, json=data)
+        assert r.status_code == 200
+
+    def send_heart_beat(self):
+        logger.info(f"Send heart beat. Models: {[self.model_name]}. "
+                    f"Semaphore: {pretty_print_semaphore(model_semaphore)}. "
+                    f"global_counter: {global_counter}")
+
+        url = self.controller_addr + "/receive_heart_beat"
+
+        while True:
+            try:
+                ret = requests.post(url, json={
+                    "worker_name": self.worker_addr,
+                    "queue_length": self.get_queue_length()}, timeout=5)
+                exist = ret.json()["exist"]
+                break
+            except requests.exceptions.RequestException as e:
+                logger.error(f"heart beat error: {e}")
+            time.sleep(5)
+
+        if not exist:
+            self.register_to_controller()
+
+    def get_queue_length(self):
+        if model_semaphore is None:
+            return 0
+        else:
+            return args.limit_model_concurrency - model_semaphore._value + (len(
+                model_semaphore._waiters) if model_semaphore._waiters is not None else 0)
+
+    def get_status(self):
+        return {
+            "model_names": [self.model_name],
+            "speed": 1,
+            "queue_length": self.get_queue_length(),
+        }
+
+    @torch.inference_mode()
+    def generate_stream(self, params):
+        tokenizer, model, image_processor = self.tokenizer, self.model, self.image_processor
+
+        prompt = params["prompt"]
+        ori_prompt = prompt
+        images_or_videos = params.get("images", None)
+        #print("Input images:", images_or_videos)
+        num_image_tokens = 0
+        modal_list = []
+        if images_or_videos is not None and len(images_or_videos) and self.is_multimodal:
+            if len(images_or_videos) > 0:
+                if len(images_or_videos) != prompt.count(DEFAULT_IMAGE_TOKEN) and len(images_or_videos) != (prompt.count(DEFAULT_VIDEO_TOKEN)):
+                    raise ValueError("Number of images/videos does not match number of <image>/<video> tokens in prompt")
+                
+                try:
+                    print("Load image...")
+                    images_or_videos = [load_image_from_base64(image) for image in images_or_videos]
+                    images_or_videos = process_images(images_or_videos, image_processor, model.config)
+                    
+                    modal_list = ["image"]
+                    replace_token = DEFAULT_IMAGE_TOKEN
+                    modal_token_index = MMODAL_TOKEN_INDEX["IMAGE"]
+                except:
+                    print("Load video instead...")
+                    decord_vr = VideoReader(uri=images_or_videos[0], ctx=cpu(0))
+                    duration = len(decord_vr)
+                    if not "use_taug" in self.model_path:
+                        frame_id_list = np.linspace(0, duration-1, 8, dtype=int)
+                        video_frames = decord_vr.get_batch(frame_id_list).asnumpy()
+                        images_or_videos = process_videos(video_frames, image_processor, model.config)
+                    else:
+                        print("Temporal augmentation activated!!!")
+                        frame_id_list = np.linspace(0, duration-1, 8 * 2 * 2, dtype=int)
+                        video_data = decord_vr.get_batch(frame_id_list)
+                        video_frames = [Image.fromarray(f) for f in video_data.asnumpy()]
+                        chunked_video_frames = chunk_list(video_frames, 2*2)
+                        expanded_video_frames = [frame_expansion(frame_list, 2) for frame_list in chunked_video_frames]
+                        images_or_videos = process_videos(expanded_video_frames, image_processor, model.config)
+
+                    # frame_id_list = np.linspace(0, duration-1, NUM_FRAMES, dtype=int)
+                    # images_or_videos = decord_vr.get_batch(frame_id_list).asnumpy()
+                    # images_or_videos = process_videos(images_or_videos, image_processor, model.config)
+                    #print("images_or_videos.shape:", images_or_videos.shape)
+                    modal_list = ["video"]
+                    replace_token = DEFAULT_VIDEO_TOKEN
+                    modal_token_index = MMODAL_TOKEN_INDEX["VIDEO"]
+                
+                if type(images_or_videos) is list:
+                    images_or_videos = [image.to(self.model.device, dtype=torch.float16) for image in images_or_videos]
+                else:
+                    images_or_videos = images_or_videos.to(self.model.device, dtype=torch.float16)
+                    if modal_list[0] == "video":
+                        print("Video:", images_or_videos.shape)
+                        images_or_videos = [images_or_videos]
+                    else:
+                        print("Image:", images_or_videos.shape)
+
+
+                #image_sizes = [image.size for image in images_or_videos]
+                
+
+                # if len(images_or_videos) % NUM_FRAMES == 0:
+                #     images_or_videos = process_images(images_or_videos, image_processor, model.config)
+                #     #images_or_videos = [image.to(self.model.device, dtype=torch.float16) for image in images_or_videos]
+                #     #modal_list = ["image"] * len(images_or_videos)
+                #     images_or_videos = images_or_videos.to(self.model.device, dtype=torch.float16)
+                #     modal_list = ["video"]
+                #     replace_token = DEFAULT_VIDEO_TOKEN
+                # else:
+                    
+                if getattr(self.model.config, 'mm_use_im_start_end', False):
+                    replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN
+                prompt = prompt.replace(DEFAULT_IMAGE_TOKEN, replace_token)
+
+                num_image_tokens = prompt.count(replace_token) * model.get_vision_tower().num_patches
+            else:
+                images = None
+                modal_list = []
+            image_args = {"images_or_videos": images_or_videos, "modal_list": modal_list}
+        else:
+            images = None
+            image_args = {}
+        print("image_args:", image_args)
+        temperature = float(params.get("temperature", 1.0))
+        top_p = float(params.get("top_p", 1.0))
+        max_context_length = getattr(model.config, 'max_position_embeddings', 2048)
+        max_new_tokens = min(int(params.get("max_new_tokens", 256)), 1024)
+        stop_str = params.get("stop", None)
+        do_sample = True if temperature > 0.001 else False
+
+        #input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(self.device)
+        # tokenizer for our video-llama beta
+        input_ids = tokenizer_MMODAL_token(prompt, tokenizer, modal_token_index, return_tensors='pt').unsqueeze(0).to(self.device)
+        #print("Current prompt:", prompt)
+        #print("input_ids.shape:", input_ids.shape)
+        keywords = [stop_str]
+        stopping_criteria = KeywordsStoppingCriteria(keywords, tokenizer, input_ids)
+        streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True, timeout=15)
+
+        max_new_tokens = min(max_new_tokens, max_context_length - input_ids.shape[-1] - num_image_tokens)
+
+        if max_new_tokens < 1:
+            yield json.dumps({"text": ori_prompt + "Exceeds max token length. Please start a new conversation, thanks.", "error_code": 0}).encode() + b"\0"
+            return
+
+        thread = Thread(target=model.generate, kwargs=dict(
+            inputs=input_ids,
+            do_sample=do_sample,
+            temperature=temperature,
+            top_p=top_p,
+            max_new_tokens=max_new_tokens,
+            streamer=streamer,
+            stopping_criteria=[stopping_criteria],
+            use_cache=True,
+            **image_args
+        ))
+        thread.start()
+
+        generated_text = ori_prompt
+        token_count = 0
+        for new_text in streamer:
+            generated_text += new_text
+            token_count += len(tokenizer.encode(new_text))
+            if token_count >= STREAM_CHECK_MULTIPLE:
+                safety_message = safety_check(generated_text)
+                if safety_message:
+                    print('####### Keyword alarm triggered:', generated_text)
+                    yield json.dumps({"text": safety_message , "error_code": 1}).encode() + b"\0"
+                    return  
+                token_count = 0  # 
+                
+
+            if generated_text.endswith(stop_str):
+                generated_text = generated_text[:-len(stop_str)]
+            yield json.dumps({"text": generated_text, "error_code": 0}).encode() + b"\0"
+
+    def generate_stream_gate(self, params):
+        try:      
+            input_text = params.get("prompt", "")
+            safety_message = input_safety_check(input_text)
+            if safety_message:
+                yield json.dumps({"text": safety_message, "error_code": 1}).encode() + b"\0"
+                return
+
+            for x in self.generate_stream(params):
+                yield x
+        except ValueError as e:
+            print("Caught ValueError:", e)
+            ret = {
+                "text": server_error_msg,
+                "error_code": 1,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+        except torch.cuda.CudaError as e:
+            print("Caught torch.cuda.CudaError:", e)
+            ret = {
+                "text": server_error_msg,
+                "error_code": 1,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+        except Exception as e:
+            print("Caught Unknown Error", e)
+            ret = {
+                "text": server_error_msg,
+                "error_code": 1,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+
+
+app = FastAPI()
+
+
+def release_model_semaphore(fn=None):
+    model_semaphore.release()
+    if fn is not None:
+        fn()
+
+
+@app.post("/worker_generate_stream")
+async def generate_stream(request: Request):
+    global model_semaphore, global_counter
+    global_counter += 1
+    params = await request.json()
+
+    if model_semaphore is None:
+        model_semaphore = asyncio.Semaphore(args.limit_model_concurrency)
+    await model_semaphore.acquire()
+    worker.send_heart_beat()
+    generator = worker.generate_stream_gate(params)
+    background_tasks = BackgroundTasks()
+    background_tasks.add_task(partial(release_model_semaphore, fn=worker.send_heart_beat))
+    return StreamingResponse(generator, background=background_tasks)
+
+
+@app.post("/worker_get_status")
+async def get_status(request: Request):
+    return worker.get_status()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="localhost")
+    parser.add_argument("--port", type=int, default=21002)
+    parser.add_argument("--worker-address", type=str, default="http://localhost:21002")
+    parser.add_argument("--controller-address", type=str, default="http://localhost:21001")
+    parser.add_argument("--model-path", type=str, default="facebook/opt-350m")
+    parser.add_argument("--model-base", type=str, default=None)
+    parser.add_argument("--model-name", type=str)
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--multi-modal", action="store_true", help="Multimodal mode is automatically detected with model name, please make sure `llava` is included in the model path.")
+    parser.add_argument("--limit-model-concurrency", type=int, default=5)
+    parser.add_argument("--stream-interval", type=int, default=1)
+    parser.add_argument("--no-register", action="store_true")
+    parser.add_argument("--load-8bit", action="store_true")
+    parser.add_argument("--load-4bit", action="store_true")
+    args = parser.parse_args()
+    logger.info(f"args: {args}")
+
+    if args.multi_modal:
+        logger.warning("Multimodal mode is automatically detected with model name, please make sure `llava` is included in the model path.")
+
+    worker = ModelWorker(args.controller_address,
+                         args.worker_address,
+                         worker_id,
+                         args.no_register,
+                         args.model_path,
+                         args.model_base,
+                         args.model_name,
+                         args.load_8bit,
+                         args.load_4bit,
+                         args.device)
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")

videollama2/serve/register_worker.py

@@ -0,0 +1,26 @@
+"""
+Manually register workers.
+
+Usage:
+python3 -m fastchat.serve.register_worker --controller http://localhost:21001 --worker-name http://localhost:21002
+"""
+
+import argparse
+
+import requests
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--controller-address", type=str)
+    parser.add_argument("--worker-name", type=str)
+    parser.add_argument("--check-heart-beat", action="store_true")
+    args = parser.parse_args()
+
+    url = args.controller_address + "/register_worker"
+    data = {
+        "worker_name": args.worker_name,
+        "check_heart_beat": args.check_heart_beat,
+        "worker_status": None,
+    }
+    r = requests.post(url, json=data)
+    assert r.status_code == 200

videollama2/serve/sglang_worker.py

@@ -0,0 +1,244 @@
+"""
+A model worker executes the model.
+"""
+import argparse
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import json
+import time
+import threading
+import uuid
+
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.responses import StreamingResponse
+import requests
+import re
+import uvicorn
+from functools import partial
+
+from llava.constants import WORKER_HEART_BEAT_INTERVAL
+from llava.utils import (build_logger, server_error_msg,
+    pretty_print_semaphore)
+from llava.mm_utils import process_images, load_image_from_base64, tokenizer_image_token, expand2square
+from llava.constants import DEFAULT_IMAGE_TOKEN
+
+import sglang as sgl
+from sglang.backend.runtime_endpoint import RuntimeEndpoint
+
+
+GB = 1 << 30
+
+worker_id = str(uuid.uuid4())[:6]
+logger = build_logger("model_worker", f"model_worker_{worker_id}.log")
+global_counter = 0
+
+model_semaphore = None
+
+
+def heart_beat_worker(controller):
+    while True:
+        time.sleep(WORKER_HEART_BEAT_INTERVAL)
+        controller.send_heart_beat()
+
+
+@sgl.function
+def pipeline(s, prompt, max_tokens):
+    for p in prompt:
+        if type(p) is str:
+            s += p
+        else:
+            s += sgl.image(p)
+    s += sgl.gen("response", max_tokens=max_tokens)
+
+
+class ModelWorker:
+    def __init__(self, controller_addr, worker_addr, sgl_endpoint,
+                 worker_id, no_register, model_name):
+        self.controller_addr = controller_addr
+        self.worker_addr = worker_addr
+        self.worker_id = worker_id
+
+        # Select backend
+        backend = RuntimeEndpoint(sgl_endpoint)
+        sgl.set_default_backend(backend)
+        model_path = backend.model_info["model_path"]
+
+        if model_path.endswith("/"):
+            model_path = model_path[:-1]
+        if model_name is None:
+            model_paths = model_path.split("/")
+            if model_paths[-1].startswith('checkpoint-'):
+                self.model_name = model_paths[-2] + "_" + model_paths[-1]
+            else:
+                self.model_name = model_paths[-1]
+        else:
+            self.model_name = model_name
+
+        logger.info(f"Loading the SGLANG model {self.model_name} on worker {worker_id} ...")
+
+        if not no_register:
+            self.register_to_controller()
+            self.heart_beat_thread = threading.Thread(
+                target=heart_beat_worker, args=(self,), daemon=True)
+            self.heart_beat_thread.start()
+
+    def register_to_controller(self):
+        logger.info("Register to controller")
+
+        url = self.controller_addr + "/register_worker"
+        data = {
+            "worker_name": self.worker_addr,
+            "check_heart_beat": True,
+            "worker_status": self.get_status()
+        }
+        r = requests.post(url, json=data)
+        assert r.status_code == 200
+
+    def send_heart_beat(self):
+        logger.info(f"Send heart beat. Models: {[self.model_name]}. "
+                    f"Semaphore: {pretty_print_semaphore(model_semaphore)}. "
+                    f"global_counter: {global_counter}")
+
+        url = self.controller_addr + "/receive_heart_beat"
+
+        while True:
+            try:
+                ret = requests.post(url, json={
+                    "worker_name": self.worker_addr,
+                    "queue_length": self.get_queue_length()}, timeout=5)
+                exist = ret.json()["exist"]
+                break
+            except requests.exceptions.RequestException as e:
+                logger.error(f"heart beat error: {e}")
+            time.sleep(5)
+
+        if not exist:
+            self.register_to_controller()
+
+    def get_queue_length(self):
+        if model_semaphore is None:
+            return 0
+        else:
+            return args.limit_model_concurrency - model_semaphore._value + (len(
+                model_semaphore._waiters) if model_semaphore._waiters is not None else 0)
+
+    def get_status(self):
+        return {
+            "model_names": [self.model_name],
+            "speed": 1,
+            "queue_length": self.get_queue_length(),
+        }
+
+    async def generate_stream(self, params):
+        ori_prompt = prompt = params["prompt"]
+        images = params.get("images", None)
+        if images is not None and len(images) > 0:
+            if len(images) > 0:
+                if len(images) != prompt.count(DEFAULT_IMAGE_TOKEN):
+                    raise ValueError("Number of images does not match number of <image> tokens in prompt")
+
+                images = [load_image_from_base64(image) for image in images]
+
+                # FIXME: for image-start/end token
+                # replace_token = DEFAULT_IMAGE_TOKEN
+                # if getattr(self.model.config, 'mm_use_im_start_end', False):
+                #     replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN
+                # prompt = prompt.replace(DEFAULT_IMAGE_TOKEN, replace_token)
+                prompt = prompt.replace(' ' + DEFAULT_IMAGE_TOKEN + '\n', DEFAULT_IMAGE_TOKEN)
+                prompt_split = prompt.split(DEFAULT_IMAGE_TOKEN)
+                prompt = []
+                for i in range(len(prompt_split)):
+                    prompt.append(prompt_split[i])
+                    if i < len(images):
+                        prompt.append(images[i])
+        else:
+            prompt = [prompt]
+
+        temperature = float(params.get("temperature", 1.0))
+        top_p = float(params.get("top_p", 1.0))
+        # max_context_length = getattr(model.config, 'max_position_embeddings', 2048)
+        max_new_tokens = min(int(params.get("max_new_tokens", 256)), 1024)
+        stop_str = params.get("stop", None)
+        stop_str = [stop_str] if stop_str is not None else None
+
+        print({'prompt': prompt, 'max_new_tokens': max_new_tokens, 'temperature': temperature, 'top_p': top_p})
+        state = pipeline.run(prompt, max_new_tokens, temperature=temperature, top_p=top_p, stream=True)
+
+        generated_text = ori_prompt
+        async for text_outputs in state.text_async_iter(var_name="response"):
+            generated_text += text_outputs
+            yield json.dumps({"text": generated_text, "error_code": 0}).encode() + b"\0"
+
+    async def generate_stream_gate(self, params):
+        try:
+            async for x in self.generate_stream(params):
+                yield x
+        except ValueError as e:
+            print("Caught ValueError:", e)
+            ret = {
+                "text": server_error_msg,
+                "error_code": 1,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+        except Exception as e:
+            print("Caught Unknown Error", e)
+            ret = {
+                "text": server_error_msg,
+                "error_code": 1,
+            }
+            yield json.dumps(ret).encode() + b"\0"
+
+
+app = FastAPI()
+
+
+def release_model_semaphore(fn=None):
+    model_semaphore.release()
+    if fn is not None:
+        fn()
+
+
+@app.post("/worker_generate_stream")
+async def generate_stream(request: Request):
+    global model_semaphore, global_counter
+    global_counter += 1
+    params = await request.json()
+
+    if model_semaphore is None:
+        model_semaphore = asyncio.Semaphore(args.limit_model_concurrency)
+    await model_semaphore.acquire()
+    worker.send_heart_beat()
+    generator = worker.generate_stream_gate(params)
+    background_tasks = BackgroundTasks()
+    background_tasks.add_task(partial(release_model_semaphore, fn=worker.send_heart_beat))
+    return StreamingResponse(generator, background=background_tasks)
+
+
+@app.post("/worker_get_status")
+async def get_status(request: Request):
+    return worker.get_status()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="localhost")
+    parser.add_argument("--port", type=int, default=21002)
+    parser.add_argument("--worker-address", type=str,
+        default="http://localhost:21002")
+    parser.add_argument("--controller-address", type=str,
+        default="http://localhost:21001")
+    parser.add_argument("--model-name", type=str)
+    parser.add_argument("--sgl-endpoint", type=str)
+    parser.add_argument("--limit-model-concurrency", type=int, default=5)
+    parser.add_argument("--stream-interval", type=int, default=1)
+    parser.add_argument("--no-register", action="store_true")
+    args = parser.parse_args()
+    logger.info(f"args: {args}")
+
+    worker = ModelWorker(args.controller_address,
+                         args.worker_address,
+                         args.sgl_endpoint,
+                         worker_id,
+                         args.no_register,
+                         args.model_name)
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")

videollama2/serve/test_message.py

@@ -0,0 +1,62 @@
+import argparse
+import json
+
+import requests
+
+from llava.conversation import default_conversation
+
+
+def main():
+    if args.worker_address:
+        worker_addr = args.worker_address
+    else:
+        controller_addr = args.controller_address
+        ret = requests.post(controller_addr + "/refresh_all_workers")
+        ret = requests.post(controller_addr + "/list_models")
+        models = ret.json()["models"]
+        models.sort()
+        print(f"Models: {models}")
+
+        ret = requests.post(controller_addr + "/get_worker_address",
+            json={"model": args.model_name})
+        worker_addr = ret.json()["address"]
+        print(f"worker_addr: {worker_addr}")
+
+    if worker_addr == "":
+        return
+
+    conv = default_conversation.copy()
+    conv.append_message(conv.roles[0], args.message)
+    prompt = conv.get_prompt()
+
+    headers = {"User-Agent": "LLaVA Client"}
+    pload = {
+        "model": args.model_name,
+        "prompt": prompt,
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": 0.7,
+        "stop": conv.sep,
+    }
+    response = requests.post(worker_addr + "/worker_generate_stream", headers=headers,
+            json=pload, stream=True)
+
+    print(prompt.replace(conv.sep, "\n"), end="")
+    for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False, delimiter=b"\0"):
+        if chunk:
+            data = json.loads(chunk.decode("utf-8"))
+            output = data["text"].split(conv.sep)[-1]
+            print(output, end="\r")
+    print("")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--controller-address", type=str, default="http://localhost:21001")
+    parser.add_argument("--worker-address", type=str)
+    parser.add_argument("--model-name", type=str, default="facebook/opt-350m")
+    parser.add_argument("--max-new-tokens", type=int, default=32)
+    parser.add_argument("--message", type=str, default=
+        "Tell me a story with more than 1000 words.")
+    args = parser.parse_args()
+
+    main()

videollama2/train.py

@@ -0,0 +1,963 @@
+# Adopted from https://github.com/haotian-liu/LLaVA. Below is the original copyright:
+# Adopted from https://github.com/lm-sys/FastChat. Below is the original copyright:
+# Adopted from tatsu-lab@stanford_alpaca. Below is the original copyright:
+#    Copyright 2023 Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+import os
+import sys
+import copy
+import json
+import random
+import logging
+import pathlib
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Sequence, List
+
+# torch-related packages
+import torch
+from torch.utils.data import Dataset
+from torchvision.transforms import Compose, Lambda, ToTensor
+from pytorchvideo.data.encoded_video import EncodedVideo
+from pytorchvideo.transforms import ApplyTransformToKey, ShortSideScale, UniformTemporalSubsample
+
+import cv2
+import decord
+import imageio
+import traceback
+import numpy as np
+import transformers
+from PIL import Image
+from decord import VideoReader, cpu
+from moviepy.editor import VideoFileClip
+from transformers.models.mixtral.modeling_mixtral import MixtralSparseMoeBlock
+
+sys.path.append('./')
+from videollama2 import conversation as conversation_lib
+from videollama2.constants import NUM_FRAMES, IGNORE_INDEX, MMODAL_TOKEN_INDEX, DEFAULT_MMODAL_TOKEN, DEFAULT_MMODAL_START_TOKEN, DEFAULT_MMODAL_END_TOKEN
+from videollama2.videollama2_trainer import VideoLLaMA2Trainer
+from videollama2.model import *
+from videollama2.mm_utils import tokenizer_MMODAL_token, tokenizer_image_token, expand2square, process_video, process_image
+
+local_rank = None
+
+
+def rank0_print(*args):
+    if local_rank == 0:
+        print(*args)
+
+
+def set_seed(seed=42):
+    """
+    Set the random seed for reproducible results.
+
+    :param seed: An integer value to be used as the random seed.
+    """
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)  # for multi-GPU setups
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+@dataclass
+class ModelArguments:
+    # LLM Arguments
+    model_name_or_path: Optional[str] = field(default="lmsys/vicuna-7b-v1.5")
+    version: Optional[str] = field(default="v1", metadata={"help": "Version of the conversation template."})
+    freeze_backbone: bool = field(default=False, metadata={"help": "Whether to freeze the LLM backbone."})
+    # Connector Arguments
+    mm_projector_type: Optional[str] = field(default='linear')
+    tune_mm_mlp_adapter: bool = field(default=False)
+    pretrain_mm_mlp_adapter: Optional[str] = field(default=None)
+    # Vision tower Arguments
+    vision_tower: Optional[str] = field(default=None)
+    mm_vision_select_layer: Optional[int] = field(default=-1)
+    mm_vision_select_feature: Optional[str] = field(default="patch")
+    # Other Arguments
+    mm_use_im_start_end: bool = field(default=False)
+    mm_use_im_patch_token: bool = field(default=True)
+
+
+@dataclass
+class DataArguments:
+    # Path Arguments
+    data_path: str = field(default=None, metadata={"help": "Path to the training data."})
+    # image_folder: Optional[str] = field(default=None)
+    # video_folder: Optional[str] = field(default=None)
+    data_folder: Optional[str] = field(default=None)
+    # Loading Arguments
+    is_multimodal: bool = False
+    lazy_preprocess: bool = False
+    num_frames: Optional[int] = field(default=None)
+    # Preprocess Arguments
+    image_aspect_ratio: str = 'square'
+
+
+@dataclass
+class TrainingArguments(transformers.TrainingArguments):
+    optim: str = field(default="adamw_torch")
+    mm_projector_lr: Optional[float] = None
+    freeze_mm_mlp_adapter: bool = field(default=False)
+    remove_unused_columns: bool = field(default=False)
+    cache_dir: Optional[str] = field(default=None)
+    # Training Data Arguments 
+    group_by_modality_length: bool = field(default=False)
+    model_max_length: int = field(
+        default=512,
+        metadata={
+            "help":
+            "Maximum sequence length. Sequences will be right padded (and possibly truncated)."
+        },
+    )
+    # Lora or Quant Arguments
+    double_quant: bool = field(
+        default=True,
+        metadata={"help": "Compress the quantization statistics through double quantization."}
+    )
+    quant_type: str = field(
+        default="nf4",
+        metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}
+    )
+    bits: int = field(
+        default=16,
+        metadata={"help": "How many bits to use."}
+    )
+    lora_enable: bool = False
+    lora_r: int = 64
+    lora_alpha: int = 16
+    lora_dropout: float = 0.05
+    lora_weight_path: str = ""
+    lora_bias: str = "none"
+
+
+def maybe_zero_3(param, ignore_status=False, name=None):
+    from deepspeed import zero
+    from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+    if hasattr(param, "ds_id"):
+        if param.ds_status == ZeroParamStatus.NOT_AVAILABLE:
+            if not ignore_status:
+                logging.warning(f"{name}: param.ds_status != ZeroParamStatus.NOT_AVAILABLE: {param.ds_status}")
+        with zero.GatheredParameters([param]):
+            param = param.data.detach().cpu().clone()
+    else:
+        param = param.detach().cpu().clone()
+    return param
+
+
+# Borrowed from peft.utils.get_peft_model_state_dict
+def get_peft_state_maybe_zero_3(named_params, bias):
+    if bias == "none":
+        to_return = {k: t for k, t in named_params if "lora_" in k}
+    elif bias == "all":
+        to_return = {k: t for k, t in named_params if "lora_" in k or "bias" in k}
+    elif bias == "lora_only":
+        to_return = {}
+        maybe_lora_bias = {}
+        lora_bias_names = set()
+        for k, t in named_params:
+            if "lora_" in k:
+                to_return[k] = t
+                bias_name = k.split("lora_")[0] + "bias"
+                lora_bias_names.add(bias_name)
+            elif "bias" in k:
+                maybe_lora_bias[k] = t
+        for k, t in maybe_lora_bias:
+            if bias_name in lora_bias_names:
+                to_return[bias_name] = t
+    else:
+        raise NotImplementedError
+    to_return = {k: maybe_zero_3(v, ignore_status=True) for k, v in to_return.items()}
+    return to_return
+
+
+def get_peft_state_non_lora_maybe_zero_3(named_params, require_grad_only=True):
+    to_return = {k: t for k, t in named_params if "lora_" not in k}
+    if require_grad_only:
+        to_return = {k: t for k, t in to_return.items() if t.requires_grad}
+    to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()}
+    return to_return
+
+
+def get_mm_adapter_state_maybe_zero_3(named_params, keys_to_match):
+    to_return = {k: t for k, t in named_params if any(key_match in k for key_match in keys_to_match)}
+    to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()}
+    return to_return
+
+
+def find_all_linear_names(model):
+    cls = torch.nn.Linear
+    lora_module_names = set()
+    multimodal_keywords = ['mm_projector', 'vision_tower', 'vision_resampler']
+    for name, module in model.named_modules():
+        if any(mm_keyword in name for mm_keyword in multimodal_keywords):
+            continue
+        if isinstance(module, cls):
+            names = name.split('.')
+            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
+
+    if 'lm_head' in lora_module_names: # needed for 16-bit
+        lora_module_names.remove('lm_head')
+    return list(lora_module_names)
+
+
+def safe_save_model_for_hf_trainer(trainer: transformers.Trainer,
+                                   output_dir: str):
+    """Collects the state dict and dump to disk."""
+
+    if getattr(trainer.args, "tune_mm_mlp_adapter", False):
+        # Only save Adapter
+        keys_to_match = ['mm_projector']
+        if getattr(trainer.args, "use_im_start_end", False):
+            keys_to_match.extend(['embed_tokens', 'embed_in'])
+
+        weight_to_save = get_mm_adapter_state_maybe_zero_3(trainer.model.named_parameters(), keys_to_match)
+        trainer.model.config.save_pretrained(output_dir)
+
+        current_folder = output_dir.split('/')[-1]
+        parent_folder = os.path.dirname(output_dir)
+        if trainer.args.local_rank == 0 or trainer.args.local_rank == -1:
+            if current_folder.startswith('checkpoint-'):
+                mm_projector_folder = os.path.join(parent_folder, "mm_projector")
+                os.makedirs(mm_projector_folder, exist_ok=True)
+                torch.save(weight_to_save, os.path.join(mm_projector_folder, f'{current_folder}.bin'))
+            else:
+                torch.save(weight_to_save, os.path.join(output_dir, f'mm_projector.bin'))
+        return
+
+    if trainer.deepspeed:
+        torch.cuda.synchronize()
+        trainer.save_model(output_dir)
+        return
+
+    state_dict = trainer.model.state_dict()
+    if trainer.args.should_save:
+        cpu_state_dict = {
+            key: value.cpu()
+            for key, value in state_dict.items()
+        }
+        del state_dict
+        trainer._save(output_dir, state_dict=cpu_state_dict)  # noqa
+
+
+def smart_tokenizer_and_embedding_resize(
+    special_tokens_dict: Dict,
+    tokenizer: transformers.PreTrainedTokenizer,
+    model: transformers.PreTrainedModel,
+):
+    """Resize tokenizer and embedding.
+
+    Note: This is the unoptimized version that may make your embedding size not be divisible by 64.
+    """
+    num_new_tokens = tokenizer.add_special_tokens(special_tokens_dict)
+    model.resize_token_embeddings(len(tokenizer))
+
+    if num_new_tokens > 0:
+        input_embeddings = model.get_input_embeddings().weight.data
+        output_embeddings = model.get_output_embeddings().weight.data
+
+        input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(
+            dim=0, keepdim=True)
+        output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(
+            dim=0, keepdim=True)
+
+        input_embeddings[-num_new_tokens:] = input_embeddings_avg
+        output_embeddings[-num_new_tokens:] = output_embeddings_avg
+
+
+def _tokenize_fn(strings: Sequence[str],
+                 tokenizer: transformers.PreTrainedTokenizer) -> Dict:
+    """Tokenize a list of strings."""
+    tokenized_list = [
+        tokenizer(
+            text,
+            return_tensors="pt",
+            padding="longest",
+            max_length=tokenizer.model_max_length,
+            truncation=True,
+        ) for text in strings
+    ]
+    input_ids = labels = [
+        tokenized.input_ids[0] for tokenized in tokenized_list
+    ]
+    input_ids_lens = labels_lens = [
+        tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item()
+        for tokenized in tokenized_list
+    ]
+    return dict(
+        input_ids=input_ids,
+        labels=labels,
+        input_ids_lens=input_ids_lens,
+        labels_lens=labels_lens,
+    )
+
+
+def _mask_targets(target, tokenized_lens, speakers):
+    # cur_idx = 0
+    cur_idx = tokenized_lens[0]
+    tokenized_lens = tokenized_lens[1:]
+    target[:cur_idx] = IGNORE_INDEX
+    for tokenized_len, speaker in zip(tokenized_lens, speakers):
+        if speaker == "human":
+            target[cur_idx+2:cur_idx + tokenized_len] = IGNORE_INDEX
+        cur_idx += tokenized_len
+
+
+def _add_speaker_and_signal(header, source, get_conversation=True):
+    """Add speaker and start/end signal on each round."""
+    BEGIN_SIGNAL = "### "
+    END_SIGNAL = "\n"
+    conversation = header
+    for sentence in source:
+        from_str = sentence["from"]
+        if from_str.lower() == "human":
+            from_str = conversation_lib.default_conversation.roles[0]
+        elif from_str.lower() == "gpt":
+            from_str = conversation_lib.default_conversation.roles[1]
+        else:
+            from_str = 'unknown'
+        sentence["value"] = (BEGIN_SIGNAL + from_str + ": " +
+                             sentence["value"] + END_SIGNAL)
+        if get_conversation:
+            conversation += sentence["value"]
+    conversation += BEGIN_SIGNAL
+    return conversation
+
+
+def preprocess_multimodal(sources: Sequence[str], data_args: DataArguments) -> Dict:
+    is_multimodal = data_args.is_multimodal
+    if not is_multimodal:
+        return sources
+
+    for source in sources:
+        for sentence in source:
+            # NOTE: scan token of each modal and move them to the beginning of the sentence. 
+            for DEFAULT_TOKEN in DEFAULT_MMODAL_TOKEN.values():
+                MODAL_TYPE = None
+                if DEFAULT_TOKEN in sentence['value']:
+                    MODAL_TYPE = DEFAULT_TOKEN[1:-1]
+                    sentence['value'] = sentence['value'].replace(DEFAULT_TOKEN, '').strip()
+                    sentence['value'] = DEFAULT_TOKEN + '\n' + sentence['value']
+                    sentence['value'] = sentence['value'].strip()
+                    if "mmtag" in conversation_lib.default_conversation.version:
+                        sentence['value'] = sentence['value'].replace(DEFAULT_TOKEN, f'<{MODAL_TYPE.capitalize()}>' + DEFAULT_TOKEN + f'</{MODAL_TYPE.capitalize()}>')
+                replace_token = DEFAULT_TOKEN
+                if data_args.mm_use_im_start_end and MODAL_TYPE is not None:
+                    replace_token = DEFAULT_MMODAL_START_TOKEN[MODAL_TYPE.upper()] + replace_token + DEFAULT_MMODAL_START_TOKEN[MODAL_TYPE.upper()]
+                sentence["value"] = sentence["value"].replace(DEFAULT_TOKEN, replace_token)
+
+    return sources
+
+
+def preprocess_llama_2(
+    sources,
+    tokenizer: transformers.PreTrainedTokenizer,
+    MODAL_list = [],
+) -> Dict:
+    conv = conversation_lib.default_conversation.copy()
+    roles = {"human": conv.roles[0], "gpt": conv.roles[1]}
+
+    # Apply prompt templates
+    conversations = []
+    for i, source in enumerate(sources):
+        if roles[source[0]["from"]] != conv.roles[0]:
+            # Skip the first one if it is not from human
+            source = source[1:]
+
+        conv.messages = []
+        for j, sentence in enumerate(source):
+            role = roles[sentence["from"]]
+            assert role == conv.roles[j % 2], f"{i}"
+            conv.append_message(role, sentence["value"])
+        conversations.append(conv.get_prompt())
+
+    # Tokenize conversations
+    if len(MODAL_list) > 0:
+        # input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors='pt') for prompt in conversations], dim=0)
+        input_ids = torch.stack([tokenizer_MMODAL_token(prompt, tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[i]], return_tensors='pt') for i, prompt in enumerate(conversations)], dim=0)
+    else:
+        input_ids = tokenizer(
+            conversations,
+            return_tensors="pt",
+            padding="longest",
+            max_length=tokenizer.model_max_length,
+            truncation=True,
+        ).input_ids
+
+    targets = input_ids.clone()
+
+    assert conv.sep_style == conversation_lib.SeparatorStyle.LLAMA_2
+
+    # Mask targets
+    sep = "[/INST] "
+    for idx, (conversation, target) in enumerate(zip(conversations, targets)):
+        total_len = int(target.ne(tokenizer.pad_token_id).sum())
+
+        rounds = conversation.split(conv.sep2)
+        cur_len = 1
+        target[:cur_len] = IGNORE_INDEX
+        for i, rou in enumerate(rounds):
+            if rou == "":
+                break
+
+            parts = rou.split(sep)
+            if len(parts) != 2:
+                break
+            parts[0] += sep
+
+            if len(MODAL_list) > 0:
+                # round_len = len(tokenizer_image_token(rou, tokenizer))
+                # instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2
+                round_len = len(tokenizer_MMODAL_token(rou, tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[idx]]))
+                instruction_len = len(tokenizer_MMODAL_token(parts[0], tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[idx]])) - 2
+            else:
+                round_len = len(tokenizer(rou).input_ids)
+                instruction_len = len(tokenizer(parts[0]).input_ids) - 2
+
+            target[cur_len : cur_len + instruction_len] = IGNORE_INDEX
+
+            cur_len += round_len
+        target[cur_len:] = IGNORE_INDEX
+
+        if cur_len < tokenizer.model_max_length:
+            if cur_len != total_len:
+                target[:] = IGNORE_INDEX
+                print(
+                    f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}."
+                    f" (ignored)"
+                )
+
+    return dict(
+        input_ids=input_ids,
+        labels=targets,
+    )
+
+
+def preprocess_v1(
+    sources,
+    tokenizer: transformers.PreTrainedTokenizer,
+    MODAL_list = [],
+) -> Dict:
+    conv = conversation_lib.default_conversation.copy()
+    roles = {"human": conv.roles[0], "gpt": conv.roles[1]}
+
+    assert len(sources) == len(MODAL_list)
+    # Apply prompt templates
+    conversations = []
+    for i, source in enumerate(sources):
+        if roles[source[0]["from"]] != conv.roles[0]:
+            # Skip the first one if it is not from human
+            source = source[1:]
+
+        conv.messages = []
+        # source is the conversations in the input data
+        for j, sentence in enumerate(source):
+            role = roles[sentence["from"]]
+            assert role == conv.roles[j % 2], f"{i}"
+            conv.append_message(role, sentence["value"])
+        conversations.append(conv.get_prompt())
+
+    # Tokenize conversations
+    if len(MODAL_list) > 0:
+        # input_ids = torch.stack([tokenizer_image_token(prompt, tokenizer, return_tensors='pt') for prompt in conversations], dim=0)
+        input_ids = torch.stack([tokenizer_MMODAL_token(prompt, tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[i]], return_tensors='pt') for i, prompt in enumerate(conversations)], dim=0)
+    else:
+        input_ids = tokenizer(
+            conversations,
+            return_tensors="pt",
+            padding="longest",
+            max_length=tokenizer.model_max_length,
+            truncation=True,
+        ).input_ids
+
+    targets = input_ids.clone()
+
+    assert conv.sep_style == conversation_lib.SeparatorStyle.TWO
+
+    # Mask targets
+    sep = conv.sep + conv.roles[1] + ": "
+    #for conversation, target in zip(conversations, targets):
+    for idx, (conversation, target) in enumerate(zip(conversations, targets)):
+        total_len = int(target.ne(tokenizer.pad_token_id).sum())
+
+        rounds = conversation.split(conv.sep2)
+        cur_len = 1
+        target[:cur_len] = IGNORE_INDEX
+        for i, rou in enumerate(rounds):
+            if rou == "":
+                break
+
+            parts = rou.split(sep)
+            if len(parts) != 2:
+                break
+            parts[0] += sep
+
+            if len(MODAL_list) > 0:
+                # round_len = len(tokenizer_image_token(rou, tokenizer)) 
+                # instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2
+                # fix the issue of tokenization mismatch
+                round_len = len(tokenizer_MMODAL_token(rou, tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[idx]]))
+                instruction_len = len(tokenizer_MMODAL_token(parts[0], tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[idx]])) - 2
+            else:
+                round_len = len(tokenizer(rou).input_ids)
+                instruction_len = len(tokenizer(parts[0]).input_ids) - 2
+
+            target[cur_len : cur_len + instruction_len] = IGNORE_INDEX
+
+            cur_len += round_len
+        target[cur_len:] = IGNORE_INDEX
+
+        if cur_len < tokenizer.model_max_length:
+            if cur_len != total_len:
+                target[:] = IGNORE_INDEX
+                print(
+                    f"WARNING: tokenization mismatch: {cur_len} vs. {total_len}."
+                    f" (ignored)"
+                )
+
+    return dict(
+        input_ids=input_ids,
+        labels=targets,
+    )
+
+
+def preprocess_plain(
+    sources: Sequence[str],
+    tokenizer: transformers.PreTrainedTokenizer,
+    MODAL_list=[]
+) -> Dict:
+    # add end signal and concatenate together
+    conversations = []
+    DEFAULT_TOKEN = DEFAULT_MMODAL_TOKEN[MODAL_list[0]]
+    for source in sources:
+        assert len(source) == 2
+        source[0]['value'] = DEFAULT_TOKEN
+        conversation = source[0]['value'] + source[1]['value'] + conversation_lib.default_conversation.sep
+        conversations.append(conversation)
+    # tokenize conversations
+    input_ids = [tokenizer_MMODAL_token(prompt, tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[0]], return_tensors='pt') for prompt in conversations]
+    targets = copy.deepcopy(input_ids)
+    for target, source in zip(targets, sources):
+        tokenized_len = len(tokenizer_MMODAL_token(source[0]['value'], tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[0]]))
+        target[:tokenized_len] = IGNORE_INDEX
+
+    return dict(input_ids=input_ids, labels=targets)
+
+
+def preprocess(
+    sources: Sequence[str],
+    tokenizer: transformers.PreTrainedTokenizer,
+    MODAL_list: list = []
+) -> Dict:
+    """
+    Given a list of sources, each is a conversation list. This transform:
+    1. Add signal '### ' at the beginning each sentence, with end signal '\n';
+    2. Concatenate conversations together;
+    3. Tokenize the concatenated conversation;
+    4. Make a deepcopy as the target. Mask human words with IGNORE_INDEX.
+    """
+    if conversation_lib.default_conversation.sep_style == conversation_lib.SeparatorStyle.PLAIN:
+        return preprocess_plain(sources, tokenizer, MODAL_list)
+    if conversation_lib.default_conversation.sep_style == conversation_lib.SeparatorStyle.LLAMA_2:
+        return preprocess_llama_2(sources, tokenizer, MODAL_list)
+    if conversation_lib.default_conversation.version.startswith("v1"):
+        return preprocess_v1(sources, tokenizer, MODAL_list)
+    # add end signal and concatenate together
+    conversations = []
+    for source in sources:
+        header = f"{conversation_lib.default_conversation.system}\n\n"
+        conversation = _add_speaker_and_signal(header, source)
+        conversations.append(conversation)
+    # tokenize conversations
+    def get_tokenize_len(prompts, token_index):
+        return [len(tokenizer_MMODAL_token(prompt, tokenizer, token_index)) for prompt in prompts]
+
+    if len(MODAL_list) > 0:
+        input_ids = [tokenizer_MMODAL_token(prompt, tokenizer, MMODAL_TOKEN_INDEX[MODAL_list[i]], return_tensors='pt') for i, prompt in enumerate(conversations)]
+    else:
+        conversations_tokenized = _tokenize_fn(conversations, tokenizer)
+        input_ids = conversations_tokenized["input_ids"]
+
+    targets = copy.deepcopy(input_ids)
+    for idx, (target, source) in enumerate(zip(targets, sources)):
+        if len(MODAL_list) > 0:
+            tokenized_lens = get_tokenize_len([header] + [s["value"] for s in source], MODAL_list[idx])
+        else:
+            tokenized_lens = _tokenize_fn([header] + [s["value"] for s in source], tokenizer)["input_ids_lens"]
+        speakers = [sentence["from"] for sentence in source]
+        _mask_targets(target, tokenized_lens, speakers)
+
+    return dict(input_ids=input_ids, labels=targets)
+
+
+class LazySupervisedDataset(Dataset):
+    """Dataset for supervised fine-tuning."""
+
+    def __init__(self, data_path: str,
+                 tokenizer: transformers.PreTrainedTokenizer,
+                 data_args: DataArguments):
+        super(LazySupervisedDataset, self).__init__()
+        list_data_dict = json.load(open(data_path, "r"))
+
+        rank0_print("Formatting inputs...Skip in lazy mode")
+        self.tokenizer = tokenizer
+        self.list_data_dict = list_data_dict
+        self.data_args = data_args
+
+    def __len__(self):
+        return len(self.list_data_dict)
+
+    @property
+    def lengths(self):
+        length_list = []
+        for sample in self.list_data_dict:
+            img_tokens = 513 if 'image' in sample else 0
+            length_list.append(sum(len(conv['value'].split()) for conv in sample['conversations']) + img_tokens)
+        return length_list
+
+    @property
+    def modality_lengths(self):
+        length_list = []
+        for sample in self.list_data_dict:
+            cur_len = sum(len(conv['value'].split()) for conv in sample['conversations'])
+            cur_len = cur_len if 'image' in sample else -cur_len
+            length_list.append(cur_len)
+        return length_list
+
+    def __getitem__(self, i) -> Dict[str, torch.Tensor]:
+        sources = self.list_data_dict[i]
+        image_processor = self.data_args.image_processor
+        video_processor = self.data_args.video_processor
+
+        num_frames = NUM_FRAMES if self.data_args.num_frames is None else self.data_args.num_frames
+
+        if isinstance(i, int):
+            sources = [sources]
+        assert len(sources) == 1, "Don't know why it is wrapped to a list"  # FIXME
+        MODAL_list = []
+        if 'image' in sources[0]:
+            image_file = self.list_data_dict[i]['image']
+            image_file = os.path.join(self.data_args.data_folder, image_file)
+
+            try:
+                image = process_image(image_file, image_processor, self.data_args.image_aspect_ratio)[0]
+            except Exception as e:
+                traceback.print_exc()
+                backup_idx = random.randint(0, len(self.list_data_dict)-1)
+                print(f"Encounted error when reading image {image_file}, use {backup_idx}-th example instead!!!")
+                return self.__getitem__(backup_idx)
+
+            sources = preprocess_multimodal(copy.deepcopy([e["conversations"] for e in sources]), self.data_args)
+            MODAL_list.append('IMAGE')
+        elif 'video' in sources[0]:
+            video_file = self.list_data_dict[i]['video']
+            video_file = os.path.join(self.data_args.data_folder, video_file)
+
+            try: 
+                video = process_video(video_file, video_processor, self.data_args.image_aspect_ratio, num_frames)
+            except Exception as e:
+                traceback.print_exc()
+                backup_idx = random.randint(0, len(self.list_data_dict)-1)
+                print(f"Encounted error when reading video {video_file}, use {backup_idx}-th example instead!!!")
+                return self.__getitem__(backup_idx)
+
+            sources = preprocess_multimodal(copy.deepcopy([e["conversations"] for e in sources]), self.data_args)
+            MODAL_list.append('VIDEO')
+        else:
+            sources = copy.deepcopy([e["conversations"] for e in sources])
+            # NOTE: for sharegpt data in the sft stage, we use the default IMAGE as modal token
+            MODAL_list.append('IMAGE')
+
+        data_dict = preprocess(sources, self.tokenizer, MODAL_list=MODAL_list)
+        if isinstance(i, int):
+            data_dict = dict(input_ids=data_dict["input_ids"][0], labels=data_dict["labels"][0])
+
+        if 'image' in self.list_data_dict[i]:
+            data_dict['image'] = image
+        elif 'video' in self.list_data_dict[i]:
+            data_dict['video'] = video
+        elif self.data_args.is_multimodal:
+            # image does not exist in the data, but the model is multimodal
+            crop_size = self.data_args.image_processor.crop_size
+            data_dict['image'] = torch.zeros(3, crop_size['height'], crop_size['width'])
+        return data_dict
+
+
+@dataclass
+class DataCollatorForSupervisedDataset(object):
+    """Collate examples for supervised fine-tuning."""
+
+    tokenizer: transformers.PreTrainedTokenizer
+
+    def __call__(self, instances: Sequence[Dict]) -> Dict[str, torch.Tensor]:
+        input_ids, labels = tuple([instance[key] for instance in instances]
+                                  for key in ("input_ids", "labels"))
+        input_ids = torch.nn.utils.rnn.pad_sequence(
+            input_ids,
+            batch_first=True,
+            padding_value=self.tokenizer.pad_token_id)
+        labels = torch.nn.utils.rnn.pad_sequence(
+            labels,
+            batch_first=True,
+            padding_value=IGNORE_INDEX)
+        input_ids = input_ids[:, :self.tokenizer.model_max_length]
+        labels = labels[:, :self.tokenizer.model_max_length]
+        batch = dict(
+            input_ids=input_ids,
+            labels=labels,
+            attention_mask=input_ids.ne(self.tokenizer.pad_token_id),
+        )
+
+        Xs, keys = [], []
+        for instance in instances:
+            for x in DEFAULT_MMODAL_TOKEN.keys():
+                x = x.lower()
+                if x in instance:
+                    Xs.append(instance[x])
+                    keys.append(x)
+        batch['images'] = [Xs, keys]  # we do not change the key's name.
+        return batch
+
+
+def make_supervised_data_module(tokenizer: transformers.PreTrainedTokenizer,
+                                data_args) -> Dict:
+    """Make dataset and collator for supervised fine-tuning."""
+    train_dataset = LazySupervisedDataset(
+        tokenizer=tokenizer,
+        data_path=data_args.data_path,
+        data_args=data_args
+    )
+    data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer)
+    return dict(train_dataset=train_dataset,
+                eval_dataset=None,
+                data_collator=data_collator)
+
+
+def train(attn_implementation=None):
+    global local_rank
+    set_seed(42)
+
+    parser = transformers.HfArgumentParser((ModelArguments, DataArguments, TrainingArguments))
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    local_rank = training_args.local_rank
+    compute_dtype = (torch.float16 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+
+    bnb_model_from_pretrained_args = {}
+    if training_args.bits in [4, 8]:
+        from transformers import BitsAndBytesConfig
+        bnb_model_from_pretrained_args.update(dict(
+            device_map={"": training_args.device},
+            load_in_4bit=training_args.bits == 4,
+            load_in_8bit=training_args.bits == 8,
+            quantization_config=BitsAndBytesConfig(
+                load_in_4bit=training_args.bits == 4,
+                load_in_8bit=training_args.bits == 8,
+                llm_int8_skip_modules=["mm_projector"],
+                llm_int8_threshold=6.0,
+                llm_int8_has_fp16_weight=False,
+                bnb_4bit_compute_dtype=compute_dtype,
+                bnb_4bit_use_double_quant=training_args.double_quant,
+                bnb_4bit_quant_type=training_args.quant_type # {'fp4', 'nf4'}
+            )
+        ))
+
+    if model_args.vision_tower is not None:
+        if 'mistral' in model_args.model_name_or_path.lower():
+            config = transformers.AutoConfig.from_pretrained(model_args.model_name_or_path, trust_remote_code=True)
+            config._attn_implementation = attn_implementation
+            model = Videollama2MistralForCausalLM.from_pretrained(
+                model_args.model_name_or_path,
+                config=config,
+                cache_dir=training_args.cache_dir,
+                torch_dtype=(torch.bfloat16 if training_args.bf16 else None),
+                do_sample=True,
+                **bnb_model_from_pretrained_args
+            )
+        elif 'mixtral' in model_args.model_name_or_path.lower():
+            config = transformers.AutoConfig.from_pretrained(model_args.model_name_or_path, trust_remote_code=True)
+            config._attn_implementation = attn_implementation
+            model = Videollama2MixtralForCausalLM.from_pretrained(
+                model_args.model_name_or_path,
+                config=config,
+                cache_dir=training_args.cache_dir,
+                torch_dtype=(torch.bfloat16 if training_args.bf16 else None),
+                do_sample=True,
+                **bnb_model_from_pretrained_args
+            )
+            import deepspeed
+            deepspeed.utils.set_z3_leaf_modules(model, [MixtralSparseMoeBlock])
+        else:
+            config = transformers.AutoConfig.from_pretrained(model_args.model_name_or_path, trust_remote_code=True)
+            config._attn_implementation = attn_implementation
+            model = Videollama2LlamaForCausalLM.from_pretrained(
+                model_args.model_name_or_path,
+                config=config,
+                cache_dir=training_args.cache_dir,
+                torch_dtype=(torch.bfloat16 if training_args.bf16 else None),
+                do_sample=True,
+                **bnb_model_from_pretrained_args
+            )
+    else:
+        config = transformers.AutoConfig.from_pretrained(model_args.model_name_or_path, trust_remote_code=True)
+        config._attn_implementation = attn_implementation
+        model = transformers.LlamaForCausalLM.from_pretrained(
+            model_args.model_name_or_path,
+            config=config,
+            cache_dir=training_args.cache_dir,
+            torch_dtype=(torch.bfloat16 if training_args.bf16 else None),
+            do_sample=True,
+            **bnb_model_from_pretrained_args
+        )
+    model.config.use_cache = False
+
+    if model_args.freeze_backbone:
+        model.model.requires_grad_(False)
+
+    if training_args.bits in [4, 8]:
+        from peft import prepare_model_for_kbit_training
+        model.config.torch_dtype=(torch.float32 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=training_args.gradient_checkpointing)
+
+    if training_args.gradient_checkpointing:
+        if hasattr(model, "enable_input_require_grads"):
+            model.enable_input_require_grads()
+        else:
+            def make_inputs_require_grad(module, input, output):
+                output.requires_grad_(True)
+            model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+    if training_args.lora_enable:
+        from peft import LoraConfig, get_peft_model
+        lora_config = LoraConfig(
+            r=training_args.lora_r,
+            lora_alpha=training_args.lora_alpha,
+            target_modules=find_all_linear_names(model),
+            lora_dropout=training_args.lora_dropout,
+            bias=training_args.lora_bias,
+            task_type="CAUSAL_LM",
+        )
+        if training_args.bits == 16:
+            if training_args.bf16:
+                model.to(torch.bfloat16)
+            if training_args.fp16:
+                model.to(torch.float16)
+        rank0_print("Adding LoRA adapters...")
+        model = get_peft_model(model, lora_config)
+
+
+    tokenizer = transformers.AutoTokenizer.from_pretrained(
+        model_args.model_name_or_path,
+        cache_dir=training_args.cache_dir,
+        model_max_length=training_args.model_max_length,
+        padding_side="right",
+        use_fast=True,
+    )
+
+    if model_args.version == "v0":
+        if tokenizer.pad_token is None:
+            smart_tokenizer_and_embedding_resize(
+                special_tokens_dict=dict(pad_token="[PAD]"),
+                tokenizer=tokenizer,
+                model=model,
+            )
+    elif model_args.version == "v0.5":
+        tokenizer.pad_token = tokenizer.unk_token
+    else:
+        tokenizer.pad_token = tokenizer.unk_token
+        if model_args.version in conversation_lib.conv_templates:
+            conversation_lib.default_conversation = conversation_lib.conv_templates[model_args.version]
+        else:
+            if model_args.version == "v1":
+                conversation_lib.default_conversation = conversation_lib.conv_templates["vicuna_v1"]
+            elif model_args.version == "v1_mistral":
+                conversation_lib.default_conversation = conversation_lib.conv_templates["mistral_instruct"]
+
+    if model_args.vision_tower is not None:
+        # initialize vision encoder + multi-modal projector
+        model.get_model().initialize_vision_modules(model_args=model_args, fsdp=training_args.fsdp)
+
+        vision_tower = model.get_vision_tower()
+        vision_tower.to(dtype=torch.bfloat16 if training_args.bf16 else torch.float16, device=training_args.device)
+
+        data_args.image_processor = vision_tower.image_processor
+        data_args.video_processor = vision_tower.video_processor if hasattr(vision_tower, "video_processor") else vision_tower.image_processor
+
+        data_args.is_multimodal = True
+
+        model.config.image_aspect_ratio = data_args.image_aspect_ratio
+        model.config.tokenizer_padding_side = tokenizer.padding_side
+        model.config.tokenizer_model_max_length = tokenizer.model_max_length
+
+        model.config.tune_mm_mlp_adapter = training_args.tune_mm_mlp_adapter = model_args.tune_mm_mlp_adapter
+        if model_args.tune_mm_mlp_adapter:
+            model.requires_grad_(False)
+            for p in model.get_model().mm_projector.parameters():
+                p.requires_grad = True
+
+        model.config.freeze_mm_mlp_adapter = training_args.freeze_mm_mlp_adapter
+        if training_args.freeze_mm_mlp_adapter:
+            for p in model.get_model().mm_projector.parameters():
+                p.requires_grad = False
+
+        if training_args.bits in [4, 8]:
+            model.get_model().mm_projector.to(dtype=compute_dtype, device=training_args.device)
+
+        model.config.mm_use_im_start_end = data_args.mm_use_im_start_end = model_args.mm_use_im_start_end
+        model.config.mm_projector_lr = training_args.mm_projector_lr
+        training_args.use_im_start_end = model_args.mm_use_im_start_end
+        model.config.mm_use_im_patch_token = model_args.mm_use_im_patch_token
+        model.initialize_MM_tokenizer(model_args, tokenizer=tokenizer)
+
+        model.config.num_frames = NUM_FRAMES if data_args.num_frames is None else data_args.num_frames
+
+    if training_args.bits in [4, 8]:
+        from peft.tuners.lora import LoraLayer
+        for name, module in model.named_modules():
+            if isinstance(module, LoraLayer):
+                if training_args.bf16:
+                    module = module.to(torch.bfloat16)
+            if 'norm' in name:
+                module = module.to(torch.float32)
+            if 'lm_head' in name or 'embed_tokens' in name:
+                if hasattr(module, 'weight'):
+                    if training_args.bf16 and module.weight.dtype == torch.float32:
+                        module = module.to(torch.bfloat16)
+
+    print("Current model:", model)
+    data_module = make_supervised_data_module(tokenizer=tokenizer, data_args=data_args)
+    # select a Trainer
+    trainer = VideoLLaMA2Trainer(model=model, tokenizer=tokenizer, args=training_args, **data_module)
+
+    if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")):
+        trainer.train(resume_from_checkpoint=True)
+    else:
+        trainer.train()
+    trainer.save_state()
+
+    model.config.use_cache = True
+
+    if training_args.lora_enable:
+        state_dict = get_peft_state_maybe_zero_3(model.named_parameters(), training_args.lora_bias)
+        non_lora_state_dict = get_peft_state_non_lora_maybe_zero_3(model.named_parameters())
+        if training_args.local_rank == 0 or training_args.local_rank == -1:
+            model.config.save_pretrained(training_args.output_dir)
+            model.save_pretrained(training_args.output_dir, state_dict=state_dict)
+            torch.save(non_lora_state_dict, os.path.join(training_args.output_dir, 'non_lora_trainables.bin'))
+    else:
+        safe_save_model_for_hf_trainer(trainer=trainer, output_dir=training_args.output_dir)
+
+
+if __name__ == "__main__":
+    train()

videollama2/train_flash_attn.py

@@ -0,0 +1,12 @@
+# Adopted from https://github.com/haotian-liu/LLaVA. Below is the original copyright:
+# Adopted from https://github.com/lm-sys/FastChat. Below is the original copyright:
+# Adopted from tatsu-lab@stanford_alpaca. Below is the original copyright:
+# Make it more memory efficient by monkey patching the LLaMA model with FlashAttn.
+
+import sys
+sys.path.append('./')
+
+from videollama2.train import train
+
+if __name__ == "__main__":
+    train(attn_implementation="flash_attention_2")

videollama2/utils.py

@@ -0,0 +1,126 @@
+import datetime
+import logging
+import logging.handlers
+import os
+import sys
+
+import requests
+
+from .constants import LOGDIR
+
+server_error_msg = "**NETWORK ERROR DUE TO HIGH TRAFFIC. PLEASE REGENERATE OR REFRESH THIS PAGE.**"
+moderation_msg = "YOUR INPUT VIOLATES OUR CONTENT MODERATION GUIDELINES. PLEASE TRY AGAIN."
+
+handler = None
+
+
+def build_logger(logger_name, logger_filename):
+    global handler
+
+    formatter = logging.Formatter(
+        fmt="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    # Set the format of root handlers
+    if not logging.getLogger().handlers:
+        logging.basicConfig(level=logging.INFO)
+    logging.getLogger().handlers[0].setFormatter(formatter)
+
+    # Redirect stdout and stderr to loggers
+    stdout_logger = logging.getLogger("stdout")
+    stdout_logger.setLevel(logging.INFO)
+    sl = StreamToLogger(stdout_logger, logging.INFO)
+    sys.stdout = sl
+
+    stderr_logger = logging.getLogger("stderr")
+    stderr_logger.setLevel(logging.ERROR)
+    sl = StreamToLogger(stderr_logger, logging.ERROR)
+    sys.stderr = sl
+
+    # Get logger
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(logging.INFO)
+
+    # Add a file handler for all loggers
+    if handler is None:
+        os.makedirs(LOGDIR, exist_ok=True)
+        filename = os.path.join(LOGDIR, logger_filename)
+        handler = logging.handlers.TimedRotatingFileHandler(
+            filename, when='D', utc=True, encoding='UTF-8')
+        handler.setFormatter(formatter)
+
+        for name, item in logging.root.manager.loggerDict.items():
+            if isinstance(item, logging.Logger):
+                item.addHandler(handler)
+
+    return logger
+
+
+class StreamToLogger(object):
+    """
+    Fake file-like stream object that redirects writes to a logger instance.
+    """
+    def __init__(self, logger, log_level=logging.INFO):
+        self.terminal = sys.stdout
+        self.logger = logger
+        self.log_level = log_level
+        self.linebuf = ''
+
+    def __getattr__(self, attr):
+        return getattr(self.terminal, attr)
+
+    def write(self, buf):
+        temp_linebuf = self.linebuf + buf
+        self.linebuf = ''
+        for line in temp_linebuf.splitlines(True):
+            # From the io.TextIOWrapper docs:
+            #   On output, if newline is None, any '\n' characters written
+            #   are translated to the system default line separator.
+            # By default sys.stdout.write() expects '\n' newlines and then
+            # translates them so this is still cross platform.
+            if line[-1] == '\n':
+                self.logger.log(self.log_level, line.rstrip())
+            else:
+                self.linebuf += line
+
+    def flush(self):
+        if self.linebuf != '':
+            self.logger.log(self.log_level, self.linebuf.rstrip())
+        self.linebuf = ''
+
+
+def disable_torch_init():
+    """
+    Disable the redundant torch default initialization to accelerate model creation.
+    """
+    import torch
+    setattr(torch.nn.Linear, "reset_parameters", lambda self: None)
+    setattr(torch.nn.LayerNorm, "reset_parameters", lambda self: None)
+
+
+def violates_moderation(text):
+    """
+    Check whether the text violates OpenAI moderation API.
+    """
+    url = "https://api.openai.com/v1/moderations"
+    headers = {"Content-Type": "application/json",
+               "Authorization": "Bearer " + os.environ["OPENAI_API_KEY"]}
+    text = text.replace("\n", "")
+    data = "{" + '"input": ' + f'"{text}"' + "}"
+    data = data.encode("utf-8")
+    try:
+        ret = requests.post(url, headers=headers, data=data, timeout=5)
+        flagged = ret.json()["results"][0]["flagged"]
+    except requests.exceptions.RequestException as e:
+        flagged = False
+    except KeyError as e:
+        flagged = False
+
+    return flagged
+
+
+def pretty_print_semaphore(semaphore):
+    if semaphore is None:
+        return "None"
+    return f"Semaphore(value={semaphore._value}, locked={semaphore.locked()})"

videollama2/videollama2_trainer.py

@@ -0,0 +1,263 @@
+# Adopted from: https://github.com/haotian-liu/LLaVA/blob/main/llava/train/llava_trainer.py
+import os
+from typing import List, Optional
+
+import torch
+import torch.nn as nn
+from torch.utils.data import Sampler
+
+from transformers import Trainer
+from transformers.trainer import (
+    is_sagemaker_mp_enabled,
+    get_parameter_names,
+    has_length,
+    ALL_LAYERNORM_LAYERS,
+    logger,
+    TRAINER_STATE_NAME,
+)
+
+
+def maybe_zero_3(param, ignore_status=False, name=None):
+    from deepspeed import zero
+    from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+    if hasattr(param, "ds_id"):
+        if param.ds_status == ZeroParamStatus.NOT_AVAILABLE:
+            if not ignore_status:
+                print(name, 'no ignore status')
+        with zero.GatheredParameters([param]):
+            param = param.data.detach().cpu().clone()
+    else:
+        param = param.detach().cpu().clone()
+    return param
+
+
+def get_mm_adapter_state_maybe_zero_3(named_params, keys_to_match):
+    to_return = {k: t for k, t in named_params if any(key_match in k for key_match in keys_to_match)}
+    to_return = {k: maybe_zero_3(v, ignore_status=True, name=k).cpu() for k, v in to_return.items()}
+    return to_return
+
+
+def split_to_even_chunks(indices, lengths, num_chunks):
+    """
+    Split a list of indices into `chunks` chunks of roughly equal lengths.
+    """
+
+    if len(indices) % num_chunks != 0:
+        return [indices[i::num_chunks] for i in range(num_chunks)]
+
+    num_indices_per_chunk = len(indices) // num_chunks
+
+    chunks = [[] for _ in range(num_chunks)]
+    chunks_lengths = [0 for _ in range(num_chunks)]
+    for index in indices:
+        shortest_chunk = chunks_lengths.index(min(chunks_lengths))
+        chunks[shortest_chunk].append(index)
+        chunks_lengths[shortest_chunk] += lengths[index]
+        if len(chunks[shortest_chunk]) == num_indices_per_chunk:
+            chunks_lengths[shortest_chunk] = float("inf")
+
+    return chunks
+
+
+def get_modality_length_grouped_indices(lengths, batch_size, world_size, generator=None):
+    # We need to use torch for the random part as a distributed sampler will set the random seed for torch.
+    assert all(l != 0 for l in lengths), "Should not have zero length."
+    if all(l > 0 for l in lengths) or all(l < 0 for l in lengths):
+        # all samples are in the same modality
+        return get_length_grouped_indices(lengths, batch_size, world_size, generator=generator)
+    mm_indices, mm_lengths = zip(*[(i, l) for i, l in enumerate(lengths) if l > 0])
+    lang_indices, lang_lengths = zip(*[(i, -l) for i, l in enumerate(lengths) if l < 0])
+
+    mm_shuffle = [mm_indices[i] for i in get_length_grouped_indices(mm_lengths, batch_size, world_size, generator=None)]
+    lang_shuffle = [lang_indices[i] for i in get_length_grouped_indices(lang_lengths, batch_size, world_size, generator=None)]
+    megabatch_size = world_size * batch_size
+    mm_megabatches = [mm_shuffle[i : i + megabatch_size] for i in range(0, len(mm_shuffle), megabatch_size)]
+    lang_megabatches = [lang_shuffle[i : i + megabatch_size] for i in range(0, len(lang_shuffle), megabatch_size)]
+
+    last_mm = mm_megabatches[-1]
+    last_lang = lang_megabatches[-1]
+    additional_batch = last_mm + last_lang
+    megabatches = mm_megabatches[:-1] + lang_megabatches[:-1]
+    megabatch_indices = torch.randperm(len(megabatches), generator=generator)
+    megabatches = [megabatches[i] for i in megabatch_indices]
+
+    if len(additional_batch) > 0:
+        megabatches.append(sorted(additional_batch))
+
+    return [i for megabatch in megabatches for i in megabatch]
+
+
+def get_length_grouped_indices(lengths, batch_size, world_size, generator=None, merge=True):
+    # We need to use torch for the random part as a distributed sampler will set the random seed for torch.
+    indices = torch.randperm(len(lengths), generator=generator)
+    megabatch_size = world_size * batch_size
+    megabatches = [indices[i : i + megabatch_size].tolist() for i in range(0, len(lengths), megabatch_size)]
+    megabatches = [sorted(megabatch, key=lambda i: lengths[i], reverse=True) for megabatch in megabatches]
+    megabatches = [split_to_even_chunks(megabatch, lengths, world_size) for megabatch in megabatches]
+
+    return [i for megabatch in megabatches for batch in megabatch for i in batch]
+
+
+class LengthGroupedSampler(Sampler):
+    r"""
+    Sampler that samples indices in a way that groups together features of the dataset of roughly the same length while
+    keeping a bit of randomness.
+    """
+
+    def __init__(
+        self,
+        batch_size: int,
+        world_size: int,
+        lengths: Optional[List[int]] = None,
+        generator=None,
+        group_by_modality: bool = False,
+    ):
+        if lengths is None:
+            raise ValueError("Lengths must be provided.")
+
+        self.batch_size = batch_size
+        self.world_size = world_size
+        self.lengths = lengths
+        self.generator = generator
+        self.group_by_modality = group_by_modality
+
+    def __len__(self):
+        return len(self.lengths)
+
+    def __iter__(self):
+        if self.group_by_modality:
+            indices = get_modality_length_grouped_indices(self.lengths, self.batch_size, self.world_size, generator=self.generator)
+        else:
+            indices = get_length_grouped_indices(self.lengths, self.batch_size, self.world_size, generator=self.generator)
+        return iter(indices)
+
+
+class VideoLLaMA2Trainer(Trainer):
+
+    def _get_train_sampler(self) -> Optional[torch.utils.data.Sampler]:
+        if self.train_dataset is None or not has_length(self.train_dataset):
+            return None
+
+        if self.args.group_by_modality_length:
+            lengths = self.train_dataset.modality_lengths
+            return LengthGroupedSampler(
+                self.args.train_batch_size,
+                world_size=self.args.world_size * self.args.gradient_accumulation_steps,
+                lengths=lengths,
+                group_by_modality=True,
+            )
+        else:
+            return super()._get_train_sampler()
+
+    def create_optimizer(self):
+        """
+        Setup the optimizer.
+
+        We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the
+        Trainer's init through `optimizers`, or subclass and override this method in a subclass.
+        """
+        if is_sagemaker_mp_enabled():
+            return super().create_optimizer()
+
+        opt_model = self.model
+
+        if self.optimizer is None:
+            decay_parameters = get_parameter_names(opt_model, ALL_LAYERNORM_LAYERS)
+            decay_parameters = [name for name in decay_parameters if "bias" not in name]
+            if self.args.mm_projector_lr is not None:
+                projector_parameters = [name for name, _ in opt_model.named_parameters() if "mm_projector" in name]
+                optimizer_grouped_parameters = [
+                    {
+                        "params": [
+                            p for n, p in opt_model.named_parameters() if (n in decay_parameters and n not in projector_parameters and p.requires_grad)
+                        ],
+                        "weight_decay": self.args.weight_decay,
+                    },
+                    {
+                        "params": [
+                            p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n not in projector_parameters and p.requires_grad)
+                        ],
+                        "weight_decay": 0.0,
+                    },
+                    {
+                        "params": [
+                            p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in projector_parameters and p.requires_grad)
+                        ],
+                        "weight_decay": self.args.weight_decay,
+                        "lr": self.args.mm_projector_lr,
+                    },
+                    {
+                        "params": [
+                            p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in projector_parameters and p.requires_grad)
+                        ],
+                        "weight_decay": 0.0,
+                        "lr": self.args.mm_projector_lr,
+                    },
+                ]
+            else:
+                optimizer_grouped_parameters = [
+                    {
+                        "params": [
+                            p for n, p in opt_model.named_parameters() if (n in decay_parameters and p.requires_grad)
+                        ],
+                        "weight_decay": self.args.weight_decay,
+                    },
+                    {
+                        "params": [
+                            p for n, p in opt_model.named_parameters() if (n not in decay_parameters and p.requires_grad)
+                        ],
+                        "weight_decay": 0.0,
+                    },
+                ]
+
+            optimizer_cls, optimizer_kwargs = Trainer.get_optimizer_cls_and_kwargs(self.args)
+
+            self.optimizer = optimizer_cls(optimizer_grouped_parameters, **optimizer_kwargs)
+            if optimizer_cls.__name__ == "Adam8bit":
+                import bitsandbytes
+
+                manager = bitsandbytes.optim.GlobalOptimManager.get_instance()
+
+                skipped = 0
+                for module in opt_model.modules():
+                    if isinstance(module, nn.Embedding):
+                        skipped += sum({p.data_ptr(): p.numel() for p in module.parameters()}.values())
+                        logger.info(f"skipped {module}: {skipped/2**20}M params")
+                        manager.register_module_override(module, "weight", {"optim_bits": 32})
+                        logger.debug(f"bitsandbytes: will optimize {module} in fp32")
+                logger.info(f"skipped: {skipped/2**20}M params")
+
+        return self.optimizer
+
+    def _save_checkpoint(self, model, trial, metrics=None):
+        if getattr(self.args, 'tune_mm_mlp_adapter', False):
+            from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR
+            checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}"
+
+            run_dir = self._get_output_dir(trial=trial)
+            output_dir = os.path.join(run_dir, checkpoint_folder)
+
+            # Only save Adapter
+            keys_to_match = ['mm_projector', 'vision_resampler']
+            if getattr(self.args, "use_im_start_end", False):
+                keys_to_match.extend(['embed_tokens', 'embed_in'])
+
+            weight_to_save = get_mm_adapter_state_maybe_zero_3(self.model.named_parameters(), keys_to_match)
+
+            if self.args.local_rank == 0 or self.args.local_rank == -1:
+                self.model.config.save_pretrained(output_dir)
+                torch.save(weight_to_save, os.path.join(output_dir, f'mm_projector.bin'))
+            # Save optimizer and scheduler
+            self._save_optimizer_and_scheduler(output_dir)
+            # Save RNG state
+            self._save_rng_state(output_dir)
+            self.state.save_to_json(os.path.join(output_dir, TRAINER_STATE_NAME))
+            self.args.distributed_state.wait_for_everyone()
+        else:
+            super(VideoLLaMA2Trainer, self)._save_checkpoint(model, trial, metrics)
+
+    def _save(self, output_dir: Optional[str] = None, state_dict=None):
+        if getattr(self.args, 'tune_mm_mlp_adapter', False):
+            pass
+        else:
+            super(VideoLLaMA2Trainer, self)._save(output_dir, state_dict)