init

app.py

@@ -0,0 +1,580 @@
+try:
+    import spaces
+except ImportError:
+    # Local run: define dummy decorator
+    class spaces:
+        @staticmethod
+        def GPU(duration=10):
+            def dummy(func):
+                return func
+            return dummy
+
+import argparse
+import json
+import time
+
+import gradio as gr
+from filelock import FileLock
+from PIL import Image
+import threading
+
+from utils import (
+    build_logger,
+    server_error_msg,
+    violates_moderation,
+    moderation_msg,
+    get_log_filename,
+)
+from conversation import Conversation
+from model import (
+    FullSequenceStreamer,
+    get_model,
+)
+
+logger = build_logger("dimple", "dimple.log")
+
+no_change_btn = gr.Button()
+enable_btn = gr.Button(interactive=True)
+disable_btn = gr.Button(interactive=False)
+
+
+@spaces.GPU(duration=10)
+def make_zerogpu_happy():
+    pass
+
+
+def write2file(path, content):
+    lock = FileLock(f"{path}.lock")
+    with lock:
+        with open(path, "a") as fout:
+            fout.write(content)
+
+model, processor = get_model("cuda:0")
+
+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 init_state(state=None):
+    if state is not None:
+        del state
+    return Conversation()
+
+def vote_last_response(state, liked, request: gr.Request):
+    conv_data = {
+        "tstamp": round(time.time(), 4),
+        "like": liked,
+        "model": '"rp-yu/Dimple-7B"',
+        "state": state.dict(),
+        "ip": request.client.host,
+    }
+    write2file(get_log_filename(), json.dumps(conv_data) + "\n")
+
+
+def upvote_last_response(state, request: gr.Request):
+    logger.info(f"upvote. ip: {request.client.host}")
+    vote_last_response(state, True, request)
+    textbox = gr.MultimodalTextbox(value=None, interactive=True)
+    return (textbox,) + (disable_btn,) * 3
+
+
+def downvote_last_response(state, request: gr.Request):
+    logger.info(f"downvote. ip: {request.client.host}")
+    vote_last_response(state, False, request)
+    textbox = gr.MultimodalTextbox(value=None, interactive=True)
+    return (textbox,) + (disable_btn,) * 3
+
+
+def vote_selected_response(
+    state, request: gr.Request, data: gr.LikeData
+):
+    logger.info(
+        f"Vote: {data.liked}, index: {data.index}, value: {data.value} , ip: {request.client.host}"
+    )
+    conv_data = {
+        "tstamp": round(time.time(), 4),
+        "like": data.liked,
+        "index": data.index,
+        "model": 'rp-yu/Dimple-7B',
+        "state": state.dict(),
+        "ip": request.client.host,
+    }
+    write2file(get_log_filename(), json.dumps(conv_data) + "\n")
+    return
+
+
+def flag_last_response(state, request: gr.Request):
+    logger.info(f"flag. ip: {request.client.host}")
+    vote_last_response(state, "flag", request)
+    textbox = gr.MultimodalTextbox(value=None, interactive=True)
+    return (textbox,) + (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
+    state.update_message(Conversation.ASSISTANT, content='', image=None, idx=-1)
+    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
+    textbox = gr.MultimodalTextbox(value=None, interactive=True)
+    return (state, state.to_gradio_chatbot(), textbox) + (disable_btn,) * 5
+
+
+def clear_history(request: gr.Request):
+    logger.info(f"clear_history. ip: {request.client.host}")
+    state = init_state()
+    textbox = gr.MultimodalTextbox(value=None, interactive=True)
+    return (state, state.to_gradio_chatbot(), textbox) + (disable_btn,) * 5
+
+
+def add_text(state, message, system_prompt, request: gr.Request):
+    print(f"state: {state}")
+    if not state:
+        state = init_state()
+    images = message.get("files", [])
+    text = message.get("text", "").strip()
+    logger.info(f"add_text. ip: {request.client.host}. len: {len(text)}")
+    # import pdb; pdb.set_trace()
+    textbox = gr.MultimodalTextbox(value=None, interactive=False)
+    if len(text) <= 0 and len(images) == 0:
+        state.skip_next = True
+        return (state, state.to_gradio_chatbot(), textbox) + (no_change_btn,) * 5
+    if args.moderate:
+        flagged = violates_moderation(text)
+        if flagged:
+            state.skip_next = True
+            textbox = gr.MultimodalTextbox(
+                value={"text": moderation_msg}, interactive=True
+            )
+            return (state, state.to_gradio_chatbot(), textbox) + (no_change_btn,) * 5
+    images = [Image.open(path).convert("RGB") for path in images]
+
+    if len(images) > 0 and len(state.get_images(source=state.USER)) > 0:
+        state = init_state(state)
+    state.set_system_message(system_prompt)
+    state.append_message(Conversation.USER, text, images)
+    state.skip_next = False
+    return (state, state.to_gradio_chatbot(), textbox) + (
+        disable_btn,
+    ) * 5
+
+
+def http_bot(
+    state,
+    temperature,
+    top_p,
+    p_threshold,
+    alg_temp,
+    max_new_tokens,
+    steps,
+    alg,
+):
+    start_tstamp = time.time()
+    if hasattr(state, "skip_next") and state.skip_next:
+        # This generate call is skipped due to invalid inputs
+        yield (
+            state,
+            state.to_gradio_chatbot(),
+            gr.MultimodalTextbox(interactive=False),
+        ) + (no_change_btn,) * 5
+        return
+
+    all_images = state.get_images(source=state.USER)
+    all_image_paths = [state.save_image(image) for image in all_images]
+    
+    if len(all_images) == 0:
+        all_images = None
+
+    messages = state.get_prompt()
+    text = processor.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True, add_vision_id=False
+    )
+
+    inputs = processor(
+            text=text,
+            images=all_images,
+            videos=None,
+            padding="longest",
+            return_tensors="pt",
+        ).to(model.device)
+    input_ids = inputs.pop("input_ids")
+
+    streamer = FullSequenceStreamer(
+        processor.tokenizer,
+        timeout=10,
+        skip_special_tokens=True,
+    )
+
+    def run_generate():
+        output = model.diffusion_generate(
+            input_ids,
+            max_new_tokens=int(max_new_tokens),
+            output_history=True,
+            return_dict_in_generate=True,
+            steps=int(steps),
+            temperature=float(temperature),
+            top_p=float(top_p),
+            alg=alg,
+            alg_temp = float(alg_temp),
+            use_cache=True,
+            alg_p_threshold=float(p_threshold),
+            use_original_confidence=True,
+            decoding_pipeline="dim",
+            streamer = streamer,
+            **inputs
+        )
+    
+    thread = threading.Thread(target=run_generate)
+    thread.start()
+
+    logger.info(f"==== wait for first token ====\n")
+    state.append_message(Conversation.ASSISTANT, state.streaming_placeholder)
+    yield (
+        state,
+        state.to_gradio_chatbot(),
+        gr.MultimodalTextbox(interactive=False),
+    ) + (disable_btn,) * 5
+
+    try:
+        # Stream output
+        for ans in streamer:
+            if len(ans) > 1:
+                ans = "\n".join(ans)
+            else:
+                ans = ans[0]
+                
+            state.update_message(Conversation.ASSISTANT, ans, None)
+            yield (
+                state,
+                state.to_gradio_chatbot(),
+                gr.MultimodalTextbox(interactive=False),
+            ) + (disable_btn,) * 5
+    except Exception as e:
+        state.update_message(Conversation.ASSISTANT, server_error_msg, None)
+        yield (
+            state,
+            state.to_gradio_chatbot(),
+            gr.MultimodalTextbox(interactive=True),
+        ) + (
+            disable_btn,
+            disable_btn,
+            disable_btn,
+            enable_btn,
+            enable_btn,
+        )
+        return
+
+    state.end_of_current_turn()
+
+    yield (
+        state,
+        state.to_gradio_chatbot(),
+        gr.MultimodalTextbox(interactive=True),
+    ) + (enable_btn,) * 5
+
+    finish_tstamp = time.time()
+    logger.info(f"{ans}")
+    data = {
+        "tstamp": round(finish_tstamp, 4),
+        "like": None,
+        "model": "rp-yu/Dimple-7B",
+        "start": round(start_tstamp, 4),
+        "finish": round(start_tstamp, 4),
+        "state": state.dict(),
+        "images": all_image_paths,
+    }
+    write2file(get_log_filename(), json.dumps(data) + "\n")
+
+title_html = """
+<div style="width:100%; max-width:600px; margin:auto;">
+<img src="https://cdn-uploads.huggingface.co/production/uploads/635364b3c41f548fe39db945/T6ffjtAkFkI76QjXmN6iR.png" style="width:100%;">
+<p style="margin:0; text-align:left;">
+Dimple: Discrete Diffusion Multimodal Large Language Model with Parallel Decoding
+</p>
+<a href="https://arxiv.org/abs/">[📜 Dimple Paper]</a><br>
+<a href="https://github.com/yu-rp/Dimple">[🌟 Github]</a><br>  
+<a href="https://huggingface.co/rp-yu/Dimple-7B">[🤗 Huggingface Model]</a><br>
+<a href="https://huggingface.co/spaces/rp-yu/dimple">[💬 Huggingface Demo]</a><br>
+</div>
+"""
+
+
+tos_markdown = """
+Acknowledgement: This demo is built on the huggingfcae space of [InternVL](https://huggingface.co/spaces/OpenGVLab/InternVL).
+"""
+
+
+# .gradio-container {margin: 5px 10px 0 10px !important};
+block_css = """
+.gradio-container {margin: 0.1% 1% 0 1% !important; max-width: 98% !important;};
+#buttons button {
+    min-width: min(120px,100%);
+}
+
+.gradient-text {
+    font-size: 28px;
+    width: auto;
+    font-weight: bold;
+    background: linear-gradient(45deg, red, orange, yellow, green, blue, indigo, violet);
+    background-clip: text;
+    -webkit-background-clip: text;
+    color: transparent;
+}
+
+.plain-text {
+    font-size: 22px;
+    width: auto;
+    font-weight: bold;
+}
+"""
+
+
+def build_demo():
+    textbox = gr.MultimodalTextbox(
+        interactive=True,
+        file_types=["image"],
+        placeholder="Enter message or upload file...",
+        show_label=False,
+    )
+
+    with gr.Blocks(
+        title="Dimple-7B",
+        theme=gr.themes.Default(),
+        css=block_css,
+    ) as demo:
+        state = gr.State()
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                gr.HTML(title_html)
+
+                with gr.Accordion("Settings", open=False) as setting_row:
+                    system_prompt = gr.Textbox(
+                        value="You are a helpful assistant.",
+                        label="System Prompt",
+                        interactive=True,
+                    )
+                    temperature = gr.Slider(
+                        minimum=0.0,
+                        maximum=2.0,
+                        value=0.2,
+                        step=0.1,
+                        interactive=True,
+                        label="Temperature",
+                    )
+                    top_p = gr.Slider(
+                        minimum=0.0,
+                        maximum=1.0,
+                        value=0.95,
+                        step=0.1,
+                        interactive=True,
+                        label="Top P",
+                    )
+                    alg = gr.Radio(
+                        choices=["origin", "maskgit_plus", "entropy"],
+                        value="origin",
+                        label="Selection Algorithm",
+                        interactive=True,
+                    )
+                    p_threshold = gr.Slider(
+                        minimum=0.,
+                        maximum=1.0,
+                        value=0.95,
+                        step=0.01,
+                        interactive=True,
+                        label="Probability threshold for Confident Decoding",
+                    )
+                    alg_temp = gr.Slider(
+                        minimum=0.0,
+                        maximum=2.0,
+                        value=0.2,
+                        step=0.1,
+                        interactive=True,
+                        label="Temperature for Selectiion Algorithm",
+                    )
+                    max_new_tokens = gr.Slider(
+                        minimum=1,
+                        maximum=128,
+                        value=64,
+                        step=2,
+                        interactive=True,
+                        label="Max output tokens",
+                    )
+                    steps = gr.Slider(
+                        minimum=1,
+                        maximum=128,
+                        value=64,
+                        step=2,
+                        interactive=True,
+                        label="Number of decoding steps",
+                    )
+
+                examples = gr.Examples(
+                    examples=[
+                        [
+                            {
+                                "files": [
+                                    "gallery/14.jfif",
+                                ],
+                                "text": "Please help me analyze this picture.",
+                            }
+                        ],
+                        [
+                            {
+                                "files": [
+                                    "gallery/prod_9.jpg",
+                                ],
+                                "text": "Please help me describe the image.",
+                            }
+                        ],
+                        [
+                            {
+                                "files": [
+                                    "gallery/15.PNG",
+                                ],
+                                "text": "Please help me analyze this picture.",
+                            }
+                        ],
+                    ],
+                    inputs=[textbox],
+                )
+
+            with gr.Column(scale=8):
+                chatbot = gr.Chatbot(
+                    elem_id="chatbot",
+                    label="Dimple-7B",
+                    height=580,
+                    show_copy_button=True,
+                    show_share_button=True,
+                    avatar_images=[
+                        "assets/human.png",
+                        "assets/assistant.png",
+                    ],
+                    bubble_full_width=False,
+                )
+                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)
+
+        gr.Markdown(tos_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],
+            [textbox, upvote_btn, downvote_btn, flag_btn],
+        )
+        downvote_btn.click(
+            downvote_last_response,
+            [state],
+            [textbox, upvote_btn, downvote_btn, flag_btn],
+        )
+        chatbot.like(
+            vote_selected_response,
+            [state],
+            [],
+        )
+        flag_btn.click(
+            flag_last_response,
+            [state],
+            [textbox, upvote_btn, downvote_btn, flag_btn],
+        )
+        regenerate_btn.click(
+            regenerate,
+            [state, system_prompt],
+            [state, chatbot, textbox] + btn_list,
+        ).then(
+            http_bot,
+            [
+                state,
+                temperature,
+                top_p,
+                p_threshold,
+                alg_temp,
+                max_new_tokens,
+                steps,
+                alg,
+            ],
+            [state, chatbot, textbox] + btn_list,
+        )
+        clear_btn.click(clear_history, None, [state, chatbot, textbox] + btn_list)
+
+        textbox.submit(
+            add_text,
+            [state, textbox, system_prompt],
+            [state, chatbot, textbox] + btn_list,
+        ).then(
+            http_bot,
+            [
+                state,
+                temperature,
+                top_p,
+                p_threshold,
+                alg_temp,
+                max_new_tokens,
+                steps,
+                alg,
+            ],
+            [state, chatbot, textbox] + btn_list,
+        )
+        submit_btn.click(
+            add_text,
+            [state, textbox, system_prompt],
+            [state, chatbot, textbox] + btn_list,
+        ).then(
+            http_bot,
+            [
+                state,
+                temperature,
+                top_p,
+                p_threshold,
+                alg_temp,
+                max_new_tokens,
+                steps,
+                alg,
+            ],
+            [state, chatbot, textbox] + btn_list,
+        )
+
+    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, default=7860)
+    parser.add_argument("--concurrency-count", type=int, default=10)
+    parser.add_argument("--share", action="store_true")
+    parser.add_argument("--moderate", action="store_true")
+    args = parser.parse_args()
+    logger.info(f"args: {args}")
+
+    logger.info(args)
+    demo = build_demo()
+    demo.queue(api_open=False).launch(
+        server_name=args.host,
+        server_port=args.port,
+        share=args.share,
+        max_threads=args.concurrency_count,
+    )

constants.py

@@ -0,0 +1,7 @@
+# --------------------------------------------------------
+# Dimple
+# Copyright (c) 2025 Dimple Team
+# Licensed under The MIT License [see LICENSE for details]
+# --------------------------------------------------------
+
+LOGDIR = 'logs/'

conversation.py

@@ -0,0 +1,295 @@
+import os
+import dataclasses
+import base64
+import copy
+import hashlib
+import datetime
+from io import BytesIO
+from PIL import Image
+from typing import Any, List, Dict, Union
+from dataclasses import field
+
+from utils import LOGDIR
+
+
+def pil2base64(img: Image.Image) -> str:
+    buffered = BytesIO()
+    img.save(buffered, format="PNG")
+    return base64.b64encode(buffered.getvalue()).decode()
+
+
+def resize_img(img: Image.Image, max_len: int, min_len: int) -> Image.Image:
+    max_hw, min_hw = max(img.size), min(img.size)
+    aspect_ratio = max_hw / min_hw
+    # max_len, min_len = 800, 400
+    shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw))
+    longest_edge = int(shortest_edge * aspect_ratio)
+    W, H = img.size
+    if H > W:
+        H, W = longest_edge, shortest_edge
+    else:
+        H, W = shortest_edge, longest_edge
+    return img.resize((W, H))
+
+
+@dataclasses.dataclass
+class Conversation:
+    """A class that keeps all conversation history."""
+
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+    roles: List[str] = field(
+        default_factory=lambda: [
+            Conversation.SYSTEM,
+            Conversation.USER,
+            Conversation.ASSISTANT,
+        ]
+    )
+    mandatory_system_message = ""
+    system_message: str = "You are a helpful assistant."
+    messages: List[Dict[str, Any]] = field(default_factory=lambda: [])
+    max_image_limit: int = 2
+    skip_next: bool = False
+    streaming_placeholder: str = "•••"
+
+    def get_system_message(self):
+        if len(self.mandatory_system_message) == 0:
+            return self.system_message
+        else:
+            return self.mandatory_system_message + "\n\n" + self.system_message
+
+    def set_system_message(self, system_message: str):
+        self.system_message = system_message
+        return self
+    
+    def get_prompt(self):
+        send_messages = [
+            {
+                "role": "system", 
+                "content": self.get_system_message(),
+            }
+        ]
+        for message in self.messages:
+            if message["role"] == self.USER:
+                user_message = {
+                    "role": self.USER,
+                    "content": message["content"],
+                }
+                if "image" in message:
+                    user_message["image"] = []
+                    for image in message["image"]:
+                        user_message["image"].append(pil2base64(image))
+                    
+                    content = [{"type": "text", "text": message["content"]}]
+                    for image_base64 in user_message["image"]:
+                        content.append({
+                            "type": "image", 
+                            "image": f"data:image/jpeg;base64,{image_base64}"
+                        })
+                    send_messages.append({'role': self.USER, 'content': content})
+                else:
+                    send_messages.append(user_message)
+            elif message["role"] == self.ASSISTANT:
+                send_messages.append(
+                    {"role": self.ASSISTANT, "content": message["content"]}
+                )
+            elif message["role"] == self.SYSTEM:
+                send_messages.append(
+                    {
+                        "role": self.SYSTEM,
+                        "content": message["content"],
+                    }
+                )
+            else:
+                raise ValueError(f"Invalid role: {message['role']}")
+        return send_messages
+
+    def append_message(
+        self,
+        role,
+        content,
+        image_list=None,
+    ):
+        self.messages.append(
+            {
+                "role": role,
+                "content": content,
+                "image": [] if image_list is None else image_list,
+                # "filenames": save_filenames,
+            }
+        )
+
+    def get_images(
+        self,
+        return_copy=False,
+        return_base64=False,
+        source: Union[str, None] = None,
+    ):
+        assert source in [self.USER, self.ASSISTANT, None], f"Invalid source: {soure}"
+        images = []
+        for i, msg in enumerate(self.messages):
+            if source and msg["role"] != source:
+                continue
+
+            for image in msg.get("image", []):
+                # org_image = [i.copy() for i in image]
+                if return_copy:
+                    image = image.copy()
+
+                if return_base64:
+                    image = pil2base64(image)
+
+                images.append(image)
+
+        return images
+
+    def to_gradio_chatbot(self):
+        ret = []
+        for i, msg in enumerate(self.messages):
+            if msg["role"] == self.SYSTEM:
+                continue
+
+            alt_str = (
+                "user upload image" if msg["role"] == self.USER else "output image"
+            )
+            image = msg.get("image", [])
+            if not isinstance(image, list):
+                images = [image]
+            else:
+                images = image
+
+            img_str_list = []
+            for i in range(len(images)):
+                image = resize_img(
+                    images[i],
+                    400,
+                    200,
+                )
+                img_b64_str = pil2base64(image)
+                W, H = image.size
+                img_str = f'<img src="data:image/png;base64,{img_b64_str}" alt="{alt_str}" style="width: {W}px; max-width:none; max-height:none"></img>'
+                # img_str = (
+                #     f'<img src="data:image/png;base64,{img_b64_str}" alt="{alt_str}" />'
+                # )
+                img_str_list.append(img_str)
+            
+            if ('\[' in msg["content"] and '\]' in msg["content"]) or ('\(' in msg["content"] and '\)' in msg["content"]):
+                # 行内公式 or 行间公式
+                content = msg["content"].replace('\[', '$$').replace('\]', '$$').replace('\(', '$$').replace('\)', '$$')
+                content = content.split('$$')
+                for i in range(len(content)):
+                    if i % 2:
+                        content[i] = content[i].strip()
+                content = '$$'.join(content)
+                print('content:', content)
+                # content = (
+                #     r"<span>" + content + r"</span>"
+                #     r"<script type='text/javascript'>"
+                #     r"MathJax.typesetPromise();"
+                #     r"</script>"
+                # )
+            else:
+                content = msg["content"]
+            if msg["role"] == self.USER:
+                msg_str = " ".join(img_str_list) + content
+                ret.append([msg_str, None])
+            else:
+                msg_str = content + " ".join(img_str_list)
+                ret[-1][-1] = msg_str
+        return ret
+
+    def update_message(self, role, content, image=None, idx=-1):
+        assert len(self.messages) > 0, "No message in the conversation."
+
+        idx = (idx + len(self.messages)) % len(self.messages)
+
+        assert (
+            self.messages[idx]["role"] == role
+        ), f"Role mismatch: {role} vs {self.messages[idx]['role']}"
+
+        self.messages[idx]["content"] = content
+        if image is not None:
+            if image not in self.messages[idx]["image"]:
+                self.messages[idx]["image"] = []
+            if not isinstance(image, list):
+                image = [image]
+            self.messages[idx]["image"].extend(image)
+
+    def return_last_message(self):
+        return self.messages[-1]["content"]
+
+    def end_of_current_turn(self):
+        assert len(self.messages) > 0, "No message in the conversation."
+        assert (
+            self.messages[-1]["role"] == self.ASSISTANT
+        ), f"It should end with the message from assistant instead of {self.messages[-1]['role']}."
+
+        if self.messages[-1]["content"][-1] != self.streaming_placeholder:
+            return
+
+        self.update_message(self.ASSISTANT, self.messages[-1]["content"][:-1], None)
+
+    def copy(self):
+        return Conversation(
+            mandatory_system_message=self.mandatory_system_message,
+            system_message=self.system_message,
+            roles=copy.deepcopy(self.roles),
+            messages=copy.deepcopy(self.messages),
+        )
+
+    def dict(self):
+        """
+        all_images = state.get_images()
+        all_image_hash = [hashlib.md5(image.tobytes()).hexdigest() for image in all_images]
+        t = datetime.datetime.now()
+        for image, hash in zip(all_images, all_image_hash):
+            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)
+        """
+        messages = []
+        for message in self.messages:
+            images = []
+            for image in message.get("image", []):
+                filename = self.save_image(image)
+                images.append(filename)
+
+            messages.append(
+                {
+                    "role": message["role"],
+                    "content": message["content"],
+                    "image": images,
+                }
+            )
+            if len(images) == 0:
+                messages[-1].pop("image")
+
+        return {
+            "mandatory_system_message": self.mandatory_system_message,
+            "system_message": self.system_message,
+            "roles": self.roles,
+            "messages": messages,
+        }
+
+    def save_image(self, image: Image.Image) -> str:
+        t = datetime.datetime.now()
+        image_hash = hashlib.md5(image.tobytes()).hexdigest()
+        filename = os.path.join(
+            LOGDIR,
+            "serve_images",
+            f"{t.year}-{t.month:02d}-{t.day:02d}",
+            f"{image_hash}.jpg",
+        )
+        if not os.path.isfile(filename):
+            os.makedirs(os.path.dirname(filename), exist_ok=True)
+            image.save(filename)
+
+        return filename
+
+
+

gallery/14.jfif

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43e2db149258578de2d456c951d534278dbf3cd8f1987bf67219acf966139556
+size 112403

model.py

@@ -0,0 +1,35 @@
+
+import torch
+from transformers import AutoProcessor, AutoModel, TextIteratorStreamer
+
+class FullSequenceStreamer(TextIteratorStreamer):
+    def __init__(self, tokenizer, **kwargs):
+        super().__init__(tokenizer, **kwargs)
+
+    def put(self, value, stream_end=False):
+        # Assume full token_ids are passed in every time
+        decoded = self.tokenizer.batch_decode(value, **self.decode_kwargs)
+        self.text_queue.put(decoded)
+        if stream_end:
+            self.text_queue.put(self.stop_signal, timeout=self.timeout)
+
+    def end(self):
+        self.text_queue.put(self.stop_signal, timeout=self.timeout)
+
+def get_model(device):
+    
+    model_name = "rp-yu/Dimple-7B"
+    processor = AutoProcessor.from_pretrained(
+        model_name,
+        trust_remote_code=True
+    )
+    model = AutoModel.from_pretrained(
+        model_name,
+        torch_dtype=torch.bfloat16,
+        trust_remote_code=True,
+    )
+    model = model.eval()
+    model = model.to(device)
+
+    return model, processor
+

utils.py

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