Add files using upload-large-folder tool

spatial-model/VLM-3R/llava/__init__.py

@@ -0,0 +1 @@
+from .model import LlavaLlamaForCausalLM

spatial-model/VLM-3R/llava/conversation.py

@@ -0,0 +1,585 @@
+import dataclasses
+from enum import auto, Enum
+from typing import List, Any, Dict, Union, Tuple
+import re
+import base64
+from io import BytesIO
+from PIL import Image
+from transformers import AutoTokenizer
+
+
+class SeparatorStyle(Enum):
+    """Different separator style."""
+
+    SINGLE = auto()
+    TWO = auto()
+    MPT = auto()
+    PLAIN = auto()
+    CHATML = auto()
+    LLAMA_2 = auto()
+    LLAMA_3 = auto()
+    QWEN = auto()
+    GEMMA = 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"
+
+    tokenizer_id: str = ""
+    tokenizer: Any = None
+    # Stop criteria (the default one is EOS token)
+    stop_str: Union[str, List[str]] = None
+    # Stops generation if meeting any token in this list
+    stop_token_ids: List[int] = None
+
+    skip_next: bool = False
+
+    def get_prompt(self):
+        messages = self.messages
+        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]
+            if "mmtag" in self.version:
+                init_msg = init_msg.replace("<image>", "").strip()
+                messages[0] = (init_role, init_msg)
+                messages.insert(0, (self.roles[0], "<Image><image></Image>"))
+                messages.insert(1, (self.roles[1], "Received."))
+            elif not init_msg.startswith("<image>"):
+                init_msg = init_msg.replace("<image>", "").strip()
+                messages[0] = (init_role, "<image>\n" + init_msg)
+            else:
+                messages[0] = (init_role, 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.CHATML:
+            ret = "" if self.system == "" else self.system + self.sep + "\n"
+            for role, message in messages:
+                if message:
+                    if type(message) is tuple:
+                        message, images, _ = message
+                        message = "<image>" * len(images) + message
+                    ret += role + "\n" + message + self.sep + "\n"
+                else:
+                    ret += role + "\n"
+            return ret
+
+        elif self.sep_style == SeparatorStyle.LLAMA_3:
+            if self.tokenizer is None:
+                raise ValueError("Llama 3 tokenizer is not available. Make sure you have the necessary permissions.")
+            chat_template_messages = [{"role": "system", "content": self.system}]
+            for role, message in messages:
+                if message:
+                    if type(message) is tuple:
+                        message, images = message
+                        message = "<image>" * len(images) + message
+                    chat_template_messages.append({"role": role, "content": message})
+
+            # print(chat_template_messages)
+            return self.tokenizer.apply_chat_template(chat_template_messages, tokenize=False, add_generation_prompt=True)
+            # ret = "" if self.system == "" else self.system + self.sep + "\n"
+            # for role, message in messages:
+            #     if message:
+            #         if type(message) is tuple:
+            #             message, images = message
+            #             message = "<image>" * len(images) + message
+            #         ret += role + "\n" + message + self.sep + "\n"
+            #     else:
+            #         ret += role + "\n"
+            # return ret
+
+        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.GEMMA:
+            ret = ""
+            for i, (role, message) in enumerate(messages):
+                assert role == self.roles[i % 2], "Conversation should alternate user/assistant/user/assistant/..."
+                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" if len(msg) > 0 else msg
+            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"):
+        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 type(image) is not Image.Image:
+            image = Image.open(image).convert("RGB")
+
+        max_hw, min_hw = max(image.size), min(image.size)
+        aspect_ratio = max_hw / min_hw
+        max_len, min_len = 672, 448
+        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_images(self, return_pil=False, return_path=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
+                    if type(image) != list:
+                        image = [image]
+                    for img in image:
+                        if not return_path and self.is_image_file(img):
+                            img = self.process_image(img, image_process_mode, return_pil=return_pil)
+                        else:
+                            images.append(img)
+        return images
+
+    def is_image_file(self, filename):
+        image_extensions = [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp"]
+        return any(filename.lower().endswith(ext) for ext in image_extensions)
+
+    def is_video_file(self, filename):
+        video_extensions = [".mp4", ".mov", ".avi", ".mkv", ".wmv", ".flv", ".mpeg", ".mpg"]
+        return any(filename.lower().endswith(ext) for ext in video_extensions)
+
+    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:
+                    msg, image, image_process_mode = msg
+                    if type(image) != list:
+                        image = [image]
+                    if len(image) == 1:
+                        msg = "<image>\n" + msg.replace("<image>", "").strip()
+                    else:
+                        msg = re.sub(r"(<image>)\n(?=<image>)", r"\1 ", msg)
+
+                    img_str_list = []                         
+                    for img in image:
+                        if self.is_image_file(img):
+                            img_b64_str = self.process_image(img, "Default", return_pil=False, image_format="JPEG")
+                            img_str = f'<img src="data:image/jpeg;base64,{img_b64_str}" style="max-width: 256px; max-height: 256px; width: auto; height: auto; object-fit: contain;"/>'
+                            img_str_list.append(img_str)
+                        elif self.is_video_file(img):
+                            ret.append(((img,), None))
+
+                    msg = msg.strip()
+                    img_place_holder = ""
+                    for img_str in img_str_list:
+                        img_place_holder += f"{img_str}\n\n"
+
+                    if len(img_str_list) > 0:
+                        msg = f"{img_place_holder}\n\n{msg}"
+
+                    if len(msg) > 0:
+                        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 len(self.get_images()) > 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,
+            }
+        return {
+            "system": self.system,
+            "roles": self.roles,
+            "messages": self.messages,
+            "offset": self.offset,
+            "sep": self.sep,
+            "sep2": self.sep2,
+        }
+
+
+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>",
+)
+
+def safe_load_tokenizer(tokenizer_id):
+    try:
+        return AutoTokenizer.from_pretrained(tokenizer_id)
+    except Exception:
+        return None
+
+conv_llava_llama_3 = 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_v3",
+    messages=[],
+    offset=0,
+    sep="<|eot_id|>",
+    sep_style=SeparatorStyle.LLAMA_3,
+    tokenizer_id="meta-llama/Meta-Llama-3-8B-Instruct",
+    tokenizer=safe_load_tokenizer("meta-llama/Meta-Llama-3-8B-Instruct"),
+    stop_token_ids=[128009],
+)
+
+conv_mistral_instruct = Conversation(
+    system="",
+    roles=("USER", "ASSISTANT"),
+    version="llama_v2",
+    messages=[],
+    offset=0,
+    sep_style=SeparatorStyle.LLAMA_2,
+    sep="",
+    sep2="</s>",
+)
+
+conv_llava_llama_2_simple = Conversation(
+    system="Answer the questions about the visual content that the user provides.",
+    roles=("USER", "ASSISTANT"),
+    version="llama_v2",
+    messages=[],
+    offset=0,
+    sep_style=SeparatorStyle.LLAMA_2,
+    sep="<s>",
+    sep2="</s>",
+)
+
+conv_llava_llama_2_mmtag = Conversation(
+    system="Answer the questions about the visual content that the user provides." "The visual content will be provided with the following format: <Image>visual content</Image>.",
+    roles=("USER", "ASSISTANT"),
+    version="llama_v2_mmtag",
+    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_qwen = Conversation(
+    system="""<|im_start|>system
+You are a helpful assistant.""",
+    roles=("<|im_start|>user", "<|im_start|>assistant"),
+    version="qwen",
+    messages=[],
+    offset=0,
+    sep_style=SeparatorStyle.CHATML,
+    sep="<|im_end|>",
+)
+
+conv_gemma_instruct = Conversation(system="", roles=("<start_of_turn>user\n", "<start_of_turn>model\n"), version="gemma", messages=[], offset=0, sep_style=SeparatorStyle.GEMMA, sep="<end_of_turn>\n")
+
+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",
+)
+
+conv_mistral_orca = Conversation(
+    system="""<|im_start|>system
+You are MistralOrca, a large language model trained by Alignment Lab AI. Write out your reasoning step-by-step to be sure you get the right answers!""",
+    roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
+    version="mpt",
+    messages=[],
+    offset=0,
+    sep_style=SeparatorStyle.MPT,
+    sep="<|im_end|>",
+)
+
+conv_mistral_zephyr = Conversation(
+    system="""<|system|>
+You are a helpful AI assistant.""",
+    roles=("<|user|>\n", "<|assistant|>\n"),
+    version="mpt",
+    messages=[],
+    offset=0,
+    sep_style=SeparatorStyle.MPT,
+    sep="</s>",
+)
+
+conv_mistral_direct = Conversation(
+    system="""<|im_start|>system
+Answer the questions.""",
+    roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
+    version="mpt",
+    messages=[],
+    offset=0,
+    sep_style=SeparatorStyle.MPT,
+    sep="<|im_end|>",
+)
+
+conv_chatml_direct = Conversation(
+    system="""<|im_start|>system
+Answer the questions.""",
+    roles=("<|im_start|>user\n", "<|im_start|>assistant\n"),
+    version="mpt",
+    messages=[],
+    offset=0,
+    sep_style=SeparatorStyle.MPT,
+    sep="<|im_end|>",
+)
+
+default_conversation = conv_vicuna_v0
+conv_templates = {
+    "default": conv_vicuna_v0,
+    "v0": conv_vicuna_v0,
+    "v1": conv_vicuna_v1,
+    "vicuna_v1": conv_vicuna_v1,
+    "llama_2": conv_llama_2,
+    "mistral_instruct": conv_mistral_instruct,
+    "mistral_orca": conv_mistral_orca,
+    "mistral_zephyr": conv_mistral_zephyr,
+    "mistral_direct": conv_mistral_direct,
+    "plain": conv_llava_plain,
+    "v0_plain": conv_llava_plain,
+    "chatml_direct": conv_chatml_direct,
+    "llava_v0": conv_llava_v0,
+    "llava_v0_mmtag": conv_llava_v0_mmtag,
+    "llava_v1": conv_llava_v1,
+    "llava_v1_mmtag": conv_llava_v1_mmtag,
+    "llava_llama_2": conv_llava_llama_2,
+    "llava_llama_3": conv_llava_llama_3,
+    "llava_llama_2_simple": conv_llava_llama_2_simple,
+    "llava_llama_2_mmtag": conv_llava_llama_2_mmtag,
+    "llava_mistral_instruct": conv_mistral_instruct,
+    "mpt": conv_mpt,
+    "qwen_1_5": conv_qwen,
+    "qwen_2": conv_qwen,
+    "gemma_instruct": conv_gemma_instruct,
+}
+
+
+if __name__ == "__main__":
+    print(default_conversation.get_prompt())

spatial-model/VLM-3R/llava/eval/eval_sqa3d.py

@@ -0,0 +1,93 @@
+import re
+import json
+import argparse
+import string
+import numpy as np
+
+def clean_answer(data):
+    data = data.lower()
+    data = re.sub('[ ]+$' ,'', data)
+    data = re.sub('^[ ]+' ,'', data)
+    data = re.sub(' {2,}', ' ', data)
+
+    data = re.sub('\.[ ]{2,}', '. ', data)
+    data = re.sub('[^a-zA-Z0-9,\'\s\-:]+', '', data)
+    data = re.sub('ç' ,'c', data)
+    data = re.sub('’' ,'\'', data)
+    data = re.sub(r'\bletf\b' ,'left', data)
+    data = re.sub(r'\blet\b' ,'left', data)
+    data = re.sub(r'\btehre\b' ,'there', data)
+    data = re.sub(r'\brigth\b' ,'right', data)
+    data = re.sub(r'\brght\b' ,'right', data)
+    data = re.sub(r'\bbehine\b', 'behind', data)
+    data = re.sub(r'\btv\b' ,'TV', data)
+    data = re.sub(r'\bchai\b' ,'chair', data)
+    data = re.sub(r'\bwasing\b' ,'washing', data)
+    data = re.sub(r'\bwaslked\b' ,'walked', data)
+    data = re.sub(r'\boclock\b' ,'o\'clock', data)
+    data = re.sub(r'\bo\'[ ]+clock\b' ,'o\'clock', data)
+
+    # digit to word, only for answer
+    data = re.sub(r'\b0\b', 'zero', data)
+    data = re.sub(r'\bnone\b', 'zero', data)
+    data = re.sub(r'\b1\b', 'one', data)
+    data = re.sub(r'\b2\b', 'two', data)
+    data = re.sub(r'\b3\b', 'three', data)
+    data = re.sub(r'\b4\b', 'four', data)
+    data = re.sub(r'\b5\b', 'five', data)
+    data = re.sub(r'\b6\b', 'six', data)
+    data = re.sub(r'\b7\b', 'seven', data)
+    data = re.sub(r'\b8\b', 'eight', data)
+    data = re.sub(r'\b9\b', 'nine', data)
+    data = re.sub(r'\b10\b', 'ten', data)
+    data = re.sub(r'\b11\b', 'eleven', data)
+    data = re.sub(r'\b12\b', 'twelve', data)
+    data = re.sub(r'\b13\b', 'thirteen', data)
+    data = re.sub(r'\b14\b', 'fourteen', data)
+    data = re.sub(r'\b15\b', 'fifteen', data)
+    data = re.sub(r'\b16\b', 'sixteen', data)
+    data = re.sub(r'\b17\b', 'seventeen', data)
+    data = re.sub(r'\b18\b', 'eighteen', data)
+    data = re.sub(r'\b19\b', 'nineteen', data)
+    data = re.sub(r'\b20\b', 'twenty', data)
+    data = re.sub(r'\b23\b', 'twenty-three', data)
+
+    # misc
+    # no1, mat2, etc
+    data = re.sub(r'\b([a-zA-Z]+)([0-9])\b' ,r'\g<1>', data)
+    data = re.sub(r'\ba\b ([a-zA-Z]+)' ,r'\g<1>', data)
+    data = re.sub(r'\ban\b ([a-zA-Z]+)' ,r'\g<1>', data)
+    data = re.sub(r'\bthe\b ([a-zA-Z]+)' ,r'\g<1>', data)
+
+    data = re.sub(r'\bbackwards\b', 'backward', data)
+
+    return data
+
+def main(args):
+    with open(args.input_file) as f:
+        data = [json.loads(line.strip()) for line in f.readlines()]
+    
+    if args.n != -1:
+        data = data[:args.n]
+
+    from collections import defaultdict
+    correct_per_type = defaultdict(list)
+
+    for item in data:
+        pred = clean_answer(item['pred_response']) 
+        gt = clean_answer(item['gt_response'])
+
+        correct_per_type["all"].append(int(pred == gt))
+        correct_per_type[item['question_type']].append(int(pred == gt))
+
+    for k in correct_per_type:
+        print(f"{k}: {np.mean(correct_per_type[k]) * 100}")
+
+
+if __name__=="__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input-file', type=str, default='results/llava_next_video_sqa3d_test_answer_pred_scanqa_sqa3d.jsonl')
+    parser.add_argument("-n", type=int, default=-1)
+    args = parser.parse_args()
+
+    main(args)

spatial-model/VLM-3R/llava/eval/evaluate_interleave.py

@@ -0,0 +1,339 @@
+import re
+from rouge import Rouge
+import argparse
+import os
+import json
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+
+spot_the_diff = ["Spot-the-Diff", "Birds-to-Words", "CLEVR-Change"]
+image_edit_instruct = ["IEdit", "HQ-Edit", "MagicBrush"]
+visual_story_telling = ["AESOP", "FlintstonesSV", "PororoSV", "VIST"]
+visual_cloze = ["COMICS_Dialogue", "RecipeQA_VisualCloze"]
+text_rich_vqa = ["WebQA", "TQA", "OCR-VQA", "DocVQA"]
+multi_image_vqa = ["MIT-States_StateCoherence", "MIT-States_PropertyCoherence", "VISION", "RecipeQA_ImageCoherence"]
+
+puzzle = ["RAVEN"]
+nlrv2 = ["NLVR2_Mantis"]
+qbench = ["QBench"]
+
+class Eval:
+    def __init__(self):
+        self.periodStrip = re.compile("(?!<=\d)(\.)(?!\d)")
+        self.commaStrip = re.compile("(\d)(\,)(\d)")
+        self.punct = [
+            ";",
+            r"/",
+            "[",
+            "]",
+            '"',
+            "{",
+            "}",
+            "(",
+            ")",
+            "=",
+            "+",
+            "\\",
+            "_",
+            "-",
+            ">",
+            "<",
+            "@",
+            "`",
+            ",",
+            "?",
+            "!",
+        ]
+        
+    def processPunctuation(self, inText):
+        outText = inText
+        for p in self.punct:
+            if (p + " " in inText or " " + p in inText) or (
+                re.search(self.commaStrip, inText) != None
+            ):
+                outText = outText.replace(p, "")
+            else:
+                outText = outText.replace(p, " ")
+        outText = self.periodStrip.sub("", outText, re.UNICODE)
+        return outText
+    
+    def process(self, answer):
+        answer = answer.replace("\n", " ")
+        answer = answer.replace("\t", " ")
+        answer = answer.strip()
+        answer = self.processPunctuation(answer)
+        answer = answer.strip('\'')
+        answer = answer.strip('\"')
+        answer = answer.strip(')')
+        answer = answer.strip('(')
+        answer = answer.strip().lower()
+        return answer
+
+    def evaluate_rouge(self,preds):
+        rouge = Rouge()
+        acc = {'f': []}
+        eval_list = []
+        for i, res in enumerate(preds):
+            sample_id = res['sample_id']
+            # print(sample_id)
+            gt_ans = self.process(res["gt_response"])
+            pred_ans = self.process(res["pred_response"])
+            # assert gt_ans != ''
+
+            if gt_ans == '':
+                continue
+            
+            if pred_ans == '':
+                s = 0
+            else:
+                if len(pred_ans) > 512:
+                    pred_ans = pred_ans[0: 512]
+                s = rouge.get_scores(pred_ans, gt_ans)[0]['rouge-l']['f']
+            acc['f'].append(s)
+            eval_list.append({'id':str(sample_id),'score':str(round(s,3))})
+        results = {'Rouge-L f': np.mean(acc['f'])}
+        return results,eval_list
+
+
+    def judge_multi_choice(self,sample):
+        sample_id = sample['sample_id']
+        gt_ans = sample["gt_response"]
+        pred_ans = sample["pred_response"]
+
+        if ":" in pred_ans:
+            a_list = pred_ans.split(":")
+            a_list = [a.strip() for a in a_list ]
+            for a in a_list:
+                if len(a) == 1 and a[-1] in ["a", "b", "c", "d", "e", "f", "g", "h"]:
+                    pred_ans = a
+
+        if pred_ans == gt_ans:
+            return 1
+        else:
+            return 0
+
+    def process_sample(self,sample):
+        sample["gt_response"] = self.process(sample["gt_response"])
+        sample["pred_response"] = self.process(sample["pred_response"])
+
+    def evaluate_multichoice(self, preditions):
+        correct = 0
+        eval_list = []
+        for i, sample in enumerate(preditions):
+            self.process_sample(sample)
+            score = self.judge_multi_choice(sample)
+            sample_id = sample['sample_id']
+            sample['result'] = score
+            eval_list.append({'id':str(sample_id),'score':str(score)})
+            correct+=score
+        return {'Accuracy':correct/len(preditions)},eval_list
+
+    def evaluate_multi_choice_image(self,preditions):
+        correct = 0
+        eval_list = []
+        for i,sample in enumerate(preditions):
+            gt_ans = self.process(sample["gt_response"])
+            pred_ans = self.process(sample["pred_response"])
+            sample_id = sample['sample_id']
+
+            if ":" in pred_ans:
+                a_list = pred_ans.split(":")
+                a_list = [a.strip() for a in a_list ]
+                for a in a_list:
+                    if len(a) == 1 and a[-1] in ["a", "b", "c", "d", "e", "f", "g", "h"]:
+                        pred_ans = a
+
+            if gt_ans == pred_ans:
+                score = 1
+            else:
+                score = 0
+            sample_id = sample['sample_id']
+            sample['result'] = score
+            eval_list.append({'id':str(sample_id),'score':str(score)})
+            correct+=score
+        return {'Accuracy':correct/len(preditions)},eval_list
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--result-dir', type=str, required=True)
+
+    args = parser.parse_args()
+    
+    result_file = os.path.join(args.result_dir, "result.jsonl")
+
+    if not os.path.exists(result_file):
+        print('No prediction file found')
+        exit(0)
+    with open(result_file, 'r') as f:
+        preds_all = [json.loads(line) for line in f]
+    
+    preds_all_dict = dict()
+    for pred in preds_all:
+        if pred["dataset"] not in preds_all_dict:
+            preds_all_dict[pred["dataset"]] = list()
+        preds_all_dict[pred["dataset"]].append(pred)
+
+    image_choice_dataset_list = ["recipeqa-RecipeQA_VisualCloze", "RecipeQA_ImageCoherence", "COMICS_Panel"]
+    E = Eval()
+
+    eval_result_list = dict()
+    eval_result_list_detail = dict()
+
+    for dataset in preds_all_dict:
+        
+        preds = preds_all_dict[dataset]
+        question_type = preds[0]["question_type"]
+   
+        if question_type == 'open-ended':
+            eval_result, eval_list = E.evaluate_rouge(preds)
+
+        elif question_type == 'multi-choice' or dataset == 'nlrv2':
+            if dataset in image_choice_dataset_list:
+                eval_result, eval_list = E.evaluate_multi_choice_image(preds)
+            else:
+                eval_result, eval_list = E.evaluate_multichoice(preds)
+
+        else:
+            eval_result = 'Dataset not supported'
+            print('Dataset not supported')
+            exit(0)
+
+        print(dataset, end = ':  ')
+        print(eval_result)
+
+        eval_result_list[dataset] = eval_result
+        eval_result_list_detail[dataset] = eval_list
+
+    os.makedirs(args.result_dir, exist_ok=True)
+    with open(os.path.join(args.result_dir, 'eval_dataset.json'), 'w') as f:
+        json.dump(eval_result_list, f, indent=4)
+
+    with open(os.path.join(args.result_dir,'eval_dataset_details.json'), 'w') as f:
+        json.dump(eval_result_list_detail, f, indent=4)
+
+
+    eval_cat_list = dict()
+    print()
+
+    # spot_the_diff
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in spot_the_diff:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["spot_the_diff"] = score
+        print("spot_the_diff", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    # image_edit_instruct
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in image_edit_instruct:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["image_edit_instruct"] = score
+        print("image_edit_instruct", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    # visual_story_telling
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in visual_story_telling:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["visual_story_telling"] = score
+        print("visual_story_telling", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    # visual_cloze
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in visual_cloze:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["visual_cloze"] = score
+        print("visual_cloze", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    # text_rich_vqa
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in text_rich_vqa:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["text_rich_vqa"] = score
+        print("text_rich_vqa", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    # multi_image_vqa
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in multi_image_vqa:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["multi_image_vqa"] = score
+        print("multi_image_vqa", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    # puzzle
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in puzzle:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["puzzle"] = score
+        print("puzzle", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    # nlrv2
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in nlrv2:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["nlrv2"] = score
+        print("nlrv2", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    # qbench
+    score = 0
+    count = 0
+    for dataset in eval_result_list:
+        if dataset in qbench:
+            count += 1
+            score += list(eval_result_list[dataset].values())[0]
+    if count > 0:
+        score /= count
+        eval_cat_list["qbench"] = score
+        print("qbench", end = ':  ')
+        print('{:.2f}'.format(100 * score))
+
+    with open(os.path.join(args.result_dir,'eval_cat.json'), 'w') as f:
+        json.dump(eval_cat_list, f, indent=4)

spatial-model/VLM-3R/llava/eval/model_scanqa.py

@@ -0,0 +1,133 @@
+import argparse
+import torch
+import os
+import json
+from tqdm import tqdm
+import shortuuid
+
+from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+from llava.conversation import conv_templates, SeparatorStyle
+from llava.model.builder import load_pretrained_model
+from llava.utils import disable_torch_init
+from llava.mm_utils import tokenizer_image_token, get_model_name_from_path
+
+from PIL import Image
+import math
+from llava.eval.model_vqa import preprocess_qwen
+
+from decord import VideoReader, cpu
+import numpy as np
+import warnings
+warnings.filterwarnings("ignore")
+import copy
+
+def load_video(video_path, max_frames_num,fps=1,force_sample=False):
+    if max_frames_num == 0:
+        return np.zeros((1, 336, 336, 3))
+    vr = VideoReader(video_path, ctx=cpu(0),num_threads=1)
+    total_frame_num = len(vr)
+    video_time = total_frame_num / vr.get_avg_fps()
+    fps = round(vr.get_avg_fps()/fps)
+    frame_idx = [i for i in range(0, len(vr), fps)]
+    frame_time = [i/fps for i in frame_idx]
+    if len(frame_idx) > max_frames_num or force_sample:
+        sample_fps = max_frames_num
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, sample_fps, dtype=int)
+        frame_idx = uniform_sampled_frames.tolist()
+        frame_time = [i/vr.get_avg_fps() for i in frame_idx]
+    frame_time = ",".join([f"{i:.2f}s" for i in frame_time])
+    spare_frames = vr.get_batch(frame_idx).asnumpy()
+    # import pdb;pdb.set_trace()
+    return spare_frames,frame_time,video_time
+
+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 eval_model(args):
+    # Model
+    disable_torch_init()
+    model_path = os.path.expanduser(args.model_path)
+    model_name = "llava_qwen_lora"
+    tokenizer, model, processor, context_len = load_pretrained_model(model_path, args.model_base, model_name, torch_dtype="bfloat16")
+    model.to(device="cuda")
+    # questions = [json.loads(q) for q in open(os.path.expanduser(args.question_file), "r")]
+    with open(args.question_file, 'r') as file:
+        questions = json.load(file)
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+    answers_file = os.path.expanduser(args.answers_file)
+    os.makedirs(os.path.dirname(answers_file), exist_ok=True)
+    ans_file = open(answers_file, "w")
+    for line in tqdm(questions):
+        idx = line["question_id"]
+        scene_id = line["scene_id"]
+        video_path = os.path.join(args.video_folder, f"{scene_id}.mp4")
+        qs = line["question"]
+
+        args.conv_mode = "qwen_1_5"
+
+        # load video
+        video,frame_time,video_time = load_video(video_path, args.max_frames_num, 1, force_sample=True)
+        video = processor.preprocess(video, return_tensors="pt")["pixel_values"].cuda().bfloat16()
+        video = [video]
+        time_instruciton = f"The video lasts for {video_time:.2f} seconds, and {len(video[0])} frames are uniformly sampled from it. These frames are located at {frame_time}.Please answer the following questions related to this video."
+        question = DEFAULT_IMAGE_TOKEN + f"{time_instruciton}\n{qs}\nAnswer the question simply."
+        
+        conv = copy.deepcopy(conv_templates[args.conv_mode])
+        conv.append_message(conv.roles[0], question)
+        conv.append_message(conv.roles[1], None)
+        prompt_question = conv.get_prompt()
+        
+        input_ids = tokenizer_image_token(prompt_question, tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt").unsqueeze(0).to(args.device)
+
+        with torch.inference_mode():
+            output_ids = model.generate(
+                input_ids,
+                images=video,
+                modalities= ["video"],
+                do_sample=True if args.temperature > 0 else False,
+                temperature=args.temperature,
+                top_p=args.top_p,
+                num_beams=args.num_beams,
+                max_new_tokens=512,
+                use_cache=True,
+            )
+
+        outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+
+        ans_id = shortuuid.uuid()
+        ans_file.write(json.dumps({"question_id": idx,
+                                   "prompt": prompt_question,
+                                   "text": outputs,
+                                   "answer_id": ans_id,
+                                   "model_id": model_name,
+                                   "metadata": {}}) + "\n")
+        ans_file.flush()
+    ans_file.close()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-path", type=str, default="checkpoints/llava3d-v1.5-7b-task-v3-tuning")
+    parser.add_argument("--model-base", type=str, default=None)
+    parser.add_argument("--video-folder", type=str, default="playground/data/LLaVA-3D-Pretrain")
+    parser.add_argument("--question-file", type=str, default="playground/data/annotations/llava3d_sqa3d_val_question.json")
+    parser.add_argument("--answers-file", type=str, default="./llava3d_sqa3d_val_answer_pred.json")
+    parser.add_argument("--max-frames-num", type=int, default=32)
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--extra-prompt", type=str, default="")
+    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("--temperature", type=float, default=0.)
+    parser.add_argument("--top_p", type=float, default=None)
+    parser.add_argument("--num_beams", type=int, default=1)
+    args = parser.parse_args()
+
+    eval_model(args)

spatial-model/VLM-3R/llava/eval/model_sqa3d.py

@@ -0,0 +1,154 @@
+import argparse
+import torch
+import os
+import json
+from tqdm import tqdm
+import shortuuid
+
+from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+from llava.conversation import conv_templates, SeparatorStyle
+from llava.model.builder import load_pretrained_model
+from llava.utils import disable_torch_init
+from llava.mm_utils import tokenizer_image_token, get_model_name_from_path
+
+from PIL import Image
+import math
+from llava.eval.model_vqa import preprocess_qwen
+
+from decord import VideoReader, cpu
+import numpy as np
+import warnings
+warnings.filterwarnings("ignore")
+import copy
+
+
+def load_video(video_path, max_frames_num,fps=1,force_sample=False):
+    if max_frames_num == 0:
+        return np.zeros((1, 336, 336, 3))
+    vr = VideoReader(video_path, ctx=cpu(0),num_threads=1)
+    total_frame_num = len(vr)
+    video_time = total_frame_num / vr.get_avg_fps()
+    fps = round(vr.get_avg_fps()/fps)
+    frame_idx = [i for i in range(0, len(vr), fps)]
+    frame_time = [i/fps for i in frame_idx]
+    if len(frame_idx) > max_frames_num or force_sample:
+        sample_fps = max_frames_num
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, sample_fps, dtype=int)
+        frame_idx = uniform_sampled_frames.tolist()
+        frame_time = [i/vr.get_avg_fps() for i in frame_idx]
+    frame_time = ",".join([f"{i:.2f}s" for i in frame_time])
+    spare_frames = vr.get_batch(frame_idx).asnumpy()
+    # import pdb;pdb.set_trace()
+    return spare_frames,frame_time,video_time
+
+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 eval_model(args):
+    # Model
+    disable_torch_init()
+    model_path = os.path.expanduser(args.model_path)
+    model_name = "llava_qwen_lora"
+    tokenizer, model, processor, context_len = load_pretrained_model(model_path, args.model_base, model_name, torch_dtype="bfloat16")
+    model.to(device="cuda")
+    
+    # Load questions
+    with open(args.question_file, 'r') as file:
+        questions = json.load(file)
+    questions = get_chunk(questions, args.num_chunks, args.chunk_idx)
+    
+    answers_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answers_file), exist_ok=True)
+    ans_file = open(answers_file, "w")
+    
+    for line in tqdm(questions):
+        idx = line["id"]
+        question_type = line["metadata"]["question_type"]
+        dataset_name = line["metadata"]["dataset"]
+        video_id = line["video"].split("/")[-1]
+        
+        # Get video path - assuming video files are in video_folder with .mp4 extension
+        video_path = os.path.join(args.video_folder, f"{video_id}.mp4")
+        
+        gt = line["conversations"][1]["value"]
+        qs = line["conversations"][0]["value"].replace("<image>", "")
+
+        args.conv_mode = "qwen_1_5"
+
+        # Load video
+        video, frame_time, video_time = load_video(video_path, args.max_frame_num, 1, force_sample=True)
+        video = processor.preprocess(video, return_tensors="pt")["pixel_values"].cuda().bfloat16()
+        video = [video]
+        
+        time_instruction = f"The video lasts for {video_time:.2f} seconds, and {len(video[0])} frames are uniformly sampled from it. These frames are located at {frame_time}.Please answer the following questions related to this video."
+        question = DEFAULT_IMAGE_TOKEN + f"{time_instruction}\n{qs}"
+        
+        conv = copy.deepcopy(conv_templates[args.conv_mode])
+        conv.append_message(conv.roles[0], question)
+        conv.append_message(conv.roles[1], None)
+        prompt_question = conv.get_prompt()
+        
+        input_ids = tokenizer_image_token(prompt_question, tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt").unsqueeze(0).to(args.device)
+
+        with torch.inference_mode():
+            output_ids = model.generate(
+                input_ids,
+                images=video,
+                modalities=["video"],
+                do_sample=True if args.temperature > 0 else False,
+                temperature=args.temperature,
+                top_p=args.top_p,
+                num_beams=args.num_beams,
+                max_new_tokens=512,
+                use_cache=True,
+            )
+
+        outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+
+        ans_id = shortuuid.uuid()
+        ans_file.write(json.dumps({
+            "dataset": dataset_name,
+            "sample_id": idx,
+            "prompt": prompt_question,
+            "pred_response": outputs,
+            "gt_response": gt,
+            "model_id": model_name,
+            "question_type": question_type,
+        }) + "\n")
+        ans_file.flush()
+
+    ans_file.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-path", type=str, default="checkpoints/llava3d-v1.5-7b-task-v3-tuning")
+    parser.add_argument("--model-base", type=str, default=None)
+    parser.add_argument("--video-folder", type=str, default="playground/data/LLaVA-3D-Pretrain")
+    parser.add_argument("--extra-prompt", type=str, default="The video captures 3D spatial information of a scene. Please focus on the spatial relationships in the video and answer the following questions.\n")
+    parser.add_argument("--question-file", type=str, default="playground/data/annotations/llava3d_sqa3d_val_question.json")
+    parser.add_argument("--answer-file", type=str, default="./llava3d_sqa3d_val_answer_pred.json")
+    parser.add_argument("--conv-mode", type=str, default="llava_v1")
+    parser.add_argument("--max-frame-num", type=int, default=32)
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--num-chunks", type=int, default=1)
+    parser.add_argument("--chunk-idx", type=int, default=0)
+    parser.add_argument("--temperature", type=float, default=0.)
+    parser.add_argument("--top_p", type=float, default=None)
+    parser.add_argument("--num_beams", type=int, default=1)
+    parser.add_argument("--force_sample", type=bool, default=True)
+    args = parser.parse_args()
+
+    # if os.path.exists(args.answer_file):
+    #     print(f"The {args.answer_file} already exists!!!")
+    #     exit()
+    
+    eval_model(args)

spatial-model/VLM-3R/llava/eval/model_sqa3d_preload.py

@@ -0,0 +1,234 @@
+import argparse
+import torch
+import os
+import json
+import ray
+import time
+import numpy as np
+from tqdm import tqdm
+import shortuuid
+import fasteners
+
+# Fix bitsandbytes CUDA setup issue in Ray workers
+os.environ['BNB_CUDA_VERSION'] = '121'  # CUDA 12.1
+os.environ['BITSANDBYTES_NOWELCOME'] = '1'
+os.environ['CUDA_VISIBLE_DEVICES'] = os.environ.get('CUDA_VISIBLE_DEVICES', '0,1,2,3')
+
+from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+from llava.conversation import conv_templates, SeparatorStyle
+from llava.model.builder import load_pretrained_model
+from llava.utils import disable_torch_init
+from llava.mm_utils import tokenizer_image_token, get_model_name_from_path
+
+from PIL import Image
+import math
+from llava.eval.model_vqa import preprocess_qwen
+
+from decord import VideoReader, cpu
+import warnings
+warnings.filterwarnings("ignore")
+import copy
+
+
+def load_video(video_path, max_frames_num, fps=1, force_sample=False):
+    """Load video frames from file."""
+    if max_frames_num == 0:
+        return np.zeros((1, 336, 336, 3))
+    vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
+    total_frame_num = len(vr)
+    video_time = total_frame_num / vr.get_avg_fps()
+    fps = round(vr.get_avg_fps()/fps)
+    frame_idx = [i for i in range(0, len(vr), fps)]
+    frame_time = [i/fps for i in frame_idx]
+    if len(frame_idx) > max_frames_num or force_sample:
+        sample_fps = max_frames_num
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, sample_fps, dtype=int)
+        frame_idx = uniform_sampled_frames.tolist()
+        frame_time = [i/vr.get_avg_fps() for i in frame_idx]
+    frame_time = ",".join([f"{i:.2f}s" for i in frame_time])
+    spare_frames = vr.get_batch(frame_idx).asnumpy()
+    return spare_frames, frame_time, video_time
+
+
+@ray.remote(num_gpus=1)
+def eval_model(questions, args):
+    # Fix bitsandbytes CUDA setup in worker process
+    gpu_ids = ray.get_gpu_ids()
+    if gpu_ids:
+        os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu_ids[0])
+    os.environ['BNB_CUDA_VERSION'] = '121'  # CUDA 12.1
+    os.environ['BITSANDBYTES_NOWELCOME'] = '1'
+    
+    # Model
+    disable_torch_init()
+    model_path = os.path.expanduser(args.model_path)
+    model_name = "llava_qwen_lora"
+    tokenizer, model, processor, context_len = load_pretrained_model(
+        model_path, args.model_base, model_name, torch_dtype="bfloat16"
+    )
+    model.to(device="cuda")
+    
+    answer_file = os.path.expanduser(args.answer_file)
+    os.makedirs(os.path.dirname(answer_file), exist_ok=True)
+    ans_file = open(answer_file, "a")
+    file_lock = fasteners.InterProcessLock(ans_file)
+    
+    inference_time = []
+    feature_load_time = []
+    
+    for line in tqdm(questions):
+        idx = line["id"]
+        question_type = line["metadata"]["question_type"]
+        dataset_name = line["metadata"]["dataset"]
+        video_id = line["video"].split("/")[-1]
+        
+        # Get video path - assuming video files are in video_folder with .mp4 extension
+        video_path = os.path.join(args.video_folder, f"{video_id}.mp4")
+        
+        gt = line["conversations"][1]["value"]
+        qs = line["conversations"][0]["value"].replace("<image>", "")
+
+        args.conv_mode = "qwen_1_5"
+
+        start_time = time.time()
+        
+        # Try to load precomputed spatial features first
+        spatial_features = None
+        if args.feature_dir:
+            # Following the pattern from train.py: replace .mp4 with .pt and videos with spatial_features
+            feature_path = os.path.join(args.feature_dir, f"{video_id}.pt")
+            if not os.path.exists(feature_path):
+                # Try alternative path pattern
+                feature_path = video_path.replace('.mp4', '.pt').replace('videos', 'spatial_features')
+            
+            if os.path.exists(feature_path):
+                # Load precomputed spatial features
+                feature_load_time.append(time.time() - start_time)
+                spatial_features = torch.load(feature_path, map_location='cuda')
+                if isinstance(spatial_features, dict) and 'spatial_features' in spatial_features:
+                    spatial_features = spatial_features['spatial_features']
+                spatial_features = [spatial_features]
+                
+                # Still need to load video for metadata, but can skip processing
+                video, frame_time, video_time = load_video(video_path, args.max_frame_num, 1, force_sample=True)
+                video = processor.preprocess(video, return_tensors="pt")["pixel_values"].cuda().bfloat16()
+                video = [video]
+            else:
+                # No precomputed features, process normally
+                video, frame_time, video_time = load_video(video_path, args.max_frame_num, 1, force_sample=True)
+                video = processor.preprocess(video, return_tensors="pt")["pixel_values"].cuda().bfloat16()
+                video = [video]
+        else:
+            # No feature directory specified, process normally
+            video, frame_time, video_time = load_video(video_path, args.max_frame_num, 1, force_sample=True)
+            video = processor.preprocess(video, return_tensors="pt")["pixel_values"].cuda().bfloat16()
+            video = [video]
+        
+        time_instruction = f"The video lasts for {video_time:.2f} seconds, and {len(video[0])} frames are uniformly sampled from it. These frames are located at {frame_time}.Please answer the following questions related to this video."
+        question = DEFAULT_IMAGE_TOKEN + f"{time_instruction}\n{qs}"
+        
+        if args.extra_prompt:
+            question = DEFAULT_IMAGE_TOKEN + f"{args.extra_prompt}\n{time_instruction}\n{qs}"
+        
+        conv = copy.deepcopy(conv_templates[args.conv_mode])
+        conv.append_message(conv.roles[0], question)
+        conv.append_message(conv.roles[1], None)
+        prompt_question = conv.get_prompt()
+        
+        input_ids = tokenizer_image_token(prompt_question, tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt").unsqueeze(0).to("cuda")
+
+        with torch.inference_mode():
+            output_ids = model.generate(
+                input_ids,
+                images=video,
+                spatial_features=spatial_features,  # Pass precomputed spatial features
+                modalities=["video"],
+                do_sample=True if args.temperature > 0 else False,
+                temperature=args.temperature,
+                top_p=args.top_p,
+                num_beams=args.num_beams,
+                max_new_tokens=512,
+                use_cache=True,
+            )
+        
+        inference_time.append(time.time() - start_time)
+
+        outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip()
+
+        ans_id = shortuuid.uuid()
+        
+        with file_lock:
+            ans_file.write(json.dumps({
+                "dataset": dataset_name,
+                "sample_id": idx,
+                "prompt": prompt_question,
+                "pred_response": outputs,
+                "gt_response": gt,
+                "model_id": model_name,
+                "question_type": question_type,
+            }) + "\n")
+            ans_file.flush()
+
+    ans_file.close()
+    
+    return {
+        'inference_time': inference_time,
+        'feature_load_time': feature_load_time
+    }
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-path", type=str, default="checkpoints/llava3d-v1.5-7b-task-v3-tuning")
+    parser.add_argument("--model-base", type=str, default=None)
+    parser.add_argument("--video-folder", type=str, default="playground/data/LLaVA-3D-Pretrain")
+    parser.add_argument("--feature-dir", type=str, default=None,
+                       help="Directory containing precomputed spatial features")
+    parser.add_argument("--extra-prompt", type=str, default="The video captures 3D spatial information of a scene. Please focus on the spatial relationships in the video and answer the following questions.")
+    parser.add_argument("--question-file", type=str, default="playground/data/annotations/llava3d_sqa3d_val_question.json")
+    parser.add_argument("--answer-file", type=str, default="./llava3d_sqa3d_val_answer_pred.jsonl")
+    parser.add_argument("--conv-mode", type=str, default="llava_v1")
+    parser.add_argument("--max-frame-num", type=int, default=32)
+    parser.add_argument("--n_gpu", type=int, default=4)
+    parser.add_argument("--temperature", type=float, default=0.)
+    parser.add_argument("--top_p", type=float, default=None)
+    parser.add_argument("--num_beams", type=int, default=1)
+    parser.add_argument("--force_sample", type=bool, default=True)
+    parser.add_argument("--debug", action="store_true",
+                       help="Enable debug mode with Ray local mode")
+    args = parser.parse_args()
+
+    # Load questions
+    with open(args.question_file, 'r') as file:
+        questions = json.load(file)
+    
+    if os.path.exists(args.answer_file):
+        print(f"The {args.answer_file} already exists! Appending to it.")
+    
+    # Initialize Ray
+    if args.n_gpu == 1 and args.debug:
+        # Use Ray local mode for debugging
+        ray.init(local_mode=True)
+    else:
+        ray.init(num_gpus=args.n_gpu)
+    
+    # Distribute questions across GPUs
+    features = []
+    for i in range(args.n_gpu):
+        features.append(eval_model.remote(questions[i::args.n_gpu], args))
+    
+    # Get results
+    results = ray.get(features)
+    
+    # Aggregate statistics
+    all_inference_times = []
+    all_feature_load_times = []
+    
+    for result in results:
+        all_inference_times.extend(result['inference_time'])
+        all_feature_load_times.extend(result['feature_load_time'])
+    
+    print(f"Average inference time: {np.mean(all_inference_times):.2f} seconds")
+    if all_feature_load_times:
+        print(f"Average feature load time: {np.mean(all_feature_load_times):.4f} seconds")
+    print(f"Total questions processed: {len(questions)}")

spatial-model/VLM-3R/llava/eval/scanqa_evaluator.py

@@ -0,0 +1,283 @@
+import re
+import json
+from tqdm import tqdm
+import mmengine
+from pycocoevalcap.bleu.bleu import Bleu
+from pycocoevalcap.meteor.meteor import Meteor
+from pycocoevalcap.rouge.rouge import Rouge
+from pycocoevalcap.cider.cider import Cider
+from pycocoevalcap.spice.spice import Spice
+from pycocoevalcap.tokenizer.ptbtokenizer import PTBTokenizer
+
+tokenizer = PTBTokenizer()
+scorers = [
+    (Bleu(4), ["Bleu_1", "Bleu_2", "Bleu_3", "Bleu_4"]),
+    (Meteor(), "METEOR"),
+    (Rouge(), "ROUGE_L"),
+    (Cider(), "CIDEr"),
+    (Spice(), "SPICE")
+]
+
+
+# refer to LEO: embodied-generalist
+# https://github.com/embodied-generalist/embodied-generalist/blob/477dc44b8b18dbfbe6823c307436d896ec8b062e/data/data_utils.py#L322-L379
+def clean_answer(data):
+    data = data.lower()
+    data = re.sub('[ ]+$' ,'', data)
+    data = re.sub('^[ ]+' ,'', data)
+    data = re.sub(' {2,}', ' ', data)
+
+    data = re.sub('\.[ ]{2,}', '. ', data)
+    data = re.sub('[^a-zA-Z0-9,\'\s\-:]+', '', data)
+    data = re.sub('ç' ,'c', data)
+    data = re.sub('’' ,'\'', data)
+    data = re.sub(r'\bletf\b' ,'left', data)
+    data = re.sub(r'\blet\b' ,'left', data)
+    data = re.sub(r'\btehre\b' ,'there', data)
+    data = re.sub(r'\brigth\b' ,'right', data)
+    data = re.sub(r'\brght\b' ,'right', data)
+    data = re.sub(r'\bbehine\b', 'behind', data)
+    data = re.sub(r'\btv\b' ,'TV', data)
+    data = re.sub(r'\bchai\b' ,'chair', data)
+    data = re.sub(r'\bwasing\b' ,'washing', data)
+    data = re.sub(r'\bwaslked\b' ,'walked', data)
+    data = re.sub(r'\boclock\b' ,'o\'clock', data)
+    data = re.sub(r'\bo\'[ ]+clock\b' ,'o\'clock', data)
+
+    # digit to word, only for answer
+    data = re.sub(r'\b0\b', 'zero', data)
+    data = re.sub(r'\bnone\b', 'zero', data)
+    data = re.sub(r'\b1\b', 'one', data)
+    data = re.sub(r'\b2\b', 'two', data)
+    data = re.sub(r'\b3\b', 'three', data)
+    data = re.sub(r'\b4\b', 'four', data)
+    data = re.sub(r'\b5\b', 'five', data)
+    data = re.sub(r'\b6\b', 'six', data)
+    data = re.sub(r'\b7\b', 'seven', data)
+    data = re.sub(r'\b8\b', 'eight', data)
+    data = re.sub(r'\b9\b', 'nine', data)
+    data = re.sub(r'\b10\b', 'ten', data)
+    data = re.sub(r'\b11\b', 'eleven', data)
+    data = re.sub(r'\b12\b', 'twelve', data)
+    data = re.sub(r'\b13\b', 'thirteen', data)
+    data = re.sub(r'\b14\b', 'fourteen', data)
+    data = re.sub(r'\b15\b', 'fifteen', data)
+    data = re.sub(r'\b16\b', 'sixteen', data)
+    data = re.sub(r'\b17\b', 'seventeen', data)
+    data = re.sub(r'\b18\b', 'eighteen', data)
+    data = re.sub(r'\b19\b', 'nineteen', data)
+    data = re.sub(r'\b20\b', 'twenty', data)
+    data = re.sub(r'\b23\b', 'twenty-three', data)
+
+    # misc
+    # no1, mat2, etc
+    data = re.sub(r'\b([a-zA-Z]+)([0-9])\b' ,r'\g<1>', data)
+    data = re.sub(r'\ba\b ([a-zA-Z]+)' ,r'\g<1>', data)
+    data = re.sub(r'\ban\b ([a-zA-Z]+)' ,r'\g<1>', data)
+    data = re.sub(r'\bthe\b ([a-zA-Z]+)' ,r'\g<1>', data)
+
+    data = re.sub(r'\bbackwards\b', 'backward', data)
+
+    return data
+
+
+# refer to LEO: embodied-generalist
+# https://github.com/embodied-generalist/embodied-generalist/blob/477dc44b8b18dbfbe6823c307436d896ec8b062e/evaluator/scanqa_eval.py#L41-L50
+def classify_question_type(question):
+    question_lower = question.lower()
+    
+    # Color questions
+    if question_lower.startswith('what color') or question_lower.startswith('what is the color'):
+        return 'Color'
+    
+    # Object nature questions  
+    if (question_lower.startswith('what type') or 
+        question_lower.startswith('what shape') or 
+        question_lower.startswith('what kind')):
+        return 'Object nature'
+    
+    # Place questions
+    if question_lower.startswith('where is'):
+        return 'Place'
+    
+    # Number questions
+    if question_lower.startswith('how many'):
+        return 'Number'
+    
+    # Object questions (What is, except color questions)
+    if question_lower.startswith('what is') and not question_lower.startswith('what is the color'):
+        return 'Object'
+    
+    # Everything else is Other
+    return 'Other'
+
+def answer_match(pred, gts):
+    # return EM and refined EM
+    if pred in gts:
+        return 1, 1
+    for gt in gts:
+        if ''.join(pred.split()) in ''.join(gt.split()) or ''.join(gt.split()) in ''.join(pred.split()):
+            return 0, 1
+    return 0, 0
+
+def calc_scanqa_score(preds, gts, tokenizer, scorers):
+    val_scores = {}
+    tmp_preds = {}
+    tmp_targets = {}
+    acc, refined_acc = 0, 0
+    
+    # Initialize subtask tracking
+    subtasks = ['Object', 'Color', 'Object nature', 'Place', 'Number', 'Other']
+    subtask_stats = {task: {
+        'count': 0,
+        'acc': 0,
+        'refined_acc': 0,
+        'tmp_preds': {},
+        'tmp_targets': {}
+    } for task in subtasks}
+    
+    print("Total samples:", len(preds))
+    
+    # Create a dictionary to map question_id to ground truth data
+    gt_dict = {gt['question_id']: gt for gt in gts}
+    
+    # Check if all predictions have corresponding ground truth
+    missing_gt = [pred['question_id'] for pred in preds if pred['question_id'] not in gt_dict]
+    if missing_gt:
+        print(f"Warning: {len(missing_gt)} predictions have no corresponding ground truth")
+        print(f"Missing question_ids: {missing_gt[:10]}...")  # Show first 10
+    
+    matched_count = 0
+    for item_id, pred in tqdm(enumerate(preds)):
+        question_id = pred['question_id']
+        
+        # Skip if no ground truth found
+        if question_id not in gt_dict:
+            continue
+            
+        gt = gt_dict[question_id]
+        matched_count += 1
+        
+        # Classify question type
+        question_type = classify_question_type(gt['question'])
+        
+        pred_answer = pred['text']
+        gt_answers = gt['answers']
+        pred_answer = clean_answer(pred_answer)
+        ref_captions = [clean_answer(gt_answer) for gt_answer in gt_answers]
+        tmp_acc, tmp_refined_acc = answer_match(pred_answer, ref_captions)
+        
+        # Update overall metrics
+        acc += tmp_acc
+        refined_acc += tmp_refined_acc
+        tmp_preds[item_id] = [{'caption': pred_answer}]
+        ref_captions = [p.replace("\n", " ").strip() for p in ref_captions]
+        tmp_targets[item_id] = [{'caption': caption} for caption in ref_captions]
+        
+        # Update subtask metrics
+        subtask_stats[question_type]['count'] += 1
+        subtask_stats[question_type]['acc'] += tmp_acc
+        subtask_stats[question_type]['refined_acc'] += tmp_refined_acc
+        subtask_stats[question_type]['tmp_preds'][item_id] = [{'caption': pred_answer}]
+        subtask_stats[question_type]['tmp_targets'][item_id] = [{'caption': caption} for caption in ref_captions]
+    
+    print(f"Matched {matched_count} predictions with ground truth")
+    
+    if matched_count == 0:
+        print("Error: No matched predictions found!")
+        return val_scores, subtask_stats
+    
+    # Calculate overall scores
+    tmp_preds = tokenizer.tokenize(tmp_preds)
+    tmp_targets = tokenizer.tokenize(tmp_targets)
+    acc = acc / matched_count
+    refined_acc = refined_acc / matched_count
+    val_scores["[scanqa] EM1"] = acc
+    val_scores["[scanqa] EM1_refined"] = refined_acc
+    for scorer, method in scorers:
+        score, scores = scorer.compute_score(tmp_targets, tmp_preds)
+        if type(method) == list:
+            for sc, scs, m in zip(score, scores, method):
+                val_scores[f"[scanqa] {m}"] = sc
+        else:
+            val_scores[f"[scanqa] {method}"] = score
+    
+    # Calculate subtask scores
+    for task in subtasks:
+        if subtask_stats[task]['count'] > 0:
+            # Calculate EM scores
+            subtask_stats[task]['em1'] = subtask_stats[task]['acc'] / subtask_stats[task]['count']
+            subtask_stats[task]['em1_refined'] = subtask_stats[task]['refined_acc'] / subtask_stats[task]['count']
+            
+            # Calculate other metrics if there are samples
+            if subtask_stats[task]['tmp_preds']:
+                task_preds = tokenizer.tokenize(subtask_stats[task]['tmp_preds'])
+                task_targets = tokenizer.tokenize(subtask_stats[task]['tmp_targets'])
+                
+                for scorer, method in scorers:
+                    score, scores = scorer.compute_score(task_targets, task_preds)
+                    if type(method) == list:
+                        for sc, scs, m in zip(score, scores, method):
+                            subtask_stats[task][m.lower()] = sc
+                    else:
+                        subtask_stats[task][method.lower()] = score
+    
+    return val_scores, subtask_stats
+
+def print_subtask_results_table(subtask_stats):
+    print("\n" + "="*80)
+    print("SUBTASK EVALUATION RESULTS")
+    print("="*80)
+    
+    # Print header with only the 5 requested metrics
+    header = f"{'Question type':<15} {'Count':<8} {'BLEU-1':<8} {'BLEU-4':<8} {'METEOR':<8} {'ROUGE-L':<8} {'CIDEr':<8}"
+    print(header)
+    print("-" * 80)
+    
+    # Print results for each subtask
+    for task in ['Object', 'Color', 'Object nature', 'Place', 'Number', 'Other']:
+        if subtask_stats[task]['count'] > 0:
+            bleu_1 = subtask_stats[task].get('bleu_1', 0) * 100 if 'bleu_1' in subtask_stats[task] else 0
+            bleu_4 = subtask_stats[task].get('bleu_4', 0) * 100 if 'bleu_4' in subtask_stats[task] else 0
+            meteor = subtask_stats[task].get('meteor', 0) * 100 if 'meteor' in subtask_stats[task] else 0
+            rouge_l = subtask_stats[task].get('rouge_l', 0) * 100 if 'rouge_l' in subtask_stats[task] else 0
+            cider = subtask_stats[task].get('cider', 0) * 100 if 'cider' in subtask_stats[task] else 0
+            
+            row = f"{task:<15} {subtask_stats[task]['count']:<8} {bleu_1:<8.2f} {bleu_4:<8.2f} {meteor:<8.2f} {rouge_l:<8.2f} {cider:<8.2f}"
+            print(row)
+        else:
+            row = f"{task:<15} {subtask_stats[task]['count']:<8} {'N/A':<8} {'N/A':<8} {'N/A':<8} {'N/A':<8} {'N/A':<8}"
+            print(row)
+    
+    print("-" * 80)
+    
+    # Calculate and print totals
+    total_count = sum(subtask_stats[task]['count'] for task in subtask_stats)
+    if total_count > 0:
+        # Calculate weighted averages for the 5 requested metrics
+        total_bleu_1 = sum(subtask_stats[task].get('bleu_1', 0) * subtask_stats[task]['count'] 
+                          for task in subtask_stats if subtask_stats[task]['count'] > 0) / total_count * 100
+        total_bleu_4 = sum(subtask_stats[task].get('bleu_4', 0) * subtask_stats[task]['count'] 
+                          for task in subtask_stats if subtask_stats[task]['count'] > 0) / total_count * 100
+        total_meteor = sum(subtask_stats[task].get('meteor', 0) * subtask_stats[task]['count'] 
+                          for task in subtask_stats if subtask_stats[task]['count'] > 0) / total_count * 100
+        total_rouge_l = sum(subtask_stats[task].get('rouge_l', 0) * subtask_stats[task]['count'] 
+                           for task in subtask_stats if subtask_stats[task]['count'] > 0) / total_count * 100
+        total_cider = sum(subtask_stats[task].get('cider', 0) * subtask_stats[task]['count'] 
+                         for task in subtask_stats if subtask_stats[task]['count'] > 0) / total_count * 100
+        
+        total_row = f"{'TOTAL':<15} {total_count:<8} {total_bleu_1:<8.2f} {total_bleu_4:<8.2f} {total_meteor:<8.2f} {total_rouge_l:<8.2f} {total_cider:<8.2f}"
+        print(total_row)
+    
+    print("="*80)
+
+pred_json = 'results/llava_next_video_val_answer_pred_vsibench.json'
+preds = [json.loads(q) for q in open(pred_json, "r")]
+gt_json = 'thinking-in-space/data/scanqa/ScanQA_v1.0_val.json'
+gts = mmengine.load(gt_json)
+
+val_scores, subtask_stats = calc_scanqa_score(preds, gts, tokenizer, scorers)
+print("\nOverall Scores:")
+print(val_scores)
+
+print_subtask_results_table(subtask_stats)

spatial-model/VLM-3R/llava/mm_utils.py

@@ -0,0 +1,395 @@
+from PIL import Image
+from io import BytesIO
+import base64
+import math
+import ast
+import re
+import torch
+from transformers import StoppingCriteria
+from llava.constants import IMAGE_TOKEN_INDEX
+
+
+def resize_and_center_crop(image, shortest_edge_length):
+    # Calculate new dimensions and resize
+    aspect_ratio = float(image.width) / float(image.height)
+    if aspect_ratio > 1:
+        new_width = int(shortest_edge_length * aspect_ratio)
+        new_height = shortest_edge_length
+    else:
+        new_width = shortest_edge_length
+        new_height = int(shortest_edge_length / aspect_ratio)
+    resized_image = image.resize((new_width, new_height), Image.ANTIALIAS)
+
+    # Calculate the position and perform the center crop
+    left = (new_width - shortest_edge_length) / 2
+    top = (new_height - shortest_edge_length) / 2
+    right = (new_width + shortest_edge_length) / 2
+    bottom = (new_height + shortest_edge_length) / 2
+    cropped_image = resized_image.crop((left, top, right, bottom))
+
+    return cropped_image
+
+
+def auto_pad_images(image, grid_params):
+    assert isinstance(image, Image.Image), "Input should be a Pillow Image"
+    assert len(grid_params) > 0, "Grid parameters should not be empty"
+
+    # Step 1: Calculate and find the closest aspect ratio
+    input_width, input_height = image.size
+    input_aspect_ratio = input_width / input_height
+    candidate_resolutions = [(w / h, w, h) for w in grid_params for h in grid_params]
+    closest_aspect_ratio = min(candidate_resolutions, key=lambda x: abs(input_aspect_ratio - x[0]))
+
+    candidate_resolutions = [(x[1], x[2]) for x in candidate_resolutions if abs(x[0] - closest_aspect_ratio[0]) < 1e-3]
+
+    target_resolution = min(candidate_resolutions, key=lambda res: abs(max(input_width, input_height) / max(res) - 1))
+
+    resize_width, resize_height = target_resolution
+    if input_width > input_height:
+        resize_height = int(resize_width / input_aspect_ratio)
+    else:
+        resize_width = int(resize_height * input_aspect_ratio)
+    resized_image = image.resize((resize_width, resize_height), Image.ANTIALIAS)
+
+    # Step 5: Pad the resized image if necessary to match the target resolution
+    pad_width = target_resolution[0] - resize_width
+    pad_height = target_resolution[1] - resize_height
+    padded_image = Image.new("RGB", target_resolution, color=(0, 0, 0))
+    padded_image.paste(resized_image, (pad_width // 2, pad_height // 2))
+
+    return padded_image
+
+
+def extract_patches(image, patch_size, overlap_ratio):
+    assert isinstance(image, Image.Image), "Input should be a Pillow Image"
+    assert patch_size > 0, "Patch size should be greater than 0"
+    assert 0 <= overlap_ratio < 1, "Overlap ratio should be between 0 and 1"
+
+    W, H = image.size
+    patches = []
+
+    stride = int(patch_size * (1 - overlap_ratio))
+
+    num_patches_y = (H - patch_size) // stride + 1
+    num_patches_x = (W - patch_size) // stride + 1
+
+    y_start = (H - (num_patches_y - 1) * stride - patch_size) // 2
+    x_start = (W - (num_patches_x - 1) * stride - patch_size) // 2
+
+    for y in range(y_start, y_start + num_patches_y * stride, stride):
+        for x in range(x_start, x_start + num_patches_x * stride, stride):
+            patch = image.crop((x, y, x + patch_size, y + patch_size))
+            patches.append(patch)
+
+    return patches
+
+
+def process_highres_image_crop_split(image, data_args, processor=None):
+    crop_resolution = data_args.image_crop_resolution
+    split_resolution = data_args.image_split_resolution
+    if processor is None:
+        processor = data_args.image_processor
+    image_crop = resize_and_center_crop(image, crop_resolution)
+    image_patches = extract_patches(image_crop, patch_size=split_resolution, overlap_ratio=0)
+    image_patches = [processor.preprocess(image_patch, return_tensors="pt")["pixel_values"][0] for image_patch in image_patches]
+    return torch.stack(image_patches, dim=0)
+
+
+def process_highres_image(image, processor, grid_pinpoints):
+    grid_params = [int(x) for x in grid_pinpoints.split(",")]
+    width_height = max(image.size)
+    fit_grid_params = [x for x in grid_params if x >= width_height]
+    if len(fit_grid_params) == 0:
+        select_size = max(grid_params)
+    else:
+        select_size = min(fit_grid_params)
+    # FIXME: always select the 448
+    select_size = max(grid_params)
+    image_padded = expand2square(image, tuple(int(x * 255) for x in processor.image_mean))
+
+    # FIXME: this seems to be a bug that it always resizes instead of padding
+    image_original_resize = image.resize((processor.size["shortest_edge"], processor.size["shortest_edge"]))
+    image_padded = image_padded.resize((select_size, select_size))
+    image_patches = extract_patches(image_padded, patch_size=processor.size["shortest_edge"], overlap_ratio=0)
+    image_patches = [image_original_resize] + image_patches
+    image_patches = [processor.preprocess(image_patch, return_tensors="pt")["pixel_values"][0] for image_patch in image_patches]
+    return torch.stack(image_patches, dim=0)
+
+
+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:
+        # Calculate the downscaled size to keep the aspect ratio
+        scale = min(width / original_width, height / original_height)
+        downscaled_width, downscaled_height = int(original_width * scale), int(original_height * scale)
+
+        # Calculate effective and wasted resolutions
+        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
+
+    # Determine which dimension (width or height) to fill
+    scale_w = target_width / original_width
+    scale_h = target_height / original_height
+
+    if scale_w < scale_h:
+        # Width will be filled completely
+        new_width = target_width
+        new_height = min(math.ceil(original_height * scale_w), target_height)
+    else:
+        # Height will be filled completely
+        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))
+
+    # Create a new image with the target size and paste the resized image onto it
+    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, grid_pinpoints, 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).
+        grid_pinpoints (str): A string representation of a list of possible resolutions.
+        patch_size (int): The size of each image patch.
+
+    Returns:
+        tuple: The shape of the image patch grid in the format (width, height).
+    """
+    if isinstance(grid_pinpoints, str) and "x" in grid_pinpoints:
+        assert patch_size in [224, 336, 384, 448, 512], "patch_size should be in [224, 336, 384, 448, 512]"
+        # Use regex to extract the range from the input string
+        matches = re.findall(r"\((\d+)x(\d+)\)", grid_pinpoints)
+        range_start = tuple(map(int, matches[0]))
+        range_end = tuple(map(int, matches[-1]))
+        # Generate a matrix of tuples from (range_start[0], range_start[1]) to (range_end[0], range_end[1])
+        grid_pinpoints = [(i, j) for i in range(range_start[0], range_end[0] + 1) for j in range(range_start[1], range_end[1] + 1)]
+        # Multiply all elements by patch_size
+        grid_pinpoints = [[dim * patch_size for dim in pair] for pair in grid_pinpoints]
+    if type(grid_pinpoints) is list:
+        possible_resolutions = grid_pinpoints
+    else:
+        possible_resolutions = ast.literal_eval(grid_pinpoints)
+    width, height = select_best_resolution(image_size, possible_resolutions)
+    return width // patch_size, height // patch_size
+
+
+def process_anyres_image(image, processor, grid_pinpoints):
+    """
+    Process an image with variable resolutions.
+
+    Args:
+        image (PIL.Image.Image): The input image to be processed.
+        processor: The image processor object.
+        grid_pinpoints (str): A string representation of a list of possible resolutions.
+
+    Returns:
+        torch.Tensor: A tensor containing the processed image patches.
+    """
+    # Convert grid_pinpoints from string to list
+    if isinstance(grid_pinpoints, str) and "x" in grid_pinpoints:
+        try:
+            patch_size = processor.size[0]
+        except Exception as e:
+            patch_size = processor.size["shortest_edge"]
+        assert patch_size in [224, 336, 384, 448, 512], "patch_size should be in [224, 336, 384, 448, 512]"
+        # Use regex to extract the range from the input string
+        matches = re.findall(r"\((\d+)x(\d+)\)", grid_pinpoints)
+        range_start = tuple(map(int, matches[0]))
+        range_end = tuple(map(int, matches[-1]))
+        # Generate a matrix of tuples from (range_start[0], range_start[1]) to (range_end[0], range_end[1])
+        grid_pinpoints = [(i, j) for i in range(range_start[0], range_end[0] + 1) for j in range(range_start[1], range_end[1] + 1)]
+        # Multiply all elements by patch_size
+        grid_pinpoints = [[dim * patch_size for dim in pair] for pair in grid_pinpoints]
+
+    if type(grid_pinpoints) is list:
+        possible_resolutions = grid_pinpoints
+    else:
+        possible_resolutions = ast.literal_eval(grid_pinpoints)
+    best_resolution = select_best_resolution(image.size, possible_resolutions)
+    image_padded = resize_and_pad_image(image, best_resolution)
+
+    patches = divide_to_patches(image_padded, processor.crop_size["height"])
+
+    # FIXME: this seems to be a bug that it resizes instead of pad.
+    # but to keep it consistent with previous, i will keep it as it is
+    # TODO: uncomment below to ablate with the padding
+    if isinstance(processor.size, dict):
+        shortest_edge = processor.size["shortest_edge"]
+    else:
+        shortest_edge = min(processor.size)
+    image_original_resize = image.resize((shortest_edge, shortest_edge))
+    # image_padded_square = expand2square(image, tuple(int(x*255) for x in processor.image_mean))
+    # image_original_resize = image_padded_square.resize((processor.size['shortest_edge'], processor.size['shortest_edge']))
+
+    image_patches = [image_original_resize] + patches
+    image_patches = [processor.preprocess(image_patch, return_tensors="pt")["pixel_values"][0] for image_patch in image_patches]
+    return torch.stack(image_patches, dim=0)
+
+
+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 = []
+    if image_aspect_ratio == "highres":
+        for image in images:
+            image = process_highres_image(image, image_processor, model_cfg.image_grid_pinpoints)
+            new_images.append(image)
+    elif image_aspect_ratio == "anyres" or "anyres_max" in image_aspect_ratio:
+        for image in images:
+            image = process_anyres_image(image, image_processor, model_cfg.image_grid_pinpoints)
+            new_images.append(image)
+    elif image_aspect_ratio == "crop_split":
+        for image in images:
+            image = process_highres_image_crop_split(image, model_cfg, image_processor)
+            new_images.append(image)
+    elif 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.preprocess(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 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 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 = []
+        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:]
+            self.keyword_ids.append(torch.tensor(cur_keyword_ids))
+        self.tokenizer = tokenizer
+        self.start_len = input_ids.shape[1]
+
+    def __call__(self, output_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
+        assert output_ids.shape[0] == 1, "Only support batch size 1 (yet)"  # TODO
+        offset = min(output_ids.shape[1] - self.start_len, 3)
+        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:
+                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

spatial-model/VLM-3R/llava/model/multimodal_spatial_encoder/builder.py

@@ -0,0 +1,39 @@
+import os
+import sys
+
+# Get the directory containing the current script
+script_dir = os.path.dirname(os.path.abspath(__file__))
+# Go up four levels to reach VLM-3R/
+vlm_3r_root = os.path.abspath(os.path.join(script_dir, '..', '..', '..'))
+
+def build_spatial_tower(spatial_tower_cfg, **kwargs):
+    spatial_tower = getattr(spatial_tower_cfg, "mm_spatial_tower", getattr(spatial_tower_cfg, "spatial_tower", 'spann3r'))
+    if spatial_tower == "spann3r":
+        spann3r_path = os.path.join(vlm_3r_root, 'spann3r')
+        if spann3r_path not in sys.path:
+             sys.path.append(spann3r_path)
+        # Use relative import for the encoder wrapper/adapter file
+        from .spann3r_spatial_encoder import Spann3rSpatialTower
+        return Spann3rSpatialTower(spatial_tower, spatial_tower_cfg=spatial_tower_cfg, **kwargs)
+    elif spatial_tower == "cut3r":
+        cut3r_path = os.path.join(vlm_3r_root, 'CUT3R')
+        if cut3r_path not in sys.path:
+            sys.path.append(cut3r_path)
+        # Use relative import for the encoder wrapper/adapter file
+        from .cut3r_spatial_encoder import Cut3rSpatialTower
+        return Cut3rSpatialTower(spatial_tower, spatial_tower_cfg=spatial_tower_cfg, **kwargs)
+    elif spatial_tower == "vggt":
+        vggt_path = os.path.join(vlm_3r_root, 'vggt')
+        if vggt_path not in sys.path:
+            sys.path.append(vggt_path)
+        # Use relative import for the encoder wrapper/adapter file
+        from .vggt_spatial_encoder import VGGTSpatialTower
+        return VGGTSpatialTower(spatial_tower, spatial_tower_cfg=spatial_tower_cfg, **kwargs)
+    elif spatial_tower == "cut3r_points":
+        cut3r_path = os.path.join(vlm_3r_root, 'CUT3R') # Assumes cut3r_points is also in CUT3R
+        if cut3r_path not in sys.path:
+            sys.path.append(cut3r_path)
+        # Use relative import for the encoder wrapper/adapter file
+        from .cut3r_points import Cut3rPointsSpatialTower
+        return Cut3rPointsSpatialTower(spatial_tower, spatial_tower_cfg=spatial_tower_cfg, **kwargs)
+    raise ValueError(f"Unknown vision tower: {spatial_tower}")

spatial-model/VLM-3R/llava/model/multimodal_spatial_encoder/cut3r_points.py

@@ -0,0 +1,342 @@
+import torch
+import torch.nn as nn
+from transformers import PretrainedConfig, PreTrainedModel
+from transformers.modeling_outputs import BaseModelOutputWithPooling, BaseModelOutput
+from typing import Union, Optional, Tuple
+import os
+from llava.utils import rank0_print
+from einops import rearrange
+from src.dust3r.model import ARCroco3DStereo
+import numpy as np
+
+class Cut3rPointsConfig(PretrainedConfig):
+    model_type = "cut3r_points_model"
+
+    def __init__(
+        self,
+        weights_path="../CUT3R/src/cut3r_512_dpt_4_64.pth",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.weights_path = weights_path
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
+        cls._set_token_in_kwargs(kwargs)
+
+        config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
+
+        # get the spatial config dict if we are loading from Cut3rSpatialConfig
+        if config_dict.get("model_type") == "cut3r_points":
+            config_dict = config_dict["spatial_config"]
+
+        if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
+            print(f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " f"{cls.model_type}. This is not supported for all configurations of models and can yield errors.")
+
+        return cls.from_dict(config_dict, **kwargs)
+
+class Cut3rPointsPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = Cut3rPointsConfig
+    base_model_prefix = "cut3r"
+    supports_gradient_checkpointing = True
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        pass
+
+def prepare_input(pixel_values):
+    pixel_values = nn.functional.interpolate(pixel_values, size=(432, 432), mode='bilinear')
+    pixel_values = pixel_values.unsqueeze(1) ## FIXME: the second dimension is the number of frames in one batch
+    views = []
+    for i in range(len(pixel_values)):
+        view = {
+            "img": pixel_values[i],
+            "ray_map": torch.full(
+                (
+                    pixel_values[i].shape[0],
+                    6,
+                    pixel_values[i].shape[-2],
+                    pixel_values[i].shape[-1],
+                ),
+                torch.nan,
+            ).to(pixel_values[i].device),
+            "true_shape": torch.tensor(pixel_values[i].shape[-2:]).to(pixel_values[i].device),
+            "idx": i,
+            "instance": str(i),
+            "camera_pose": torch.eye(4).unsqueeze(0).to(pixel_values[i].device),
+            "img_mask": torch.tensor(True).unsqueeze(0).to(pixel_values[i].device),
+            "ray_mask": torch.tensor(False).unsqueeze(0).to(pixel_values[i].device),
+            "update": torch.tensor(True).unsqueeze(0).to(pixel_values[i].device),
+            "reset": torch.tensor(False).unsqueeze(0).to(pixel_values[i].device),
+        }
+        views.append(view)
+    return views
+
+class Cut3rPointsEncoder(nn.Module):
+    def __init__(self, config: Cut3rPointsConfig, **kwargs):
+        super().__init__()
+        self.cut3r = ARCroco3DStereo.from_pretrained(config.weights_path)
+        self.cut3r.eval()
+        self.config = config
+        for param in self.cut3r.parameters():
+            param.requires_grad = False
+
+    def forward(
+        self,
+        pixel_values,
+        attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutput]:
+        
+        views = prepare_input(pixel_values=pixel_values)
+        shape, feat_ls, pos = self.cut3r._encode_views(views)
+        feat = feat_ls[-1]
+        state_feat, state_pos = self.cut3r._init_state(feat[0], pos[0])
+        mem = self.cut3r.pose_retriever.mem.expand(feat[0].shape[0], -1, -1)
+        init_state_feat = state_feat.clone()
+        init_mem = mem.clone()
+        all_state_args = [(state_feat, state_pos, init_state_feat, mem, init_mem)]
+        ress = []
+        out_points = []
+        for i in range(len(views)):
+            feat_i = feat[i].to(pixel_values.dtype)
+            pos_i = pos[i]
+            if self.cut3r.pose_head_flag:
+                global_img_feat_i = self.cut3r._get_img_level_feat(feat_i)
+                if i == 0:
+                    pose_feat_i = self.cut3r.pose_token.expand(feat_i.shape[0], -1, -1)
+                else:
+                    pose_feat_i = self.cut3r.pose_retriever.inquire(global_img_feat_i, mem)
+                pose_pos_i = -torch.ones(
+                    feat_i.shape[0], 1, 2, device=feat_i.device, dtype=pos_i.dtype
+                )
+            else:
+                pose_feat_i = None
+                pose_pos_i = None
+            new_state_feat, dec = self.cut3r._recurrent_rollout(
+                state_feat,
+                state_pos,
+                feat_i,
+                pos_i,
+                pose_feat_i,
+                pose_pos_i,
+                init_state_feat,
+                img_mask=views[i]["img_mask"],
+                reset_mask=views[i]["reset"],
+                update=views[i].get("update", None),
+            )
+            out_pose_feat_i = dec[-1][:, 0:1]
+            new_mem = self.cut3r.pose_retriever.update_mem(
+                mem, global_img_feat_i, out_pose_feat_i
+            )
+            assert len(dec) == self.cut3r.dec_depth + 1
+            head_input = [
+                dec[0],
+                dec[self.cut3r.dec_depth * 2 // 4][:, 1:],
+                dec[self.cut3r.dec_depth * 3 // 4][:, 1:],
+                dec[self.cut3r.dec_depth],
+            ]
+            res = self.cut3r._downstream_head(head_input, shape[i], pos=pos_i)
+            ress.append(res)
+
+            out_points.append(res["pts3d_in_other_view"])
+            img_mask = views[i]["img_mask"]
+            update = views[i].get("update", None)
+            if update is not None:
+                update_mask = (
+                    img_mask & update
+                )  # if don't update, then whatever img_mask
+            else:
+                update_mask = img_mask
+            update_mask = update_mask[:, None, None].to(pixel_values.dtype)
+            state_feat = new_state_feat * update_mask + state_feat * (
+                1 - update_mask
+            )  # update global state
+            mem = new_mem * update_mask + mem * (
+                1 - update_mask
+            )  # then update local state
+            reset_mask = views[i]["reset"]
+            if reset_mask is not None:
+                reset_mask = reset_mask[:, None, None].to(pixel_values.dtype)
+                state_feat = init_state_feat * reset_mask + state_feat * (
+                    1 - reset_mask
+                )
+                mem = init_mem * reset_mask + mem * (1 - reset_mask)
+            all_state_args.append(
+                (state_feat, state_pos, init_state_feat, mem, init_mem)
+            )
+        # # for debug
+        # pts3d = []
+        # colors = []
+        # for i in range(len(views)):
+        #     pts3d.append(ress[i]["pts3d_in_other_view"])
+        #     colors.append(ress[i]["rgb"])
+        # pts3d = torch.cat(pts3d, dim=0) # b h w 3
+        # colors = torch.cat(colors, dim=0) # b h w 3
+        # pts3d = pts3d.view(-1, 3).float().cpu().numpy()
+        # colors = colors * 0.5 + 0.5
+        # colors = colors.view(-1, 3).float().cpu().numpy()
+        # #保存为点云
+        # import open3d as o3d
+        # pcd = o3d.geometry.PointCloud()
+        # pcd.points = o3d.utility.Vector3dVector(pts3d)
+        # pcd.colors = o3d.utility.Vector3dVector(colors)
+        # o3d.io.write_point_cloud("pts3d.ply", pcd)
+
+        out_points = torch.stack(out_points, dim=0) # [frame, b, H, W, 3]
+        out_points = rearrange(out_points, 'frame b H W c -> (b frame) H W c')
+        return out_points
+
+class Cut3rPointsTransformer(nn.Module):
+    def __init__(self, config: Cut3rPointsConfig, **kwargs):
+        super().__init__()
+        self.config = config
+        self.encoder = Cut3rPointsEncoder(config=config, **kwargs)
+
+    def forward(
+        self,
+        pixel_values,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutputWithPooling]:
+        r"""
+        Returns:
+
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        encoder_outputs = self.encoder(
+            pixel_values=pixel_values,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        return encoder_outputs
+
+class Cut3rPointsSpatialModel(Cut3rPointsPreTrainedModel):
+    config_class = Cut3rPointsConfig
+    main_input_name = "pixel_values"
+    _no_split_modules = ["Cut3rPointsEncoderLayer"]
+
+    def __init__(self, config: Cut3rPointsConfig, **kwargs):
+        super().__init__(config)
+
+        self.spatial_model = Cut3rPointsTransformer(config, **kwargs)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], config: Cut3rPointsConfig, **kwargs):
+        model = cls(config=config, **kwargs)
+        return model
+
+    def forward(
+        self,
+        pixel_values,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutputWithPooling]:
+
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        return self.spatial_model(
+            pixel_values=pixel_values,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+class Cut3rPointsSpatialTower(nn.Module):
+    def __init__(self, spatial_tower, spatial_tower_cfg, delay_load=True):
+        super().__init__()
+
+        self.is_loaded = False
+
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        vlm_3r_root = os.path.abspath(os.path.join(script_dir, '..', '..', '..'))
+        dynamic_weights_path = os.path.join(vlm_3r_root, 'CUT3R', 'src', 'cut3r_512_dpt_4_64.pth')
+
+        self.config = Cut3rPointsConfig(weights_path=dynamic_weights_path)
+
+        self.spatial_tower_name = spatial_tower
+
+        if not delay_load:
+            rank0_print(f"Loading spatial tower: {spatial_tower}")
+            self.load_model()
+        elif getattr(spatial_tower_cfg, "unfreeze_mm_spatial_tower", False):
+            # TODO: better detector is needed.
+            rank0_print(f"The checkpoint seems to contain `spatial_tower` weights: `unfreeze_mm_spatial_tower`: True.")
+            self.load_model()
+        elif hasattr(spatial_tower_cfg, "mm_tunable_parts") and "mm_spatial_tower" in spatial_tower_cfg.mm_tunable_parts:
+            rank0_print(f"The checkpoint seems to contain `spatial_tower` weights: `mm_tunable_parts` contains `mm_spatial_tower`.")
+            self.load_model()
+        else:
+            self.cfg_only = self.config
+
+    def load_model(self, device_map=None):
+        if self.is_loaded:
+            rank0_print("{} is already loaded, `load_model` called again, skipping.".format(self.spatial_tower_name))
+            return
+
+        self.spatial_tower = Cut3rPointsSpatialModel.from_pretrained(self.spatial_tower_name, config=self.config, device_map=device_map)
+
+        self.spatial_tower.requires_grad_(False)
+
+        self.is_loaded = True
+
+    def forward(self, images):
+        if type(images) is list:
+            image_features = []
+            for image in images:
+                image_forward_out = self.spatial_tower(image.to(device=self.device, dtype=self.dtype).unsqueeze(0), output_hidden_states=True)
+                image_feature = image_forward_out.last_hidden_state.to(image.dtype)
+                # assert image_features.shape[-2] == 729
+                image_features.append(image_feature)
+        else:
+            image_forward_outs = self.spatial_tower(images.to(device=self.device, dtype=self.dtype), output_hidden_states=True)
+            image_features = image_forward_outs.to(images.dtype)
+            # assert image_features.shape[-2] == 729
+
+        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):
+        for p in self.spatial_tower.parameters():
+            return p.dtype
+
+    @property
+    def device(self):
+        for p in self.spatial_tower.parameters():
+            return p.device
+
+    @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
+
+    @property
+    def image_size(self):
+        return self.config.image_size

spatial-model/VLM-3R/llava/model/multimodal_spatial_encoder/cut3r_spatial_encoder.py

@@ -0,0 +1,555 @@
+import torch
+import torch.nn as nn
+from transformers import PretrainedConfig, PreTrainedModel
+from transformers.modeling_outputs import BaseModelOutputWithPooling, BaseModelOutput
+from typing import Union, Optional, Tuple
+import os
+from llava.utils import rank0_print
+from einops import rearrange
+import sys
+sys.path.append('CUT3R')
+from src.dust3r.model import ARCroco3DStereo
+import numpy as np
+
+try:
+    import open3d as o3d
+    _OPEN3D_AVAILABLE = True
+except ImportError:
+    rank0_print("Warning: open3d not found. Point cloud export functionality will be disabled.")
+    _OPEN3D_AVAILABLE = False
+
+class Cut3rSpatialConfig(PretrainedConfig):
+    model_type = "cut3r_spatial_model"
+
+    def __init__(
+        self,
+        weights_path="../CUT3R/src/cut3r_512_dpt_4_64.pth",
+        spatial_tower_select_feature="patch",
+        spatial_tower_select_layer=-1,
+        export_point_cloud: bool = False,
+        point_cloud_output_dir: str = "point_clouds",
+        point_cloud_voxel_size: float = 0.02,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.weights_path = weights_path
+        self.spatial_tower_select_feature = spatial_tower_select_feature
+        self.spatial_tower_select_layer = spatial_tower_select_layer
+        self.export_point_cloud = export_point_cloud
+        self.point_cloud_output_dir = point_cloud_output_dir
+        self.point_cloud_voxel_size = point_cloud_voxel_size
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
+        cls._set_token_in_kwargs(kwargs)
+
+        config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
+
+        # get the spatial config dict if we are loading from Cut3rSpatialConfig
+        if config_dict.get("model_type") == "cut3r":
+            config_dict = config_dict["spatial_config"]
+
+        if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
+            print(f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " f"{cls.model_type}. This is not supported for all configurations of models and can yield errors.")
+
+        return cls.from_dict(config_dict, **kwargs)
+
+class Cut3rSpatialPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = Cut3rSpatialConfig
+    base_model_prefix = "cut3r"
+    supports_gradient_checkpointing = True
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        pass
+
+def prepare_input(pixel_values):
+    pixel_values = nn.functional.interpolate(pixel_values, size=(432, 432), mode='bilinear')
+    pixel_values = pixel_values.unsqueeze(1) ## FIXME: the second dimension is the number of frames in one batch
+    views = []
+    # Assuming pixel_values is (F_max, B, C, H, W)
+    if not isinstance(pixel_values, torch.Tensor) or pixel_values.ndim != 5:
+        raise ValueError(f"Expected pixel_values to be a 5D tensor (F, B, C, H, W), got {type(pixel_values)} with shape {getattr(pixel_values, 'shape', 'N/A')}")
+
+    F_max, B, C, H, W = pixel_values.shape
+    device = pixel_values.device
+
+    for i in range(F_max):
+        current_frame_batch = pixel_values[i] # Shape (B, C, H, W)
+        view = {
+            "img": current_frame_batch,
+            "ray_map": torch.full(
+                (
+                    B, # Use batch size B
+                    6,
+                    H, # Use H
+                    W, # Use W
+                ),
+                torch.nan,
+            ).to(device),
+            "true_shape": torch.tensor([H, W], device=device).expand(B, -1), # Shape (B, 2)
+            "idx": i,
+            "instance": [str(j) for j in range(B)], # List of B instances
+            "camera_pose": torch.eye(4, device=device).unsqueeze(0).expand(B, -1, -1), # Shape (B, 4, 4)
+            "img_mask": torch.tensor(True, device=device).expand(B), # Shape (B)
+            "ray_mask": torch.tensor(False, device=device).expand(B), # Shape (B)
+            "update": torch.tensor(True, device=device).expand(B), # Shape (B)
+            "reset": torch.tensor(False, device=device).expand(B), # Shape (B)
+        }
+        views.append(view)
+    return views
+
+class Cut3rEncoder(nn.Module):
+    def __init__(self, config: Cut3rSpatialConfig, **kwargs):
+        super().__init__()
+        self.cut3r = ARCroco3DStereo.from_pretrained(config.weights_path)
+        self.cut3r.eval()
+        self.config = config
+        for param in self.cut3r.parameters():
+            param.requires_grad = False
+
+    def export_point_cloud(self, views, ress, point_cloud_output_paths: Optional[list[str]]):
+        if not _OPEN3D_AVAILABLE:
+            rank0_print("Skipping point cloud export because open3d is not available.")
+            return
+        if not ress:
+            rank0_print("Warning: 'ress' list is empty, skipping point cloud export.")
+            return
+        if not point_cloud_output_paths:
+            rank0_print("Warning: point_cloud_output_paths is not provided. Skipping point cloud export.")
+            return
+
+        try:
+            # Determine batch size (B) from the first frame's output if available
+            if 'pts3d_in_other_view' not in ress[0] or ress[0]['pts3d_in_other_view'] is None:
+                 rank0_print("Warning: Cannot determine batch size from ress[0]. Skipping point cloud export.")
+                 return
+            B = ress[0]['pts3d_in_other_view'].shape[0]
+            num_frames = len(views)
+
+            if len(point_cloud_output_paths) != B:
+                 rank0_print(f"Warning: Number of output paths ({len(point_cloud_output_paths)}) does not match batch size ({B}). Skipping point cloud export.")
+                 return
+
+            # Ensure base output directory exists (individual file paths might contain subdirs)
+            base_output_dir = os.path.dirname(point_cloud_output_paths[0])
+            if base_output_dir:
+                os.makedirs(base_output_dir, exist_ok=True)
+
+            for b_idx in range(B):
+                pts3d_batch_item = []
+                colors_batch_item = []
+                valid_frames_for_batch_item = 0
+
+                try:
+                    # Ensure the specific directory for this batch item exists
+                    item_output_dir = os.path.dirname(point_cloud_output_paths[b_idx])
+                    if item_output_dir:
+                        os.makedirs(item_output_dir, exist_ok=True)
+
+                    # --- Combine data across frames for the current batch item --- 
+                    for i in range(num_frames):
+                        # Check if the tensors exist and have the expected batch dimension for this frame
+                        if (i < len(ress) and 
+                            'pts3d_in_other_view' in ress[i] and 
+                            'rgb' in ress[i] and 
+                            ress[i]['pts3d_in_other_view'] is not None and 
+                            ress[i]['rgb'] is not None and 
+                            ress[i]['pts3d_in_other_view'].shape[0] == B and 
+                            ress[i]['rgb'].shape[0] == B):
+                            
+                            # Extract data for the current batch item b_idx from frame i
+                            pts3d_batch_item.append(ress[i]["pts3d_in_other_view"][b_idx]) # Shape (H, W, 3)
+                            colors_batch_item.append(ress[i]["rgb"][b_idx]) # Shape (H, W, 3)
+                            valid_frames_for_batch_item += 1
+                        else:
+                            rank0_print(f"Warning: Missing, None, or mismatched data in ress[{i}] for batch index {b_idx}. Skipping frame {i} for this item.")
+                    # --- End combining data --- 
+
+                    if not pts3d_batch_item: # Skip if no valid frames found for this batch item
+                        rank0_print(f"Warning: No valid frame data found for batch item {b_idx}. Skipping point cloud generation.")
+                        continue # Skip to the next batch item
+
+                    # Stack tensors from valid frames and reshape
+                    # Stacking gives (F_valid, H, W, 3) -> view gives (F_valid*H*W, 3)
+                    pts3d_single = torch.stack(pts3d_batch_item, dim=0).reshape(-1, 3).float().cpu().numpy()
+                    colors_single_stacked = torch.stack(colors_batch_item, dim=0).reshape(-1, 3)
+                    colors_single = (colors_single_stacked * 0.5 + 0.5).float().cpu().numpy() # Apply color transform
+
+                    # Create Open3D point cloud for the item
+                    pcd_item = o3d.geometry.PointCloud()
+                    pcd_item.points = o3d.utility.Vector3dVector(pts3d_single)
+                    pcd_item.colors = o3d.utility.Vector3dVector(colors_single)
+
+                    # Voxel downsampling for the item
+                    voxel_size = self.config.point_cloud_voxel_size
+                    # rank0_print(f"Original combined point cloud (batch item {b_idx}) has {len(pcd_item.points)} points.")
+                    downsampled_pcd_item = pcd_item.voxel_down_sample(voxel_size)
+                    # rank0_print(f"Downsampled combined point cloud (batch item {b_idx}) has {len(downsampled_pcd_item.points)} points.")
+
+                    # Save the downsampled point cloud for the item
+                    output_path = point_cloud_output_paths[b_idx]
+                    o3d.io.write_point_cloud(output_path, downsampled_pcd_item)
+                    rank0_print(f"Saved combined and downsampled point cloud for batch item {b_idx} to {output_path}")
+
+                except (KeyError, IndexError, AttributeError, ValueError, RuntimeError, Exception) as item_e:
+                    rank0_print(f"Error processing or saving point cloud for batch item {b_idx}: {item_e}")
+                    import traceback
+                    rank0_print(traceback.format_exc())
+                    # Continue to the next batch item
+
+        except (KeyError, IndexError, AttributeError, ValueError, RuntimeError, Exception) as e:
+            rank0_print(f"Error during point cloud export setup (batch level): {e}")
+            import traceback
+            rank0_print(traceback.format_exc())
+
+    def forward(
+        self,
+        pixel_values,
+        attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        point_cloud_output_paths: Optional[list[str]] = None
+    ) -> Union[Tuple, BaseModelOutput]:
+        
+        views = prepare_input(pixel_values=pixel_values)
+        shape, feat_ls, pos = self.cut3r._encode_views(views)
+        feat = feat_ls[-1]
+        state_feat, state_pos = self.cut3r._init_state(feat[0], pos[0])
+        mem = self.cut3r.pose_retriever.mem.expand(feat[0].shape[0], -1, -1)
+        init_state_feat = state_feat.clone()
+        init_mem = mem.clone()
+        all_state_args = [(state_feat, state_pos, init_state_feat, mem, init_mem)]
+        ress = []
+        # spatial_feat = []
+        patch_features = []
+        camera_tokens = []
+        for i in range(len(views)):
+            feat_i = feat[i].to(pixel_values.dtype)
+            pos_i = pos[i]
+            if self.cut3r.pose_head_flag:
+                global_img_feat_i = self.cut3r._get_img_level_feat(feat_i)
+                if i == 0:
+                    pose_feat_i = self.cut3r.pose_token.expand(feat_i.shape[0], -1, -1)
+                else:
+                    pose_feat_i = self.cut3r.pose_retriever.inquire(global_img_feat_i, mem)
+                pose_pos_i = -torch.ones(
+                    feat_i.shape[0], 1, 2, device=feat_i.device, dtype=pos_i.dtype
+                )
+            else:
+                pose_feat_i = None
+                pose_pos_i = None
+            new_state_feat, dec = self.cut3r._recurrent_rollout(
+                state_feat,
+                state_pos,
+                feat_i,
+                pos_i,
+                pose_feat_i,
+                pose_pos_i,
+                init_state_feat,
+                img_mask=views[i]["img_mask"],
+                reset_mask=views[i]["reset"],
+                update=views[i].get("update", None),
+            )
+            out_pose_feat_i = dec[-1][:, 0:1]
+            new_mem = self.cut3r.pose_retriever.update_mem(
+                mem, global_img_feat_i, out_pose_feat_i
+            )
+            assert len(dec) == self.cut3r.dec_depth + 1
+            head_input = [
+                dec[0],
+                dec[self.cut3r.dec_depth * 2 // 4][:, 1:],
+                dec[self.cut3r.dec_depth * 3 // 4][:, 1:],
+                dec[self.cut3r.dec_depth],
+            ]
+            res = self.cut3r._downstream_head(head_input, shape[i], pos=pos_i)
+            ress.append(res)
+            # # select feature
+            # if self.config.spatial_tower_select_feature == "patch":
+            #     spatial_feat_layer = dec[int(self.config.spatial_tower_select_layer)][:, 1:]
+            # elif self.config.spatial_tower_select_feature == "all":
+            #     spatial_feat_layer = dec[int(self.config.spatial_tower_select_layer)]
+            # else:
+            #     raise ValueError(f"Unexpected spatial tower select feature: {self.config.spatial_tower_select_feature}")
+            # spatial_feat.append(spatial_feat_layer)
+            img_mask = views[i]["img_mask"]
+            update = views[i].get("update", None)
+            if update is not None:
+                update_mask = (
+                    img_mask & update
+                )  # if don't update, then whatever img_mask
+            else:
+                update_mask = img_mask
+            update_mask = update_mask[:, None, None].to(pixel_values.dtype)
+            state_feat = new_state_feat * update_mask + state_feat * (
+                1 - update_mask
+            )  # update global state
+            mem = new_mem * update_mask + mem * (
+                1 - update_mask
+            )  # then update local state
+            reset_mask = views[i]["reset"]
+            if reset_mask is not None:
+                reset_mask = reset_mask[:, None, None].to(pixel_values.dtype)
+                state_feat = init_state_feat * reset_mask + state_feat * (
+                    1 - reset_mask
+                )
+                mem = init_mem * reset_mask + mem * (1 - reset_mask)
+            all_state_args.append(
+                (state_feat, state_pos, init_state_feat, mem, init_mem)
+            )
+
+            # add camera token
+            camera_tokens.append(dec[-1][:, :1].clone())
+            # add patch features
+            patch_features.append(dec[-1][:, 1:].clone())
+
+        # # for debug - Modified for batch processing
+        # if not ress: # Handle empty ress case
+        #     print("Warning: ress list is empty, skipping point cloud debug output.")
+        #     B_debug = 0
+        # else:
+        #     # Determine batch size (B) from the first element/frame's output
+        #     # Assuming ress[0]['pts3d_in_other_view'] has shape (B, H, W, 3)
+        #     B_debug = ress[0]['pts3d_in_other_view'].shape[0]
+
+        # for b_idx in range(B_debug):
+        #     pts3d_batch_item = []
+        #     colors_batch_item = []
+        #     valid_frames_for_batch_item = 0
+        #     for i in range(len(views)): # Iterate through frames (F_max)
+        #         # Check if the tensors exist and have the expected batch dimension
+        #         if (i < len(ress) and 'pts3d_in_other_view' in ress[i] and 'rgb' in ress[i] and
+        #             ress[i]['pts3d_in_other_view'].shape[0] == B_debug and ress[i]['rgb'].shape[0] == B_debug):
+        #             # Extract data for the current batch item b_idx
+        #             pts3d_batch_item.append(ress[i]["pts3d_in_other_view"][b_idx]) # Shape (H, W, 3)
+        #             colors_batch_item.append(ress[i]["rgb"][b_idx]) # Shape (H, W, 3)
+        #             valid_frames_for_batch_item += 1
+        #         else:
+        #             print(f"Warning: Missing or mismatched data in ress[{i}] for batch index {b_idx}. Skipping frame {i} for this batch item.")
+
+        #     if not pts3d_batch_item: # Skip if no valid frames found for this batch item
+        #         print(f"Warning: No valid frame data found for batch item {b_idx}. Skipping point cloud generation.")
+        #         continue
+
+        #     # Concatenate across valid frames for this batch item
+        #     # Need to stack along a new dimension (e.g., frame dim) then reshape, or cat along H/W dim if appropriate?
+        #     # Original DUST3R might have concatenated along H or W. Let's assume stacking then view is safer.
+        #     # Stacking gives (F_valid, H, W, 3) -> view gives (F_valid*H*W, 3)
+        #     pts3d_single = torch.stack(pts3d_batch_item, dim=0).view(-1, 3).float().cpu().numpy()
+        #     colors_single = torch.stack(colors_batch_item, dim=0).view(-1, 3)
+        #     colors_single = (colors_single * 0.5 + 0.5).float().cpu().numpy() # Apply color transform
+
+        #     # 保存为点云
+        #     try:
+        #         import open3d as o3d
+        #         pcd = o3d.geometry.PointCloud()
+        #         pcd.points = o3d.utility.Vector3dVector(pts3d_single)
+        #         pcd.colors = o3d.utility.Vector3dVector(colors_single)
+
+        #         # voxelize
+        #         voxel_size = 0.05 # Example: 5cm voxel size
+        #         # print(f"Original point cloud (batch item {b_idx}) has {len(pcd.points)} points.")
+
+        #         # Apply voxel downsampling
+        #         downsampled_pcd = pcd.voxel_down_sample(voxel_size)
+        #         # print(f"Downsampled point cloud (batch item {b_idx}) has {len(downsampled_pcd.points)} points.")
+
+        #         # Save the downsampled point cloud
+        #         output_filename = f"downsampled_point_cloud_batch_{b_idx}.ply"
+        #         o3d.io.write_point_cloud(output_filename, downsampled_pcd)
+        #         # print(f"Saved point cloud for batch item {b_idx} to {output_filename}")
+        #     except ImportError:
+        #         print("Warning: open3d not found. Cannot save debug point cloud.")
+        #     except Exception as e_pcd:
+        #          print(f"Error processing or saving point cloud for batch item {b_idx}: {e_pcd}")
+
+        # spatial_feat = torch.stack(spatial_feat, dim=0) # [frame, b, token_num, token_dim]
+        # spatial_feat = rearrange(spatial_feat, 'frame b token_num token_dim -> (b frame) token_num token_dim')
+        # return (spatial_feat, None, None, None)
+
+        # Export point cloud if enabled
+        if self.config.export_point_cloud:
+            # Pass the specific output paths for this batch
+            self.export_point_cloud(views, ress, point_cloud_output_paths)
+
+        # rearrange patch_features, camera_tokens, hidden_states
+        patch_features = torch.stack(patch_features, dim=0)
+        patch_features = rearrange(patch_features, 'frame batch token_num token_dim -> (batch frame) token_num token_dim')
+        camera_tokens = torch.stack(camera_tokens, dim=0)
+        camera_tokens = rearrange(camera_tokens, 'frame batch token_num token_dim-> (batch frame) token_num token_dim')
+
+        return (camera_tokens, patch_features)
+
+class Cut3rSpatialTransformer(nn.Module):
+    def __init__(self, config: Cut3rSpatialConfig, **kwargs):
+        super().__init__()
+        self.config = config
+        self.encoder = Cut3rEncoder(config=config, **kwargs)
+
+    def forward(
+        self,
+        pixel_values,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        point_cloud_output_paths: Optional[list[str]] = None
+    ) -> Union[Tuple, BaseModelOutputWithPooling]:
+        r"""
+        Returns:
+
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        encoder_outputs = self.encoder(
+            pixel_values=pixel_values,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            point_cloud_output_paths=point_cloud_output_paths
+        )
+
+        return encoder_outputs
+
+        # last_hidden_state = encoder_outputs[0]
+
+        # if not return_dict:
+        #     return (last_hidden_state, None) + encoder_outputs[1:]
+
+        # return BaseModelOutputWithPooling(
+        #     last_hidden_state=last_hidden_state,
+        #     pooler_output=None,
+        #     hidden_states=None,
+        #     attentions=None,
+        # )
+
+class Cut3rSpatialModel(Cut3rSpatialPreTrainedModel):
+    config_class = Cut3rSpatialConfig
+    main_input_name = "pixel_values"
+    _no_split_modules = ["Cut3rSpatialEncoderLayer"]
+
+    def __init__(self, config: Cut3rSpatialConfig, **kwargs):
+        super().__init__(config)
+
+        self.spatial_model = Cut3rSpatialTransformer(config, **kwargs)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], config: Cut3rSpatialConfig, **kwargs):
+        model = cls(config=config, **kwargs)
+        return model
+
+    def forward(
+        self,
+        pixel_values,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        point_cloud_output_paths: Optional[list[str]] = None
+    ) -> Union[Tuple, BaseModelOutputWithPooling]:
+
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        return self.spatial_model(
+            pixel_values=pixel_values,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            point_cloud_output_paths=point_cloud_output_paths
+        )
+
+class Cut3rSpatialTower(nn.Module):
+    def __init__(self, spatial_tower, spatial_tower_cfg, delay_load=True):
+        super().__init__()
+
+        self.is_loaded = False
+
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        vlm_3r_root = os.path.abspath(os.path.join(script_dir, '..', '..', '..'))
+        dynamic_weights_path = os.path.join(vlm_3r_root, 'CUT3R', 'src', 'cut3r_512_dpt_4_64.pth')
+
+        self.config = Cut3rSpatialConfig(
+            weights_path=dynamic_weights_path,
+            spatial_tower_select_feature=getattr(spatial_tower_cfg, 'spatial_tower_select_feature', 'patch'),
+            spatial_tower_select_layer=getattr(spatial_tower_cfg, 'spatial_tower_select_layer', -1)
+        )
+
+        self.spatial_tower_name = spatial_tower
+
+        if not delay_load:
+            rank0_print(f"Loading spatial tower: {spatial_tower}")
+            self.load_model()
+        elif getattr(spatial_tower_cfg, "unfreeze_mm_spatial_tower", False):
+            # TODO: better detector is needed.
+            rank0_print(f"The checkpoint seems to contain `spatial_tower` weights: `unfreeze_mm_spatial_tower`: True.")
+            self.load_model()
+        elif hasattr(spatial_tower_cfg, "mm_tunable_parts") and "mm_spatial_tower" in spatial_tower_cfg.mm_tunable_parts:
+            rank0_print(f"The checkpoint seems to contain `spatial_tower` weights: `mm_tunable_parts` contains `mm_spatial_tower`.")
+            self.load_model()
+        else:
+            self.cfg_only = self.config
+
+    def load_model(self, device_map=None):
+        if self.is_loaded:
+            rank0_print("{} is already loaded, `load_model` called again, skipping.".format(self.spatial_tower_name))
+            return
+
+        self.spatial_tower = Cut3rSpatialModel.from_pretrained(self.spatial_tower_name, config=self.config, device_map=device_map)
+
+        self.spatial_tower.requires_grad_(False)
+
+        self.is_loaded = True
+
+    def forward(self, images):
+        if type(images) is list:
+            image_features = []
+            for image in images:
+                image_forward_out = self.spatial_tower(image.to(device=self.device, dtype=self.dtype).unsqueeze(0), output_hidden_states=True)
+                image_feature = image_forward_out.last_hidden_state.to(image.dtype)
+                # assert image_features.shape[-2] == 729
+                image_features.append(image_feature)
+        else:
+            image_features = self.spatial_tower(images.to(device=self.device, dtype=self.dtype), output_hidden_states=True)
+            # image_features = image_features_forward_out.to(images.dtype)
+            # assert image_features.shape[-2] == 729
+
+        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):
+        for p in self.spatial_tower.parameters():
+            return p.dtype
+
+    @property
+    def device(self):
+        for p in self.spatial_tower.parameters():
+            return p.device
+
+    @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
+
+    @property
+    def image_size(self):
+        return self.config.image_size

spatial-model/VLM-3R/llava/serve/controller.py

@@ -0,0 +1,287 @@
+"""
+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 llava.constants import CONTROLLER_HEART_BEAT_EXPIRATION
+from llava.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,))
+        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")

spatial-model/VLM-3R/llava/serve/gradio_web_server.py

@@ -0,0 +1,442 @@
+import argparse
+import datetime
+import json
+import os
+import time
+
+import gradio as gr
+import requests
+
+from llava.conversation import default_conversation, conv_templates, SeparatorStyle
+from llava.constants import LOGDIR
+from llava.utils import build_logger, server_error_msg, violates_moderation, moderation_msg
+import hashlib
+
+
+logger = build_logger("gradio_web_server", "gradio_web_server.log")
+
+headers = {"User-Agent": "LLaVA 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
+    return (state, state.to_gradio_chatbot(), "", None) + (disable_btn,) * 5
+
+
+def clear_history(request: gr.Request):
+    logger.info(f"clear_history. ip: {request.client.host}")
+    state = default_conversation.copy()
+    return (state, state.to_gradio_chatbot(), "", None) + (disable_btn,) * 5
+
+
+def add_text(state, text, image, image_process_mode, request: gr.Request):
+    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
+
+    text = text[:1536]  # Hard cut-off
+    if image is not None:
+        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.append_message(state.roles[0], text)
+    state.append_message(state.roles[1], None)
+    state.skip_next = False
+    return (state, state.to_gradio_chatbot(), "", None) + (disable_btn,) * 5
+
+
+def http_bot(state, model_selector, temperature, top_p, max_new_tokens, request: gr.Request, template_name=None):
+    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 "mistral" in model_name.lower() or "mixtral" in model_name.lower():
+                if "orca" in model_name.lower():
+                    template_name = "mistral_orca"
+                elif "hermes" in model_name.lower():
+                    template_name = "mistral_direct"
+                else:
+                    template_name = "mistral_instruct"
+            elif "zephyr" in model_name.lower():
+                template_name = "mistral_zephyr"
+            elif "hermes" in model_name.lower():
+                template_name = "mistral_direct"
+            elif "v1" in model_name.lower():
+                if "mmtag" in model_name.lower():
+                    template_name = "llava_v1_mmtag"
+                elif "plain" in model_name.lower() and "finetune" not in model_name.lower():
+                    template_name = "llava_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_plain"
+                elif "plain" in model_name.lower() and "finetune" not in model_name.lower():
+                    template_name = "v0_plain"
+                else:
+                    template_name = "llava_v0"
+        elif "mistral" in model_name.lower() or "mixtral" in model_name.lower():
+            if "orca" in model_name.lower():
+                template_name = "mistral_orca"
+            elif "hermes" in model_name.lower():
+                template_name = "mistral_direct"
+            else:
+                template_name = "mistral_instruct"
+        elif "hermes" in model_name.lower():
+            template_name = "mistral_direct"
+        elif "zephyr" in model_name.lower():
+            template_name = "mistral_zephyr"
+        elif "mpt" in model_name:
+            template_name = "mpt_text"
+        elif "llama-2" in model_name:
+            template_name = "llama_2"
+        else:
+            template_name = "vicuna_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)
+        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()
+
+    all_images = state.get_images(return_pil=True)
+    all_image_hash = [hashlib.md5(image.tobytes()).hexdigest() for image in all_images]
+    for image, hash in zip(all_images, all_image_hash):
+        t = datetime.datetime.now()
+        filename = os.path.join(LOGDIR, "serve_images", f"{t.year}-{t.month:02d}-{t.day:02d}", f"{hash}.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}",
+    }
+    logger.info(f"==== request ====\n{pload}")
+
+    pload["images"] = state.get_images()
+
+    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=100)
+        last_print_time = time.time()
+        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 + "▌"
+                    if time.time() - last_print_time > 0.05:
+                        last_print_time = time.time()
+                        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 = """
+# 🌋 LLaVA: Large Language and Vision Assistant
+[[Project Page](https://llava-vl.github.io)] [[Code](https://github.com/haotian-liu/LLaVA)] [[Model](https://github.com/haotian-liu/LLaVA/blob/main/docs/MODEL_ZOO.md)] | 📚 [[LLaVA](https://arxiv.org/abs/2304.08485)] [[LLaVA-v1.5](https://arxiv.org/abs/2310.03744)]
+"""
+
+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="LLaVA", 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")
+                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?"],
+                    ],
+                    inputs=[imagebox, textbox],
+                )
+
+                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="LLaVA 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], queue=False)
+        downvote_btn.click(downvote_last_response, [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn], queue=False)
+        flag_btn.click(flag_last_response, [state, model_selector], [textbox, upvote_btn, downvote_btn, flag_btn], queue=False)
+
+        regenerate_btn.click(regenerate, [state, image_process_mode], [state, chatbot, textbox, imagebox] + btn_list, queue=False).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] + btn_list, queue=False)
+
+        textbox.submit(add_text, [state, textbox, imagebox, image_process_mode], [state, chatbot, textbox, imagebox] + btn_list, queue=False).then(
+            http_bot, [state, model_selector, temperature, top_p, max_output_tokens], [state, chatbot] + btn_list
+        )
+
+        submit_btn.click(add_text, [state, textbox, imagebox, image_process_mode], [state, chatbot, textbox, imagebox] + btn_list, queue=False).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, queue=False)
+        elif args.model_list_mode == "reload":
+            demo.load(load_demo_refresh_model_list, None, [state, model_selector], queue=False)
+        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)

spatial-model/VLM-3R/llava/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

spatial-model/VLM-3R/llava/serve/sglang_worker.py

@@ -0,0 +1,237 @@
+"""
+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.model.builder import load_pretrained_model
+from llava.mm_utils import process_images, load_image_from_base64, tokenizer_image_token, expand2square
+from llava.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
+from transformers import AutoTokenizer
+
+import sglang as sgl
+from sglang.test.test_utils import add_common_sglang_args_and_parse, select_sglang_backend
+from sglang.backend.runtime_endpoint import RuntimeEndpoint
+from sglang.utils import read_jsonl, dump_state_text
+from sglang.lang.interpreter import ProgramState
+
+
+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,))
+            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: hacky padding
+                images = [expand2square(image, tuple(int(x * 255) for x in [0.48145466, 0.4578275, 0.40821073])) 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
+
+        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
+
+        # print(prompt)
+        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")

spatial-model/VLM-3R/llava/serve/test_message.py

@@ -0,0 +1,59 @@
+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()

spatial-model/VLM-3R/llava/spar_utils.py

@@ -0,0 +1,484 @@
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import cv2
+
+def scale_bbox(bbox, width, height):
+    return (np.array(bbox[0]) / 1000) * np.array([width, height, width, height])
+
+def scale_point(point, width, height):
+    return (np.array(point[0]) / 1000) * np.array([width, height])
+
+def draw_points(draw, image, data_entry, points):
+    for color, key in points:
+        point = scale_point(data_entry[key], image.width, image.height)
+        point = tuple(map(int, point))
+        draw.ellipse([point[0]-20, point[1]-20, point[0]+20, point[1]+20], fill=color)
+
+def draw_thick_bbox(draw, image, bbox, color, stroke=20):
+    bbox = scale_bbox(bbox, image.width, image.height)
+    extend = stroke * 7 / 8
+    bbox_out = [bbox[0] - extend, bbox[1] - extend, bbox[2] + extend, bbox[3] + extend]
+    draw.rectangle(tuple(map(int, bbox_out)), outline=color, width=stroke)
+
+def draw_spatial_relation_oo(image, data_entry):
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["red_bbox"], "red", stroke=20)
+    draw_thick_bbox(draw, image, data_entry["blue_bbox"], "blue", stroke=20)
+
+def draw_depth_prediction_oc(image, data_entry):
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point"), ("blue", "blue_point")])
+
+def draw_depth_prediction_oo(image, data_entry):
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point"), ("blue", "blue_point"), ("green", "green_point")])
+
+def draw_distance_prediction_oc(image, data_entry):
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point")])
+
+def draw_distance_prediction_oo(image, data_entry):
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point"), ("blue", "blue_point")])
+
+def draw_distance_inference_oc(image, data_entry):
+    pass 
+
+def draw_distance_inference_oo(image, data_entry):
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point"), ("blue", "blue_point"), ("green", "green_point")])
+
+def draw_spatial_volume_infer(image, data_entry):
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["red_bbox"], "red", stroke=20)
+
+def draw_spatial_imagination_oc(image, data_entry):
+    draw = ImageDraw.Draw(image)
+
+    draw_thick_bbox(draw, image, data_entry["red_bbox"], "red", stroke=20)
+    draw_thick_bbox(draw, image, data_entry["blue_bbox"], "blue", stroke=20)
+    draw_thick_bbox(draw, image, data_entry["green_bbox"], "green", stroke=20)
+
+def draw_position_matching(images, data_entry):
+    image_to_draw = images[0]
+    draw = ImageDraw.Draw(image_to_draw)
+
+    draw_thick_bbox(draw, image_to_draw, data_entry["red_bbox"], "red", stroke=20)
+
+def draw_spatial_imagination_oo(image, data_entry):
+    draw = ImageDraw.Draw(image)
+
+    draw_thick_bbox(draw, image, data_entry["red_bbox"], "red", stroke=20)
+    draw_thick_bbox(draw, image, data_entry["blue_bbox"], "blue", stroke=20)
+    draw_thick_bbox(draw, image, data_entry["green_bbox"], "green", stroke=20)
+    draw_thick_bbox(draw, image, data_entry["yellow_bbox"], "yellow", stroke=20)
+
+def draw_view_change_infer(images, data_entry):
+    pass
+
+def draw_depth_prediction_oc_mv(images, data_entry):
+    image_idx = data_entry["point_img_idx"][0]
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point")])
+
+    image = images[image_idx[1]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("blue", "blue_point")])
+
+def draw_depth_prediction_oo_mv(images, data_entry):
+    image_idx = data_entry["point_img_idx"][0]
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point")])
+
+    image = images[image_idx[1]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("blue", "blue_point")])
+
+    image = images[image_idx[2]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("green", "green_point")])
+
+def draw_distance_prediction_oc_mv(images, data_entry):
+    image_idx = data_entry["point_img_idx"][0]
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point")])
+
+def draw_distance_prediction_oo_mv(images, data_entry):
+    image_idx = data_entry["point_img_idx"][0]
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point")])
+
+    image = images[image_idx[1]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("blue", "blue_point")])
+
+def draw_obj_spatial_relation_oc_mv(images, data_entry):
+    image_idx = data_entry["bbox_img_idx"][0]
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+
+    red_bbox = data_entry.get("red_bbox", None)
+    if red_bbox:
+        draw_thick_bbox(draw, image, red_bbox, "red", stroke=20)
+
+    blue_bbox = data_entry.get("blue_bbox", None)
+    if blue_bbox:
+        draw_thick_bbox(draw, image, blue_bbox, "blue", stroke=20)
+    
+    green_bbox = data_entry.get("green_bbox", None)
+    if green_bbox:
+        draw_thick_bbox(draw, image, green_bbox, "green", stroke=20)
+
+def draw_obj_spatial_relation_oo_mv(images, data_entry):
+    image_idx = data_entry["bbox_img_idx"][0]
+    red_bbox = data_entry.get("red_bbox", None)
+    blue_bbox = data_entry.get("blue_bbox", None)
+    green_bbox = data_entry.get("green_bbox", None)
+    if red_bbox is None:
+        image = images[image_idx[0]]
+        draw = ImageDraw.Draw(image)
+        draw_thick_bbox(draw, image, blue_bbox, "blue", stroke=20)
+
+        image = images[image_idx[1]]
+        draw = ImageDraw.Draw(image)
+        draw_thick_bbox(draw, image, green_bbox, "green", stroke=20)
+    elif blue_bbox is None:
+        image = images[image_idx[0]]
+        draw = ImageDraw.Draw(image)
+        draw_thick_bbox(draw, image, red_bbox, "red", stroke=20)
+
+        image = images[image_idx[1]]
+        draw = ImageDraw.Draw(image)
+        draw_thick_bbox(draw, image, green_bbox, "green", stroke=20)
+    elif green_bbox is None:
+        image = images[image_idx[0]]
+        draw = ImageDraw.Draw(image)
+        draw_thick_bbox(draw, image, red_bbox, "red", stroke=20)
+
+        image = images[image_idx[1]]
+        draw = ImageDraw.Draw(image)
+        draw_thick_bbox(draw, image, blue_bbox, "blue", stroke=20)
+    else:
+        raise ValueError("Unexpected data entry")
+    
+def draw_distance_infer_center_oc_mv(images, data_entry):
+    pass
+
+def draw_distance_infer_center_oo_mv(images, data_entry):
+    image_idx = data_entry["point_img_idx"][0]
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point")])
+
+    image = images[image_idx[1]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("green", "green_point")])
+
+    image = images[image_idx[2]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("blue", "blue_point")])
+
+def draw_spatial_imagination_oc_mv(images, data_entry):
+    image_idx = data_entry["bbox_img_idx"][0]
+
+    image = images[image_idx[2]]
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["red_bbox"], "red", stroke=20)
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["green_bbox"], "green", stroke=20)
+
+    
+    image = images[image_idx[1]]
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["blue_bbox"], "blue", stroke=20)
+
+
+def draw_spatial_imagination_oo_mv(images, data_entry):
+    image_idx = data_entry["bbox_img_idx"][0]
+
+    image = images[image_idx[2]]
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["red_bbox"], "red", stroke=20)
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["green_bbox"], "green", stroke=20)
+
+    
+    image = images[image_idx[1]]
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["blue_bbox"], "blue", stroke=20)
+
+    image = images[image_idx[3]]
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["yellow_bbox"], "yellow", stroke=20)
+
+def draw_spatial_imagination_map_mv(images, data_entry):
+    for i, bbox in enumerate(data_entry["bbox_list"][0]):
+        img_idx = data_entry["bbox_img_idx"][0][i]
+        image = images[img_idx]
+        image = np.array(image)
+
+        bbox = (np.array(bbox) / 1000) * np.array([image.shape[1], image.shape[0], image.shape[1], image.shape[0]])
+        bbox = bbox.astype(int)
+
+        cv2.rectangle(image, (bbox[0]-20, bbox[1]-20), (bbox[2]+20, bbox[3]+20), color=(0, 0, 255), thickness=20)
+
+        label = f"object{i}"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 2.0
+        thickness = 10
+        text_size, _ = cv2.getTextSize(label, font, font_scale, thickness)
+
+        text_position = (bbox[2] - text_size[0], bbox[3] + text_size[1])
+        if text_position[1] > image.shape[0]:
+            text_position = (bbox[2] - text_size[0], bbox[3] - text_size[1])
+
+        cv2.putText(image, label, text_position, font, font_scale, color=(0, 255, 0), thickness=thickness)
+
+        images[img_idx] = Image.fromarray(image)
+
+def draw_distance_prediction_oo_video(images, data_entry):
+    image_idx = data_entry["point_img_idx"][0]
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("red", "red_point")])
+
+    image = images[image_idx[1]]
+    draw = ImageDraw.Draw(image)
+    draw_points(draw, image, data_entry, [("blue", "blue_point")])
+
+def draw_distance_infer_center_oo_video(images, data_entry):
+    for i, point in enumerate(data_entry["point_list"][0]):
+        img_idx = data_entry["point_img_idx"][0][i]
+        image = images[img_idx]
+        image = np.array(image)
+
+        point = (np.array(point) / 1000) * np.array([image.shape[1], image.shape[0]])
+        point = tuple(map(int, point))
+
+        cv2.circle(image, point, radius=20, color=(0, 0, 255), thickness=-1)
+
+        if i == 0:
+            label = f"objectA"
+        else:
+            label = f"object{i-1}"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 2.0
+        thickness = 10
+        text_size, _ = cv2.getTextSize(label, font, font_scale, thickness)
+
+        text_position = (point[0] + 20, point[1] + 20)
+
+        cv2.putText(image, label, text_position, font, font_scale, color=(0, 255, 0), thickness=thickness)
+
+        images[img_idx] = Image.fromarray(image)
+
+def draw_spatial_imagination_oo_video(images, data_entry):
+    image_indices = data_entry["bbox_img_idx"][0]
+    
+    bboxes_info = [
+        {"bbox_key": "green_bbox", "color": (0, 255, 0), "label": "object0"},
+        {"bbox_key": "blue_bbox",  "color": (255, 0, 0), "label": "object1"},
+        {"bbox_key": "red_bbox",   "color": (0, 0, 255), "label": "object2"},
+        {"bbox_key": "yellow_bbox", "color": (225, 225, 0),   "label": "object3"}
+    ]
+    
+    for i, bbox_info in enumerate(bboxes_info):
+        img_idx = image_indices[i]
+        image = images[img_idx]
+        
+        if isinstance(image, Image.Image):
+            image_np = np.array(image)
+            image_np = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+        else:
+            image_np = image
+        
+        bbox = data_entry[bbox_info["bbox_key"]]
+        bbox_coords = (np.array(bbox[0]) / 1000) * np.array([image_np.shape[1], image_np.shape[0], image_np.shape[1], image_np.shape[0]])
+        bbox_coords = bbox_coords.astype(int)
+        bbox_tuple = tuple(bbox_coords)
+        
+        cv2.rectangle(image_np, 
+                      (bbox_tuple[0]-20, bbox_tuple[1]-20), 
+                      (bbox_tuple[2]+20, bbox_tuple[3]+20), 
+                      color=bbox_info["color"], 
+                      thickness=20)
+        
+        label = bbox_info["label"]
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 2.0
+        thickness_text = 10
+        text_size, _ = cv2.getTextSize(label, font, font_scale, thickness_text)
+        
+        text_x = bbox_tuple[2] - text_size[0]
+        text_y = bbox_tuple[3] + text_size[1]
+        
+        if text_y > image_np.shape[0]:
+            text_y = bbox_tuple[3] - 5
+        
+        text_position = (text_x, text_y)
+        
+        cv2.rectangle(image_np, 
+                      (text_x, text_y - text_size[1]), 
+                      (text_x + text_size[0], text_y + 5), 
+                      bbox_info["color"], 
+                      cv2.FILLED)
+        
+        cv2.putText(image_np, 
+                    label, 
+                    text_position, 
+                    font, 
+                    font_scale, 
+                    (255, 255, 255),
+                    thickness_text, 
+                    cv2.LINE_AA)
+        
+        image_pil = Image.fromarray(cv2.cvtColor(image_np, cv2.COLOR_BGR2RGB))
+        images[img_idx] = image_pil
+
+def draw_spatial_imagination_oc_video(images, data_entry):
+    image_indices = data_entry["bbox_img_idx"][0]
+    
+    bboxes_info = [
+        {"bbox_key": "green_bbox", "color": (0, 255, 0), "label": "object0"},
+        {"bbox_key": "blue_bbox",  "color": (255, 0, 0), "label": "object1"},
+        {"bbox_key": "red_bbox",   "color": (0, 0, 255), "label": "object2"},
+    ]
+    
+    for i, bbox_info in enumerate(bboxes_info):
+        img_idx = image_indices[i]
+        image = images[img_idx]
+        
+        if isinstance(image, Image.Image):
+            image_np = np.array(image)
+            image_np = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+        else:
+            image_np = image
+        
+        bbox = data_entry[bbox_info["bbox_key"]]
+        bbox_coords = (np.array(bbox[0]) / 1000) * np.array([image_np.shape[1], image_np.shape[0], image_np.shape[1], image_np.shape[0]])
+        bbox_coords = bbox_coords.astype(int)
+        bbox_tuple = tuple(bbox_coords)
+        
+        cv2.rectangle(image_np, 
+                      (bbox_tuple[0]-20, bbox_tuple[1]-20), 
+                      (bbox_tuple[2]+20, bbox_tuple[3]+20), 
+                      color=bbox_info["color"], 
+                      thickness=20)
+        
+        label = bbox_info["label"]
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 2.0
+        thickness_text = 10
+        text_size, _ = cv2.getTextSize(label, font, font_scale, thickness_text)
+        
+        text_x = bbox_tuple[2] - text_size[0]
+        text_y = bbox_tuple[3] + text_size[1]
+        
+        if text_y > image_np.shape[0]:
+            text_y = bbox_tuple[3] - 5
+        
+        text_position = (text_x, text_y)
+        
+        cv2.rectangle(image_np, 
+                      (text_x, text_y - text_size[1]), 
+                      (text_x + text_size[0], text_y + 5), 
+                      bbox_info["color"], 
+                      cv2.FILLED)
+        
+        cv2.putText(image_np, 
+                    label, 
+                    text_position, 
+                    font, 
+                    font_scale, 
+                    (255, 255, 255),
+                    thickness_text, 
+                    cv2.LINE_AA)
+        
+        image_pil = Image.fromarray(cv2.cvtColor(image_np, cv2.COLOR_BGR2RGB))
+        images[img_idx] = image_pil
+
+def draw_obj_frame_locate(images, data_entry):
+    image_idx = data_entry["bbox_img_idx"][0]
+
+    image = images[image_idx[0]]
+    draw = ImageDraw.Draw(image)
+    draw_thick_bbox(draw, image, data_entry["red_bbox"], "red", stroke=20)
+
+def draw_appearance_order(images, data_entry):
+    pass
+
+def draw_room_size(images, data_entry):
+    pass
+
+def draw_camera_motion_infer(images, data_entry):
+    pass
+
+def draw_nav(images, data_entry):
+    pass
+
+def draw_obj_count(images, data_entry):
+    pass
+
+def draw_spatial_imagination_oc_video_hard(images, data_entry):
+    pass
+
+def draw_spatial_imagination_oo_video_hard(images, data_entry):
+    pass
+
+DRAW_FUNCTIONS = {
+    # Single View
+    "obj_spatial_relation_oo": draw_spatial_relation_oo,
+    "depth_prediction_oc": draw_depth_prediction_oc,
+    "depth_prediction_oo": draw_depth_prediction_oo,
+    "distance_prediction_oc": draw_distance_prediction_oc,
+    "distance_prediction_oo": draw_distance_prediction_oo,
+    "distance_infer_center_oc": draw_distance_inference_oc,
+    "distance_infer_center_oo": draw_distance_inference_oo,
+    "spatial_volume_infer": draw_spatial_volume_infer,
+    "spatial_imagination_oc": draw_spatial_imagination_oc,
+    "spatial_imagination_oo": draw_spatial_imagination_oo,
+
+    # Multi View
+    "position_matching": draw_position_matching,
+    "view_change_infer": draw_view_change_infer,
+    "depth_prediction_oc_mv": draw_depth_prediction_oc_mv,
+    "depth_prediction_oo_mv": draw_depth_prediction_oo_mv,
+    "distance_prediction_oc_mv": draw_distance_prediction_oc_mv,
+    "distance_prediction_oo_mv": draw_distance_prediction_oo_mv,
+    "obj_spatial_relation_oc_mv": draw_obj_spatial_relation_oc_mv, 
+    "obj_spatial_relation_oo_mv": draw_obj_spatial_relation_oo_mv,
+    "distance_infer_center_oc_mv": draw_distance_infer_center_oc_mv,
+    "distance_infer_center_oo_mv": draw_distance_infer_center_oo_mv,
+    "spatial_imagination_oc_mv": draw_spatial_imagination_oc_mv,
+    "spatial_imagination_oo_mv": draw_spatial_imagination_oo_mv,
+    "spatial_imagination_map_mv": draw_spatial_imagination_map_mv,
+    "camera_motion_infer": draw_camera_motion_infer,
+
+    # Video
+    "distance_prediction_oo_video": draw_distance_prediction_oo_video,
+    "distance_infer_center_oo_video": draw_distance_infer_center_oo_video,
+    "spatial_imagination_oo_video": draw_spatial_imagination_oo_video,
+    "spatial_imagination_oc_video": draw_spatial_imagination_oc_video,
+    "spatial_imagination_oc_video_hard": draw_spatial_imagination_oc_video_hard,
+    "spatial_imagination_oo_video_hard": draw_spatial_imagination_oo_video_hard,
+    "obj_frame_locate": draw_obj_frame_locate,
+    "appearance_order": draw_appearance_order,
+    "room_size": draw_room_size,
+    "obj_count": draw_obj_count,
+    "nav": draw_nav,
+}