add serve

app.py

@@ -0,0 +1,84 @@
+import gradio as gr
+import os
+import json
+from serve.gradio_web_t2s import *
+from serve.gradio_web_i2s import *
+from serve.leaderboard import build_leaderboard_tab
+from model.model_manager import ModelManager
+from pathlib import Path
+from serve.constants import SERVER_PORT, ROOT_PATH, ELO_RESULTS_DIR
+
+
+def build_combine_demo(models, elo_results_file, leaderboard_table_file):
+    with gr.Blocks(
+        title="Play with Open 3D Generative Models",
+        theme=gr.themes.Default(),
+        css=block_css,
+    ) as demo:
+        with gr.Tabs() as tabs_combine:
+            with gr.Tab("Text-to-3D Generation", id=0):
+                with gr.Tabs() as tabs_ig:
+                    with gr.Tab("Text-to-3D Arena (battle)", id=0):
+                        build_t2s_ui_side_by_side_anony(models)
+                    with gr.Tab("Text-to-3D Arena (side-by-side)", id=1):
+                        build_t2s_ui_side_by_side_named(models)
+                    with gr.Tab("Text-to-3D Direct Chat", id=2):
+                        build_t2s_ui_single_model(models)
+                    if elo_results_file:
+                        with gr.Tab("Text-to-3D Leaderboard", id=3):
+                            build_leaderboard_tab(elo_results_file['t2s_generation'], leaderboard_table_file['t2s_generation'])
+                    with gr.Tab("About Us", id=4):
+                        build_about()
+            
+            with gr.Tab("Image-to-3D Generation", id=5):
+                with gr.Tabs() as tabs_ie:
+                    with gr.Tab("Image-to-3D Arena (battle)", id=5):
+                        build_i2s_ui_side_by_side_anony(models)
+                    with gr.Tab("Image-to-3D Arena (side-by-side)", id=6):
+                        build_i2s_ui_side_by_side_named(models)
+                    with gr.Tab("Image-to-3D Direct Chat", id=7):
+                        build_i2s_ui_single_model(models)
+                    if elo_results_file:
+                        with gr.Tab("Image-to-3D Leaderboard", id=8):
+                            build_leaderboard_tab(elo_results_file['i2s_generation'], leaderboard_table_file['i2s_generation'])
+                    with gr.Tab("About Us", id=9):
+                        build_about()
+
+    return demo
+
+
+def load_elo_results(elo_results_dir):
+    from collections import defaultdict
+    elo_results_file = defaultdict(lambda: None)
+    leaderboard_table_file = defaultdict(lambda: None)
+    if elo_results_dir is not None:
+        elo_results_dir = Path(elo_results_dir)
+        elo_results_file = {}
+        leaderboard_table_file = {}
+        for file in elo_results_dir.glob('elo_results_*.pkl'):
+            if 't2s_generation' in file.name:
+                elo_results_file['t2s_generation'] = file
+            elif 'i2s_generation' in file.name:
+                elo_results_file['i2s_generation'] = file
+            else:
+                raise ValueError(f"Unknown file name: {file.name}")
+        for file in elo_results_dir.glob('*_leaderboard.csv'):
+            if 't2s_generation' in file.name:
+                leaderboard_table_file['t2s_generation'] = file
+            elif 'i2s_generation' in file.name:
+                leaderboard_table_file['i2s_generation'] = file
+            else:
+                raise ValueError(f"Unknown file name: {file.name}")
+            
+    return elo_results_file, leaderboard_table_file
+    
+if __name__ == "__main__":
+    server_port = int(SERVER_PORT)
+    root_path = ROOT_PATH
+    elo_results_dir = ELO_RESULTS_DIR
+    models = ModelManager()
+    
+    # elo_results_file, leaderboard_table_file = load_elo_results(elo_results_dir)
+    elo_results_file, leaderboard_table_file = None, None
+    demo = build_combine_demo(models, elo_results_file, leaderboard_table_file)
+    demo.queue(max_size=20).launch(server_port=server_port, root_path=ROOT_PATH)

model/model_config.py

@@ -0,0 +1,51 @@
+from collections import namedtuple
+from typing import List
+
+ModelConfig = namedtuple("ModelConfig", ["model_name", "i2s_model", "online_model", "model_path"])
+model_config = {}
+
+def register_model_config(
+    model_name: str, i2s_model: bool, online_model: bool, model_path: str = None
+):
+    config = ModelConfig(model_name, i2s_model, online_model, model_path)
+    model_config[model_name] = config
+
+def get_model_config(model_name: str) -> ModelConfig:
+    assert model_name in model_config
+    return model_config[model_name]
+
+register_model_config(
+    model_name="dreamfusion",
+    i2s_model=False,
+    online_model=False
+)
+
+register_model_config(
+    model_name="instant3d",
+    i2s_model=False,
+    online_model=False
+)
+
+register_model_config(
+    model_name="latent-nerf",
+    i2s_model=False,
+    online_model=False
+)
+
+register_model_config(
+    model_name="magic3d",
+    i2s_model=False,
+    online_model=False
+)
+
+register_model_config(
+    model_name="mvdream",
+    i2s_model=False,
+    online_model=False
+)
+
+register_model_config(
+    model_name="prolificdreamer",
+    i2s_model=False,
+    online_model=False
+)

model/model_manager.py

@@ -0,0 +1,120 @@
+import concurrent.futures 
+import random
+import gradio as gr
+import requests
+import io, base64, json
+# import spaces
+from PIL import Image
+
+from .model_config import model_config
+from .model_worker import BaseModelWorker
+
+class ModelManager:
+    def __init__(self):
+        self.models_config = model_config
+        self.models_worker: list[BaseModelWorker] = {}
+
+        self.build_model_workers()
+
+    def build_model_workers(self):
+        for cfg in self.models_config.values():
+            worker = BaseModelWorker(cfg.model_name, cfg.i2s_model, cfg.online_model, cfg.model_path)
+            self.models_worker[cfg.model_name] = worker
+    
+    def get_all_models(self):
+        models = []
+        for model_name in self.models_config.keys():
+            models.append(model_name)
+        return models
+    
+    def get_t2s_models(self):
+        models = []
+        for cfg in self.models_config.values():
+            if not cfg.i2s_model:
+                models.append(cfg.model_name)
+        return models
+    
+    def get_i2s_models(self):
+        models = []
+        for cfg in self.models_config.values():
+            if cfg.i2s_model:
+                models.append(cfg.model_name)
+        return models
+
+    def get_online_models(self):
+        models = []
+        for cfg in self.models_config.values():
+            if cfg.online_model:
+                models.append(cfg.model_name)
+        return models
+
+    def get_models(self, i2s_model:bool, online_model:bool):
+        models = []
+        for cfg in self.models_config.values():
+            if cfg.i2s_model==i2s_model and cfg.online_model==online_model:
+                models.append(cfg.model_name)
+        return models
+    
+    def check_online(self, name):
+        worker = self.models_worker[name]
+        if not worker.online_model:
+            return 
+
+    # @spaces.GPU(duration=120)
+    def inference(self, prompt, model_name):
+        worker = self.models_worker[model_name]
+        result = worker.inference(prompt=prompt)
+        return result
+    
+    def render(self, prompt, model_name):
+        worker = self.models_worker[model_name]
+        result = worker.render(prompt=prompt)
+        return result
+    
+    def inference_parallel(self, prompt, model_A, model_B):
+        results = []
+        model_names = [model_A, model_B]
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future_to_result = {executor.submit(self.inference, prompt, model): model 
+                                for model in model_names}
+            for future in concurrent.futures.as_completed(future_to_result):
+                result = future.result()
+                results.append(result)
+        return results[0], results[1]
+
+    def inference_parallel_anony(self, prompt, model_A, model_B, i2s_model):
+        if model_A == model_B == "":
+            model_A, model_B = random.sample(self.get_models(i2s_model=i2s_model, online_model=True), 2)
+        model_names = [model_A, model_B]
+        results = []
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future_to_result = {executor.submit(self.inference, prompt, model): model 
+                                for model in model_names}
+            for future in concurrent.futures.as_completed(future_to_result):
+                result = future.result()
+                results.append(result)
+        return results[0], results[1]
+    
+    
+    def render_parallel(self, prompt, model_A, model_B):
+        results = []
+        model_names = [model_A, model_B]
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future_to_result = {executor.submit(self.render, prompt, model): model 
+                                for model in model_names}
+            for future in concurrent.futures.as_completed(future_to_result):
+                result = future.result()
+                results.append(result)
+        return results[0], results[1]
+    
+    # def i2s_inference_parallel(self, image, model_A, model_B):
+    #     results = []
+    #     model_names = [model_A, model_B]
+    #     with concurrent.futures.ThreadPoolExecutor() as executor:
+    #         future_to_result = {executor.submit(self.inference, image, model): model 
+    #                             for model in model_names}
+    #         for future in concurrent.futures.as_completed(future_to_result):
+    #             result = future.result()
+    #             results.append(result)
+    #     return results[0], results[1]
+

model/model_registry.py

@@ -0,0 +1,219 @@
+from collections import namedtuple
+from typing import List
+
+ModelInfo = namedtuple("ModelInfo", ["simple_name", "link", "description"])
+model_info = {}
+
+def register_model_info(
+    full_names: List[str], simple_name: str, link: str, description: str
+):
+    info = ModelInfo(simple_name, link, description)
+
+    for full_name in full_names:
+        model_info[full_name] = info
+
+def get_model_info(name: str) -> ModelInfo:
+    if name in model_info:
+        return model_info[name]
+    else:
+        # To fix this, please use `register_model_info` to register your model
+        return ModelInfo(
+            name, "", "Register the description at fastchat/model/model_registry.py"
+        )
+
+def get_model_description_md(model_list):
+    model_description_md = """
+| | | |
+| ---- | ---- | ---- |
+"""
+    ct = 0
+    visited = set()
+    for i, name in enumerate(model_list):
+        minfo = get_model_info(name)
+        if minfo.simple_name in visited:
+            continue
+        visited.add(minfo.simple_name)
+        one_model_md = f"[{minfo.simple_name}]({minfo.link}): {minfo.description}"
+
+        if ct % 3 == 0:
+            model_description_md += "|"
+        model_description_md += f" {one_model_md} |"
+        if ct % 3 == 2:
+            model_description_md += "\n"
+        ct += 1
+    return model_description_md
+
+# regist text-to-shape generation models
+
+register_model_info(
+    ["dreamfusion"],
+    "DreamFusion",
+    "https://dreamfusion3d.github.io/",
+    "Text-to-3D using 2D Diffusion and SDS Loss",
+)
+
+register_model_info(
+    ["dreamgaussian"],
+    "DreamGaussian",
+    "https://github.com/dreamgaussian/dreamgaussian",
+    "Generative Gaussian Splatting for Efficient 3D Content Creation",
+)
+
+register_model_info(
+    ["fantasia3d"],
+    "Fantasia3D",
+    "https://fantasia3d.github.io/",
+    "Disentangling Geometry and Appearance for High-quality Text-to-3D Content Creation",
+)
+
+register_model_info(
+    ["latent-nerf"],
+    "Latent-NeRF",
+    "https://github.com/eladrich/latent-nerf",
+    "Latent-NeRF for Shape-Guided Generation of 3D Shapes and Textures",
+)
+
+register_model_info(
+    ["magic3d"],
+    "Magic3D",
+    "https://research.nvidia.com/labs/dir/magic3d/",
+    "High-Resolution Text-to-3D Content Creation",
+)
+
+register_model_info(
+    ["geodream"],
+    "GeoDream",
+    "https://mabaorui.github.io/GeoDream_page/",
+    "Disentangling 2D and Geometric Priors for High-Fidelity and Consistent 3D Generation",
+)
+
+register_model_info(
+    ["mvdream"],
+    "MVDream",
+    "https://github.com/bytedance/MVDream",
+    "Multi-view Diffusion for 3D Generation",
+)
+
+register_model_info(
+    ["prolificdreamer"],
+    "ProlificDreamer",
+    "https://ml.cs.tsinghua.edu.cn/prolificdreamer/",
+    "High-Fidelity and Diverse Text-to-3D Generation with Variational Score Distillation",
+)
+
+register_model_info(
+    ["syncdreamer"],
+    "SyncDreamer",
+    "https://github.com/liuyuan-pal/SyncDreamer",
+    "Generating Multiview-consistent Images from a Single-view Image",
+)
+
+register_model_info(
+    ["wonder3d"],
+    "Wonder3D",
+    "https://github.com/xxlong0/Wonder3D",
+    "Single Image to 3D using Cross-Domain Diffusion",
+)
+
+register_model_info(
+    ["dreamcraft3d"],
+    "Dreamcraft3d",
+    "https://github.com/deepseek-ai/DreamCraft3D",
+    "Hierarchical 3d generation with bootstrapped diffusion prior",
+)
+
+
+# register_model_info(
+#     [],
+#     "",
+#     "",
+#     "",
+# )
+
+
+# regist image edition models
+
+register_model_info(
+    ["zero123"],
+    "Zero-1-to-3",
+    "https://github.com/cvlab-columbia/zero123",
+    "Zero-shot One Image to 3D Object",
+)
+
+register_model_info(
+    ["stable-zero123", "zero123-xl"],
+    "Stable Zero123",
+    "https://stability.ai/news/stable-zero123-3d-generation",
+    "Quality 3D Object Generation from Single Images",
+)
+
+register_model_info(
+    ["magic123"],
+    "Magic123",
+    "https://guochengqian.github.io/project/magic123/",
+    "One Image to High-Quality 3D Object Generation Using Both 2D and 3D Diffusion Priors",
+)
+    
+register_model_info(
+    ["imagedream"],
+    "ImageDream",
+    "https://github.com/bytedance/ImageDream",
+    "Image-Prompt Multi-view Diffusion for 3D Generation",
+)
+
+register_model_info(
+    ["lucid-dreamer"],
+    "LucidDreamer",
+    "https://github.com/EnVision-Research/LucidDreamer",
+    "Towards High-Fidelity Text-to-3D Generation via Interval Score Matching",
+)
+
+register_model_info(
+    ["make-it-3d"],
+    "Make-It-3D",
+    "https://github.com/junshutang/Make-It-3D",
+    "High-Fidelity 3D Creation from A Single Image with Diffusion Prior",
+)
+
+register_model_info(
+    ["triplane-gaussian"],
+    "TriplaneGaussian",
+    "https://github.com/VAST-AI-Research/TriplaneGaussian",
+    "Triplane Meets Gaussian Splatting: Fast and Generalizable Single-View 3D Reconstruction with Transformers",
+)
+
+register_model_info(
+    ["free3d"],
+    "Free3D",
+    "https://github.com/lyndonzheng/Free3D",
+    "Consistent Novel View Synthesis without 3D Representation",
+)
+
+register_model_info(
+    ["escher-net"],
+    "EscherNet",
+    "https://github.com/kxhit/EscherNet",
+    "A Generative Model for Scalable View Synthesis",
+)
+
+register_model_info(
+    ["v3d"],
+    "V3D",
+    "https://github.com/heheyas/V3D",
+    "Video Diffusion Models are Effective 3D Generators",
+)
+
+register_model_info(
+    ["lgm"],
+    "LGM",
+    "https://github.com/3DTopia/LGM",
+    "Large Multi-View Gaussian Model for High-Resolution 3D Content Creation",
+)
+
+# register_model_info(
+#     [],
+#     "",
+#     "",
+#     "",
+# )
+

model/model_worker.py

@@ -0,0 +1,95 @@
+import os
+import time
+from typing import List
+import replicate
+
+os.environ("REPLICATE_API_TOKEN", "r8_0BaoQW0G8nWFXY8YWBCCUDurANxCtY72rarv9")
+
+class BaseModelWorker:
+    def __init__(self,
+                 model_name: str,
+                 i2s_model: bool, 
+                 online_model: bool,
+                 model_path: str = None,
+                 ):
+        self.model_name = model_name
+        self.i2s_model = i2s_model
+        self.online_model = online_model
+        self.model_path = model_path
+        self.model = None
+        
+        if self.online_model:
+            assert not self.model_path, f"Please give model_path of {model_name}"
+            self.model = self.load_model()
+
+    def check_online(self) -> bool:
+        if self.online_model and not self.model:
+            return True
+        else:
+            return False
+        
+    def load_model(self):
+        pass
+    
+    def inference(self, prompt):
+        pass
+
+    def render(self, shape):
+        pass
+
+class HuggingfaceApiWorker(BaseModelWorker):
+    def __init__(
+            self,
+            model_name: str,
+            i2s_model: bool, 
+            online_model: bool,
+            model_api: str,
+            model_path: str = None,
+    ):
+        super().__init__(
+            model_name,
+            i2s_model, 
+            online_model,
+            model_path,
+        )
+        self.model_api = model_api
+
+class PointE_Worker(BaseModelWorker):
+    def __init__(self, 
+                 model_name: str, 
+                 i2s_model: bool, 
+                 online_model: bool, 
+                 model_api: str,
+                 model_path: str = None):
+        super().__init__(model_name, i2s_model, online_model, model_path)
+        self.model_api = model_api
+
+
+class LGM_Worker(BaseModelWorker):
+    def __init__(self, 
+                 model_name: str, 
+                 i2s_model: bool, 
+                 online_model: bool, 
+                 model_path: str = "camenduru/lgm-ply-to-glb:eb217314ab0d025370df16b8c9127f9ac1a0e4b3ffbff6b323d598d3c814d258"):
+        super().__init__(model_name, i2s_model, online_model, model_path)
+    
+    def inference(self, image):
+        output = replicate.run(
+            self.model_path,
+            input={"ply_file_url": image}
+        )
+        #=> .glb file url: "https://replicate.delivery/pbxt/r4iOSfk7cv2wACJL539ACB4E...
+        return output
+
+
+if __name__=="__main__":
+    input = {
+    "ply_file_url": "https://replicate.delivery/pbxt/UvKKgNj9mT7pIVHzwerhcjkp5cMH4FS5emPVghk2qyzMRwUSA/gradio_output.ply"
+    }
+    print("Start...")
+    output = replicate.run(
+    "camenduru/lgm-ply-to-glb:eb217314ab0d025370df16b8c9127f9ac1a0e4b3ffbff6b323d598d3c814d258",
+    input=input
+    )
+    print("output: ", output)
+    #=> "https://replicate.delivery/pbxt/r4iOSfk7cv2wACJL539ACB4E...

model/models/__init__.py

@@ -0,0 +1,27 @@
+from .imagenhub_models import load_imagenhub_model
+from .playground_api import load_playground_model
+
+IMAGE_GENERATION_MODELS = ['imagenhub_LCM_generation','imagenhub_SDXLTurbo_generation','imagenhub_SDXL_generation', 'imagenhub_PixArtAlpha_generation',
+                            'imagenhub_OpenJourney_generation','imagenhub_SDXLLightning_generation', 'imagenhub_StableCascade_generation',
+                            'playground_PlayGroundV2_generation', 'playground_PlayGroundV2.5_generation']
+IMAGE_EDITION_MODELS = ['imagenhub_CycleDiffusion_edition', 'imagenhub_Pix2PixZero_edition', 'imagenhub_Prompt2prompt_edition',
+                        'imagenhub_SDEdit_edition', 'imagenhub_InstructPix2Pix_edition', 'imagenhub_MagicBrush_edition', 'imagenhub_PNP_edition']
+
+
+def load_pipeline(model_name):
+    """
+    Load a model pipeline based on the model name
+    Args:
+        model_name (str): The name of the model to load, should be of the form {source}_{name}_{type}
+        the source can be either imagenhub or playground
+        the name is the name of the model used to load the model
+        the type is the type of the model, either generation or edition
+    """
+    model_source, model_name, model_type = model_name.split("_")
+    if model_source == "imagenhub":
+        pipe = load_imagenhub_model(model_name, model_type)
+    elif model_source == "playground":
+        pipe = load_playground_model(model_name)
+    else:
+        raise ValueError(f"Model source {model_source} not supported")
+    return pipe

model/models/fal_api_models.py

@@ -0,0 +1,49 @@
+import fal
+
+class FalModel():
+    def __init__(self, model_name, model_type):
+        self.model_name = model_name
+        self.modle_type = model_type
+    
+    def __call__(self, *args, **kwargs):
+        
+        if self.model_type == "text2image":
+            assert "prompt" in kwargs, "prompt is required for text2image model"
+            handler = fal.apps.submit(
+                f"fal-ai/{self.model_name}",
+                arguments={
+                    "prompt": kwargs["prompt"]
+                },
+            )
+            
+            for event in handler.iter_events():
+                if isinstance(event, fal.apps.InProgress):
+                    print('Request in progress')
+                    print(event.logs)
+
+            result = handler.get()
+            return result
+        elif self.model_type == "image2image":
+            assert "image" in kwargs or "image_url" in kwargs, "image or image_url is required for image2image model"
+            if "image" in kwargs:
+                image_url = None
+                pass
+            handler = fal.apps.submit(
+                f"fal-ai/{self.model_name}",
+                arguments={
+                    "image_url": image_url
+                },
+            )
+            
+            for event in handler.iter_events():
+                if isinstance(event, fal.apps.InProgress):
+                    print('Request in progress')
+                    print(event.logs)
+
+            result = handler.get()
+            return result
+        else:
+            raise ValueError("model_type must be text2image or image2image")
+
+def load_fal_model(model_name, model_type):
+    return FalModel(model_name, model_type)

model/models/imagenhub_models.py

@@ -0,0 +1,33 @@
+import imagen_hub
+
+class ImagenHubModel():
+    def __init__(self, model_name):
+        self.model = imagen_hub.load(model_name)
+    
+    def __call__(self, *args, **kwargs):
+        return self.model.infer_one_image(*args, **kwargs)
+    
+class PNP(ImagenHubModel):
+    def __init__(self):
+        super().__init__('PNP')
+    
+    def __call__(self, *args, **kwargs):
+        if "num_inversion_steps" not in kwargs:
+            kwargs["num_inversion_steps"] = 200
+        return super().__call__(*args, **kwargs)
+
+class Prompt2prompt(ImagenHubModel):
+    def __init__(self):
+        super().__init__('Prompt2prompt')
+    
+    def __call__(self, *args, **kwargs):
+        if "num_inner_steps" not in kwargs:
+            kwargs["num_inner_steps"] = 3
+        return super().__call__(*args, **kwargs)
+    
+def load_imagenhub_model(model_name, model_type=None):
+    if model_name == 'PNP':
+        return PNP()
+    if model_name == 'Prompt2prompt':
+        return Prompt2prompt()
+    return ImagenHubModel(model_name)

model/models/playground_api.py

@@ -0,0 +1,35 @@
+import os
+import json
+import requests
+from PIL import Image
+import io
+import base64
+class PlayGround():
+    def __init__(self, model_name, model_type=None):
+        self.model_name = model_name
+        self.model_type = model_type
+        self.api_key = os.environ['PlaygroundAPI']
+        if model_name == "PlayGroundV2":
+            self._model_name = "Playground_v2"
+        elif model_name == "PlayGroundV2.5":
+            self._model_name = "Playground_v2.5"
+
+        
+    def __call__(self, prompt):
+        headers = {
+            'Content-Type': 'application/json',
+            'Authorization': "Bearer " + self.api_key,
+        }
+
+        data = json.dumps({"prompt": prompt, "filter_model": self._model_name, "scheduler": "DPMPP_2M_K", "guidance_scale": 3})
+
+        response = requests.post('https://playground.com/api/models/external/v1', headers=headers, data=data)
+        response.raise_for_status() 
+        json_obj = response.json()
+        image_base64 = json_obj['images'][0]
+        img = Image.open(io.BytesIO(base64.decodebytes(bytes(image_base64, "utf-8"))))
+
+        return img
+    
+def load_playground_model(model_name, model_type="generation"):
+    return PlayGround(model_name, model_type)

offline/utils.py

@@ -0,0 +1,73 @@
+import os
+import json
+import base64
+import requests
+import numpy as np
+import matplotlib.pyplot as plt
+
+# MAX_LEN = 40
+# STEP = 2
+# x = np.arange(0, MAX_LEN, STEP)
+# token_counts = [0] * (MAX_LEN//STEP)
+
+# with open("prompts.json", 'r') as f:
+#     prompts = json.load(f)
+
+# for prompt in prompts:
+#     tokens = len(prompt.strip().split(' '))
+#     token_counts[min(tokens//STEP, MAX_LEN//STEP-1)] += 1
+
+# plt.xticks(x, x+1)
+# plt.xlabel("token counts")
+# plt.bar(x, token_counts, width=1.3)
+# # plt.show()
+# plt.savefig("token_counts.png")
+
+## Generate image prompts
+with open("prompts.json") as f:
+    text_prompts = json.load(f)
+
+engine_id = "stable-diffusion-v1-6"
+api_host = os.getenv('API_HOST', 'https://api.stability.ai')
+api_key = os.getenv("STABILITY_API_KEY", "sk-ZvoFiXEbln6yh0hvSlm1K60WYcWFY5rmyW8a9FgoVBrKKP9N")
+
+if api_key is None:
+    raise Exception("Missing Stability API key.")
+
+for idx, text in enumerate(text_prompts):
+    if idx<=20: continue
+    print(f"Start generate prompt[{idx}]: {text}")
+    response = requests.post(
+        f"{api_host}/v1/generation/{engine_id}/text-to-image",
+        headers={
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        },
+        json={
+            "text_prompts": [
+                {
+                    "text": text.strip()
+                }
+            ],
+            "cfg_scale": 7,
+            "height": 1024,
+            "width": 1024,
+            "samples": 3,
+            "steps": 30,
+        },
+    )
+
+    if response.status_code != 200:
+        # raise Exception("Non-200 response: " + str(response.text))
+        print(f"{idx} Failed!!! {str(response.text)}")
+        continue
+    
+    print("Finished!")
+    data = response.json()
+
+    for i, image in enumerate(data["artifacts"]):
+        img_path = f"./images/{idx}/v1_txt2img_{i}.png"
+        os.makedirs(os.path.dirname(img_path), exist_ok=True)
+        with open(img_path, "wb") as f:
+            f.write(base64.b64decode(image["base64"]))

serve/constants.py

@@ -0,0 +1,20 @@
+import os
+
+LOGDIR = os.getenv("LOGDIR", "./3DGen-Arena-logs/vote_log")
+IMAGE_DIR = os.getenv("IMAGE_DIR", f"{LOGDIR}/images")
+OFFLINE_DIR = "./offline"
+
+SERVER_PORT = os.getenv("SERVER_PORT", 7860)
+ROOT_PATH = os.getenv("ROOT_PATH", None)
+ELO_RESULTS_DIR = os.getenv("ELO_RESULTS_DIR", "./arena_elo/results/latest")
+
+LOG_SERVER = os.getenv("LOG_SERVER", "https://tigerai.ca")
+LOG_SERVER_SUBDOAMIN = os.getenv("LOG_SERVER_SUBDIR", "GenAI-Arena-hf-logs")
+LOG_SERVER_ADDR = os.getenv("LOG_SERVER_ADDR", f"{LOG_SERVER}/{LOG_SERVER_SUBDOAMIN}")
+# LOG SERVER API ENDPOINTS
+APPEND_JSON = "append_json"
+SAVE_IMAGE = "save_image"
+SAVE_LOG = "save_log"
+
+NUM_SIDES = 2
+TEXT_PROMPT_PATH = "offline/prompts.json"

serve/gradio_web_i2s.py

@@ -0,0 +1,626 @@
+import json
+from functools import partial
+
+from .utils import *
+from .vote_utils import (
+    upvote_last_response_i2s as upvote_last_response,
+    downvote_last_response_i2s as downvote_last_response,
+    flag_last_response_i2s as flag_last_response,
+    leftvote_last_response_i2s_anony as leftvote_last_response_anony,
+    rightvote_last_response_i2s_anony as rightvote_last_response_anony,
+    tievote_last_response_i2s_anony as tievote_last_response_anony,
+    bothbad_vote_last_response_i2s_anony as bothbad_vote_last_response_anony,
+    leftvote_last_response_i2s_named as leftvote_last_response_named,
+    rightvote_last_response_i2s_named as rightvote_last_response_named,
+    tievote_last_response_i2s_named as tievote_last_response_named,
+    bothbad_vote_last_response_i2s_named as bothbad_vote_last_response_named,
+    share_click_i2s_multi as share_click,
+    share_js
+)
+from .inference import(
+    sample_i2s_model as sample_model,
+    sample_image,
+    sample_image_side_by_side,
+    generate_i2s,
+    generate_i2s_multi,
+    generate_i2s_multi_annoy
+)
+
+
+def build_i2s_ui_side_by_side_anony(models):
+    notice_markdown = """
+# ⚔️  GenAI-Arena ⚔️ : Benchmarking Image-to-3D generative models 
+## 📜 Rules
+- Upload image to two anonymous models in same area and vote for the better one!
+- When the results are ready, click the button below to vote.
+- Vote won't be counted if model identity is revealed during conversation.
+- Click "Clear" to start a new round.
+
+## 🏆 Arena Elo 
+Find out who is the 🥇conditional image generation models! More models are going to be supported.
+
+## 👇 Generating now!
+
+"""
+    model_list = models.get_i2s_models()
+    gen_func = partial(generate_i2s_multi_annoy, models.inference_parallel, models.render_parallel)
+
+    state_0 = gr.State()
+    state_1 = gr.State()
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+    model_str = gr.Markdown(str(model_list), visible=False, elem_id="moedl list string")
+
+    with gr.Group(elem_id="share-region-anony"):
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+
+        with gr.Row():    
+            with gr.Column():
+                normal_left = gr.Image(width=512, label = "Model A", 
+                    interactive=False, show_download_button=True)
+                rgb_left = gr.Image(width=512, label = "Model A", 
+                    interactive=False, show_download_button=True)
+            with gr.Column():
+                normal_right = gr.Image(width=512, label = "Model B",
+                    interactive=False, show_download_button=True,)
+                rgb_right = gr.Image(width=512, label = "Model B",
+                    interactive=False, show_download_button=True,)
+
+        with gr.Row():
+            with gr.Column():
+                model_selector_left =gr.Markdown("", visible=False)
+            with gr.Column():
+                model_selector_right = gr.Markdown("", visible=False)
+        with gr.Row():
+            slow_warning = gr.Markdown("", elem_id="notice_markdown")
+
+        with gr.Row(elem_id="Geometry Quality"):
+            geo_md = gr.Markdown("Geometry Quality: ", visible=False, elem_id="evaldim_markdown")
+            geo_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            geo_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            geo_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            geo_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+        with gr.Row(elem_id="Texture Quality"):
+            text_md = gr.Markdown("Texture Quality: ", visible=False, elem_id="evaldim_markdown")
+            text_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            text_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            text_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            text_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+        
+        with gr.Row(elem_id="Alignment Quality"):
+            align_md = gr.Markdown("Alignment Quality: ", visible=False, elem_id="evaldim_markdown")
+            align_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            align_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            align_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            align_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+    with gr.Row():
+        imagebox = gr.Image(
+            width=512,
+            show_label=False,
+            visible=True,
+            interactive=True,
+            elem_id="input_box",
+        )
+        with gr.Column():
+            sample_btn = gr.Button(value="🎲 Sample", variant="primary")
+            send_btn = gr.Button(value="📤 Send", variant="primary")
+            clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+            regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+            share_btn = gr.Button(value="📷  Share")
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+
+    geo_btn_list = [geo_leftvote_btn, geo_rightvote_btn, geo_tie_btn, geo_bothbad_btn]
+    text_btn_list = [text_leftvote_btn, text_rightvote_btn, text_tie_btn, text_bothbad_btn]
+    align_btn_list = [align_leftvote_btn, align_rightvote_btn, align_tie_btn, align_bothbad_btn]
+    states = [state_0, state_1]
+    model_selectors = [model_selector_left, model_selector_right]
+    results = [normal_left, rgb_left, normal_right, rgb_right]
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        leftvote_btn, rightvote_btn, tie_btn, bothbad_btn = btn_list
+
+        leftvote_btn.click(
+            leftvote_last_response_anony,
+            states + model_selectors,
+            [imagebox] + btn_list + model_selectors
+        )
+        rightvote_btn.click(
+            rightvote_last_response_anony,
+            states + model_selectors,
+            [imagebox] + btn_list + model_selectors
+        )
+        tie_btn.click(
+            tievote_last_response_anony,
+            states + model_selectors,
+            [imagebox] + btn_list + model_selectors
+        )
+        bothbad_btn.click(
+            bothbad_vote_last_response_anony,
+            states + model_selectors,
+            [imagebox] + btn_list + model_selectors
+        )
+
+    sample_btn.click(
+        sample_image_side_by_side,
+        states + model_selectors,
+        states + [imagebox],
+        api_name="sample_btn_anony"
+    )
+
+    imagebox.upload(
+        gen_func,
+        states + [imagebox] + model_selectors,
+        states + results + model_selectors,
+        api_name="submit_btn_named"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        sample_model,
+        states + [model_str],
+        states + model_selectors
+    ).then(
+        gen_func,
+        states + [imagebox] + model_selectors,
+        states + results + model_selectors,
+        api_name="send_btn_anony"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_i2s_history_side_by_side_anony, 
+        None, 
+        states + [imagebox] + results + model_selectors,
+        api_name="clear_btn_anony"
+    ).then(
+        disable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        disable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        sample_model,
+        states + [model_str],
+        states + model_selectors
+    ).then(
+        gen_func,
+        states + [imagebox] + model_selectors,
+        states + results + model_selectors,
+        api_name="regenerate_btn_anony"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    share_btn.click(
+        share_click,
+        states + model_selectors,
+        [],
+        js=share_js
+    )
+
+
+def build_i2s_ui_side_by_side_named(models):
+    notice_markdown = """
+# ⚔️  GenAI-Arena ⚔️ : Benchmarking Image-to-3D generative models 
+## 📜 Rules
+- Generate with any two selected models side-by-side and vote!
+- Sample or Input prompt you want to generate.
+- Click "Send" to submit the prompt.
+- Click "Clear" to start a new round.
+
+## 🏆 Arena Elo 
+Find out who is the 🥇conditional image generation models! More models are going to be supported.
+
+## 👇 Generating now!
+
+"""
+    model_list = models.get_i2s_models()
+    gen_func = partial(generate_i2s_multi, models.inference_parallel, models.render_parallel)
+
+    state_0 = gr.State()
+    state_1 = gr.State()
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+
+    with gr.Group(elem_id="share-region-named"):
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+
+        with gr.Row():
+            with gr.Column():
+                model_selector_left = gr.Dropdown(
+                    choices=model_list,
+                    value=model_list[0] if len(model_list) > 0 else "",
+                    interactive=True,
+                    show_label=False,
+                    container=False,
+                    )
+            with gr.Column():
+                model_selector_right = gr.Dropdown(
+                    choices=model_list,
+                    value=model_list[1] if len(model_list) > 1 else "",
+                    interactive=True,
+                    show_label=False,
+                    container=False,
+                    )
+
+        with gr.Row():
+
+            with gr.Column():
+                normal_left = gr.Image(width=512, label = "Model A", show_download_button=True)
+                rgb_left = gr.Image(width=512, label = "Model A", show_download_button=True)
+            with gr.Column():
+                normal_right = gr.Image(width=512, label = "Model B", show_download_button=True,)
+                rgb_right = gr.Image(width=512, label = "Model B", show_download_button=True,)
+
+        with gr.Row(elem_id="Geometry Quality"):
+            geo_md = gr.Markdown("Geometry Quality: ", visible=False, elem_id="evaldim_markdown")
+            geo_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            geo_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            geo_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            geo_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+        with gr.Row(elem_id="Texture Quality"):
+            text_md = gr.Markdown("Texture Quality: ", visible=False, elem_id="evaldim_markdown")
+            text_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            text_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            text_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            text_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+        
+        with gr.Row(elem_id="Alignment Quality"):
+            align_md = gr.Markdown("Alignment Quality: ", visible=False, elem_id="evaldim_markdown")
+            align_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            align_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            align_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            align_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+    with gr.Row():
+        imagebox = gr.Image(
+            width=512,
+            show_label=False,
+            visible=True,
+            interactive=True,
+            elem_id="input_box",
+        )
+
+        with gr.Column():
+            sample_btn = gr.Button(value="🎲 Sample", variant="primary")
+            send_btn = gr.Button(value="📤 Send", variant="primary")
+            clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+            regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+            share_btn = gr.Button(value="📷  Share")
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+    geo_btn_list = [geo_leftvote_btn, geo_rightvote_btn, geo_tie_btn, geo_bothbad_btn]
+    text_btn_list = [text_leftvote_btn, text_rightvote_btn, text_tie_btn, text_bothbad_btn]
+    align_btn_list = [align_leftvote_btn, align_rightvote_btn, align_tie_btn, align_bothbad_btn]
+    states = [state_0, state_1]
+    model_selectors = [model_selector_left, model_selector_right]
+    results = [normal_left, rgb_left, normal_right, rgb_right]
+
+    model_selector_left.change(
+        clear_i2s_history_side_by_side, 
+        None, 
+        states + [imagebox] + results, 
+        api_name="model_selector_left"
+    )
+    model_selector_right.change(
+        clear_i2s_history_side_by_side, 
+        None, 
+        states + [imagebox] + results, 
+        api_name="model_selector_right"
+    )
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        leftvote_btn, rightvote_btn, tie_btn, bothbad_btn = btn_list
+
+        leftvote_btn.click(
+            leftvote_last_response_named,
+            states + model_selectors,
+            [imagebox] + btn_list
+        )
+        rightvote_btn.click(
+            rightvote_last_response_named,
+            states + model_selectors,
+            [imagebox] + btn_list
+        )
+        tie_btn.click(
+            tievote_last_response_named,
+            states + model_selectors,
+            [imagebox] + btn_list
+        )
+        bothbad_btn.click(
+            bothbad_vote_last_response_named,
+            states + model_selectors,
+            [imagebox] + btn_list
+        )
+
+    sample_btn.click(
+        sample_image_side_by_side,
+        states + model_selectors,
+        states + [imagebox],
+        api_name="sample_btn_named"
+    )
+
+    imagebox.upload(
+        gen_func,
+        states + [imagebox] + model_selectors,
+        states + results + model_selectors,
+        api_name="submit_btn_named"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        gen_func,
+        states + [imagebox] + model_selectors,
+        states + results + model_selectors,
+        api_name="send_btn_named"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_i2s_history_side_by_side, 
+        None, 
+        states + [imagebox] + results,
+        api_name="clear_btn_named"
+    ).then(
+        disable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        disable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        gen_func,
+        states + [imagebox] + model_selectors,
+        states + results + model_selectors,
+        api_name="regenerate_btn_named"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    share_btn.click(
+        share_click,
+        states + model_selectors,
+        [],
+        js=share_js
+    )
+
+
+def build_i2s_ui_single_model(models):
+    notice_markdown = """
+# 🏔️ Play with Image Generation Models
+{promotion}
+
+## 🤖 Choose any model to generate
+
+"""
+    model_list = models.get_i2s_models()
+    gen_func = partial(generate_i2s, models.inference_parallel, models.render_parallel)
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+
+    with gr.Row():
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+
+    with gr.Row(elem_id="model_selector_row"):
+        model_selector = gr.Dropdown(
+            choices=model_list,
+            value=model_list[0] if len(model_list) > 0 else "",
+            interactive=True,
+            show_label=False
+        )
+
+    with gr.Row():
+        normal = gr.Image(width=512, label = "Normal", show_download_button=True)
+        rgb = gr.Image(width=512, label = "RGB", show_download_button=True,)
+
+    with gr.Row():
+        imagebox = gr.Image(
+            width=512,
+            show_label=False,
+            visible=True,
+            interactive=True,
+            elem_id="input_box",
+        )
+        with gr.Column():
+            # with gr.Row():
+            sample_btn = gr.Button(value="🎲 Sample", variant="primary")
+            send_btn = gr.Button(value="📤 Send", variant="primary")
+            clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+            regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+
+
+    with gr.Row(elem_id="Geometry Quality"):
+        gr.Markdown("Geometry Quality: ")
+        geo_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        geo_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        geo_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+
+    with gr.Row(elem_id="Texture Quality"):
+        gr.Markdown("Texture Quality: ")
+        text_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        text_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        text_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+    
+    with gr.Row(elem_id="Alignment Quality"):
+        gr.Markdown("Alignment Quality: ")
+        align_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        align_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        align_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+    state = gr.State()
+    geo_btn_list = [geo_upvote_btn, geo_downvote_btn, geo_flag_btn]
+    text_btn_list = [text_upvote_btn, text_downvote_btn, text_flag_btn]
+    align_btn_list = [align_upvote_btn, align_downvote_btn, align_flag_btn]
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        upvote_btn, downvote_btn, flag_btn = btn_list
+
+        upvote_btn.click(
+            upvote_last_response,
+            [state, model_selector],
+            [imagebox] + btn_list
+        )
+            
+        downvote_btn.click(
+            downvote_last_response,
+            [state, model_selector],
+            [imagebox] + btn_list
+        )
+        flag_btn.click(
+            flag_last_response,
+            [state, model_selector],
+            [imagebox] + btn_list
+        )
+
+    sample_btn.click(
+        sample_image,
+        [state, model_selector],
+        [state, imagebox],
+        api_name="sample_btn_single"
+    )
+
+    imagebox.upload(
+        gen_func,
+        [state, imagebox, model_selector],
+        [state, normal, rgb],
+        api_name="submit_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        gen_func,
+        [state, imagebox, model_selector],
+        [state, normal, rgb],
+        api_name="send_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_i2s_history, 
+        None, 
+        [state, imagebox, normal, rgb], 
+        api_name="clear_history_single",
+        show_progress="full"
+    ).then(
+        disable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        gen_func,
+        [state, imagebox, model_selector],
+        [state, normal, rgb],
+        api_name="regenerate_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+

serve/gradio_web_t2i_anony.py

@@ -0,0 +1,225 @@
+import json
+from functools import partial
+
+from .utils import *
+from .vote_utils import (
+    upvote_last_response_t2s as upvote_last_response,
+    downvote_last_response_t2s as downvote_last_response,
+    flag_last_response_t2s as flag_last_response,
+    leftvote_last_response_t2s_multi as leftvote_last_response,
+    rightvote_last_response_t2s_multi as rightvote_last_response,
+    tievote_last_response_t2s_multi as tievote_last_response,
+    bothbad_vote_last_response_t2s_multi as bothbad_vote_last_response,
+    share_click_t2s_multi as share_click,
+    share_js
+)
+from .inference import(
+    sample_model,
+    sample_prompt,
+    generate_t2s,
+    generate_t2s_multi,
+    generate_t2s_multi_annoy
+)
+from .constants import TEXT_PROMPT_PATH
+
+with open(TEXT_PROMPT_PATH, 'r') as f:
+    prompt_list = json.load(f)
+
+def build_side_by_side_ui_anony(models):
+    notice_markdown = """
+# ⚔️  GenAI-Arena ⚔️ : Benchmarking Text-to-3D generative models 
+## 📜 Rules
+- Input prompt to two anonymous models in same area and vote for the better one!
+- When the results are ready, click the button below to vote.
+- Vote won't be counted if model identity is revealed during conversation.
+- Click "Clear" to start a new round.
+
+## 🏆 Arena Elo 
+Find out who is the 🥇conditional image generation models! More models are going to be supported.
+
+## 👇 Generating now!
+
+"""
+    model_list = models.get_t2s_models()
+    gen_func = partial(generate_t2s_multi_annoy, models.inference_parallel, models.render_parallel)
+
+    state_0 = gr.State()
+    state_1 = gr.State()
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+
+    with gr.Group(elem_id="share-region-anony"):
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+        with gr.Row():
+            with gr.Column():
+                normal_left = gr.Image(width=512, label = "Model A", show_copy_button=True)
+                rgb_left = gr.Image(width=512, label = "Model A", show_copy_button=True)
+            with gr.Column():
+                normal_right = gr.Image(width=512, label = "Model B", show_copy_button=True,)
+                rgb_right = gr.Image(width=512, label = "Model B", show_copy_button=True,)
+
+        with gr.Row():
+            with gr.Column():
+                model_selector_left =gr.Markdown("", visible=False)
+            with gr.Column():
+                model_selector_right = gr.Markdown("", visible=False)
+        with gr.Row():
+            slow_warning = gr.Markdown("", elem_id="notice_markdown")
+
+        with gr.Row(elem_id="Geometry Quality"):
+            geo_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            geo_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            geo_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            geo_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+        with gr.Row(elem_id="Texture Quality"):
+            text_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            text_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            text_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            text_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+        
+        with gr.Row(elem_id="Alignment Quality"):
+            align_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            align_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            align_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            align_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+    with gr.Row():
+        textbox = gr.Textbox(
+            show_label=False,
+            placeholder="👉 Enter your prompt or Sample a random prompt, and press ENTER",
+            container=True,
+            elem_id="input_box",
+        )
+        sample_btn = gr.Button(value="🎲 Sample", variant="primary", scale=0)
+        send_btn = gr.Button(value="📤 Send", variant="primary", scale=0)
+
+    with gr.Row():
+        clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+        regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+        share_btn = gr.Button(value="📷  Share")
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+
+    geo_btn_list = [geo_leftvote_btn, geo_rightvote_btn, geo_tie_btn, geo_bothbad_btn]
+    text_btn_list = [text_leftvote_btn, text_rightvote_btn, text_tie_btn, text_bothbad_btn]
+    align_btn_list = [align_leftvote_btn, align_rightvote_btn, align_tie_btn, align_bothbad_btn]
+    states = [state_0, state_1]
+    model_selectors = [model_selector_left, model_selector_right]
+    results = [normal_left, rgb_left, normal_right, rgb_right]
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        leftvote_btn, rightvote_btn, tie_btn, bothbad_btn = btn_list
+
+        leftvote_btn.click(
+            leftvote_last_response,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        rightvote_btn.click(
+            rightvote_last_response,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        tie_btn.click(
+            tievote_last_response,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        bothbad_btn.click(
+            bothbad_vote_last_response,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+
+    sample_btn.click(
+        sample_prompt,
+        states + model_selectors + [prompt_list],
+        states + [textbox],
+        api_name="sample_btn_anony"
+    )
+
+    textbox.submit(
+        sample_model,
+        states + [model_list, False],
+        states + model_selectors
+    ).then(
+        gen_func,
+        states + [textbox] + model_selectors + [prompt_list],
+        states + results + model_selectors,
+        api_name="submit_btn_anony"
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        sample_model,
+        states + [model_list, False],
+        states + model_selectors
+    ).then(
+        gen_func,
+        states + [textbox] + model_selectors + [prompt_list],
+        states + results + model_selectors,
+        api_name="send_btn_anony"
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_history_side_by_side_anony, 
+        None, 
+        states + [textbox] + results + model_selectors,
+        api_name="clear_btn_anony"
+    ).then(
+        disable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        sample_model,
+        states + [model_list, False],
+        states + model_selectors
+    ).then(
+        gen_func,
+        states + [textbox] + model_selectors + [prompt_list],
+        states + results + model_selectors,
+        api_name="regenerate_btn_anony"
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    share_btn.click(
+        share_click,
+        states + model_selectors,
+        [],
+        js=share_js
+    )
+

serve/gradio_web_t2i_named.py

@@ -0,0 +1,236 @@
+import json
+from functools import partial
+
+from .utils import *
+from .vote_utils import (
+    upvote_last_response_t2s as upvote_last_response,
+    downvote_last_response_t2s as downvote_last_response,
+    flag_last_response_t2s as flag_last_response,
+    leftvote_last_response_t2s_multi as leftvote_last_response,
+    rightvote_last_response_t2s_multi as rightvote_last_response,
+    tievote_last_response_t2s_multi as tievote_last_response,
+    bothbad_vote_last_response_t2s_multi as bothbad_vote_last_response,
+    share_click_t2s_multi as share_click,
+    share_js
+)
+from .inference import(
+    sample_prompt,
+    generate_t2s_multi
+)
+from .constants import TEXT_PROMPT_PATH
+
+with open(TEXT_PROMPT_PATH, 'r') as f:
+    prompt_list = json.load(f)
+
+def build_side_by_side_ui_named(models):
+    notice_markdown = """
+# ⚔️  GenAI-Arena ⚔️ : Benchmarking Text-to-3D generative models 
+## 📜 Rules
+- Generate with any two selected models side-by-side and vote!
+- Sample or Input prompt you want to generate.
+- Click "Send" to submit the prompt.
+- Click "Clear" to start a new round.
+
+## 🏆 Arena Elo 
+Find out who is the 🥇conditional image generation models! More models are going to be supported.
+
+## 👇 Generating now!
+
+"""
+    model_list = models.get_t2s_models()
+    gen_func = partial(generate_t2s_multi, models.inference_parallel, models.render_parallel)
+
+    state_0 = gr.State()
+    state_1 = gr.State()
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+
+    with gr.Group(elem_id="share-region-named"):
+        with gr.Row():
+            with gr.Column():
+                model_selector_left = gr.Dropdown(
+                    choices=model_list,
+                    value=model_list[0] if len(model_list) > 0 else "",
+                    interactive=True,
+                    show_label=False,
+                    container=False,
+                    )
+            with gr.Column():
+                model_selector_right = gr.Dropdown(
+                    choices=model_list,
+                    value=model_list[1] if len(model_list) > 1 else "",
+                    interactive=True,
+                    show_label=False,
+                    container=False,
+                    )
+                
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+
+        with gr.Row():
+            with gr.Column():
+                normal_left = gr.Image(width=512, label = "Model A", show_copy_button=True)
+                rgb_left = gr.Image(width=512, label = "Model A", show_copy_button=True)
+            with gr.Column():
+                normal_right = gr.Image(width=512, label = "Model B", show_copy_button=True,)
+                rgb_right = gr.Image(width=512, label = "Model B", show_copy_button=True,)
+
+        with gr.Row():
+            slow_warning = gr.Markdown("", elem_id="notice_markdown")
+
+        with gr.Row(elem_id="Geometry Quality"):
+            geo_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            geo_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            geo_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            geo_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+        with gr.Row(elem_id="Texture Quality"):
+            text_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            text_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            text_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            text_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+        
+        with gr.Row(elem_id="Alignment Quality"):
+            align_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            align_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            align_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            align_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+    with gr.Row():
+        textbox = gr.Textbox(
+            show_label=False,
+            placeholder="👉 Enter your prompt or Sample a random prompt, and press ENTER",
+            container=True,
+            elem_id="input_box",
+        )
+        sample_btn = gr.Button(value="🎲 Sample", variant="primary", scale=0)
+        send_btn = gr.Button(value="📤 Send", variant="primary", scale=0)
+
+    with gr.Row():
+        clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+        regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+        share_btn = gr.Button(value="📷  Share")
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+    geo_btn_list = [geo_leftvote_btn, geo_rightvote_btn, geo_tie_btn, geo_bothbad_btn]
+    text_btn_list = [text_leftvote_btn, text_rightvote_btn, text_tie_btn, text_bothbad_btn]
+    align_btn_list = [align_leftvote_btn, align_rightvote_btn, align_tie_btn, align_bothbad_btn]
+    states = [state_0, state_1]
+    model_selectors = [model_selector_left, model_selector_right]
+    results = [normal_left, rgb_left, normal_right, rgb_right]
+
+    model_selector_left.change(
+        clear_history_side_by_side, 
+        None, 
+        states + [textbox] + results, 
+        api_name="model_selector_left"
+    )
+    model_selector_right.change(
+        clear_history_side_by_side, 
+        None, 
+        states + [textbox] + results, 
+        api_name="model_selector_right"
+    )
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        leftvote_btn, rightvote_btn, tie_btn, bothbad_btn = btn_list
+
+        leftvote_btn.click(
+            leftvote_last_response,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        rightvote_btn.click(
+            rightvote_last_response,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        tie_btn.click(
+            tievote_last_response,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        bothbad_btn.click(
+            bothbad_vote_last_response,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+
+    sample_btn.click(
+        sample_prompt,
+        states + model_selectors + [prompt_list],
+        states + [textbox],
+        api_name="sample_btn_named"
+    )
+
+    textbox.then(
+        gen_func,
+        states + [textbox] + model_selectors + [prompt_list],
+        states + results + model_selectors,
+        api_name="submit_btn_named"
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        gen_func,
+        states + [textbox] + model_selectors + [prompt_list],
+        states + results + model_selectors,
+        api_name="send_btn_named"
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_history_side_by_side_anony, 
+        None, 
+        states + [textbox] + results + model_selectors,
+        api_name="clear_btn_named"
+    ).then(
+        disable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        gen_func,
+        states + [textbox] + model_selectors + [prompt_list],
+        states + results + model_selectors,
+        api_name="regenerate_btn_named"
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    share_btn.click(
+        share_click,
+        states + model_selectors,
+        [],
+        js=share_js
+    )
+

serve/gradio_web_t2i_single.py

@@ -0,0 +1,159 @@
+import json
+from functools import partial
+
+from .utils import *
+from .vote_utils import (
+    upvote_last_response_t2s as upvote_last_response,
+    downvote_last_response_t2s as downvote_last_response,
+    flag_last_response_t2s as flag_last_response,
+)
+from .inference import(
+    sample_prompt,
+    generate_t2s
+)
+from .constants import TEXT_PROMPT_PATH
+
+with open(TEXT_PROMPT_PATH, 'r') as f:
+    prompt_list = json.load(f)
+
+def build_single_model_ui(models):
+    notice_markdown = """
+# 🏔️ Play with Image Generation Models
+{promotion}
+
+## 🤖 Choose any model to generate
+
+"""
+    model_list = models.get_t2s_models()
+    gen_func = partial(generate_t2s, models.inference_parallel, models.render_parallel)
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+
+    with gr.Row(elem_id="model_selector_row"):
+        model_selector = gr.Dropdown(
+            choices=model_list,
+            value=model_list[0] if len(model_list) > 0 else "",
+            interactive=True,
+            show_label=False
+        )
+
+    with gr.Row():
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+
+    with gr.Row():
+        textbox = gr.Textbox(
+            show_label=False,
+            placeholder="👉 Enter your prompt or Sample a random prompt, and press ENTER",
+            container=True,
+            elem_id="input_box",
+        )
+        sample_btn = gr.Button(value="🎲 Sample", variant="primary", scale=0)
+        send_btn = gr.Button(value="📤 Send", variant="primary", scale=0)
+
+    with gr.Row():
+        normal = gr.Image(width=512, label = "Normal", show_copy_button=True)
+        rgb = gr.Image(width=512, label = "RGB", show_copy_button=True,)
+
+    with gr.Row():
+        clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+        regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+
+    with gr.Row(elem_id="Geometry Quality"):
+        geo_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        geo_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        geo_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+
+    with gr.Row(elem_id="Texture Quality"):
+        text_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        text_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        text_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+    
+    with gr.Row(elem_id="Alignment Quality"):
+        align_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        align_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        align_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+    state = gr.State()
+    geo_btn_list = [geo_upvote_btn, geo_downvote_btn, geo_flag_btn]
+    text_btn_list = [text_upvote_btn, text_downvote_btn, text_flag_btn]
+    align_btn_list = [align_upvote_btn, align_downvote_btn, align_flag_btn]
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        upvote_btn, downvote_btn, flag_btn = btn_list
+
+        upvote_btn.click(
+            upvote_last_response,
+            [state, model_selector],
+            [textbox] + btn_list
+        )
+            
+        downvote_btn.click(
+            downvote_last_response,
+            [state, model_selector],
+            [textbox] + btn_list
+        )
+        flag_btn.click(
+            flag_last_response,
+            [state, model_selector],
+            [textbox] + btn_list
+        )
+
+    sample_btn.click(
+        sample_prompt,
+         [state, model_selector, prompt_list],
+        state + [textbox],
+        api_name="sample_btn_single"
+    )
+
+    textbox.submit(
+        gen_func,
+        [state, textbox, model_selector, prompt_list],
+        [state, normal, rgb],
+        api_name="submit_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        gen_func,
+        [state, textbox, model_selector, prompt_list],
+        [state, normal, rgb],
+        api_name="send_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_history, 
+        None, 
+        [state, textbox, normal, rgb], 
+        api_name="clear_history_single",
+        show_progress="full"
+    ).then(
+        disable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        gen_func,
+        [state, textbox, model_selector, prompt_list],
+        [state, normal, rgb],
+        api_name="regenerate_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+

serve/gradio_web_t2s.py

@@ -0,0 +1,626 @@
+import json
+from functools import partial
+
+from .utils import *
+from .vote_utils import (
+    upvote_last_response_t2s as upvote_last_response,
+    downvote_last_response_t2s as downvote_last_response,
+    flag_last_response_t2s as flag_last_response,
+    leftvote_last_response_t2s_anony as leftvote_last_response_anony,
+    rightvote_last_response_t2s_anony as rightvote_last_response_anony,
+    tievote_last_response_t2s_anony as tievote_last_response_anony,
+    bothbad_vote_last_response_t2s_anony as bothbad_vote_last_response_anony,
+    leftvote_last_response_t2s_named as leftvote_last_response_named,
+    rightvote_last_response_t2s_named as rightvote_last_response_named,
+    tievote_last_response_t2s_named as tievote_last_response_named,
+    bothbad_vote_last_response_t2s_named as bothbad_vote_last_response_named,
+    share_click_t2s_multi as share_click,
+    share_js
+)
+from .inference import(
+    sample_t2s_model as sample_model,
+    sample_prompt,
+    sample_prompt_side_by_side,
+    generate_t2s,
+    generate_t2s_multi,
+    generate_t2s_multi_annoy
+)
+
+
+def build_t2s_ui_side_by_side_anony(models):
+    notice_markdown = """
+# ⚔️  GenAI-Arena ⚔️ : Benchmarking Text-to-3D generative models 
+## 📜 Rules
+- Input prompt to two anonymous models in same area and vote for the better one!
+- When the results are ready, click the button below to vote.
+- Vote won't be counted if model identity is revealed during conversation.
+- Click "Clear" to start a new round.
+
+## 🏆 Arena Elo 
+Find out who is the 🥇conditional image generation models! More models are going to be supported.
+
+## 👇 Generating now!
+
+"""
+    model_list = models.get_t2s_models()
+    gen_func = partial(generate_t2s_multi_annoy, models.inference_parallel, models.render_parallel)
+
+
+    state_0 = gr.State()
+    state_1 = gr.State()
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+    model_str = gr.Markdown(str(model_list), visible=False, elem_id="model list string")
+
+    with gr.Group(elem_id="share-region-anony"):
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+        with gr.Row():
+            with gr.Column():
+                normal_left = gr.Image(width=512, label = "Model A", show_download_button=True)
+                rgb_left = gr.Image(width=512, label = "Model A", show_download_button=True)
+            with gr.Column():
+                normal_right = gr.Image(width=512, label = "Model B", show_download_button=True,)
+                rgb_right = gr.Image(width=512, label = "Model B", show_download_button=True,)
+
+        with gr.Row():
+            with gr.Column():
+                model_selector_left =gr.Markdown("", visible=False)
+            with gr.Column():
+                model_selector_right = gr.Markdown("", visible=False)
+        with gr.Row():
+            slow_warning = gr.Markdown("", elem_id="notice_markdown")
+
+        with gr.Row(elem_id="Geometry Quality"):
+            geo_md = gr.Markdown("Geometry Quality: ", visible=False, elem_id="evaldim_markdown")
+            geo_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            geo_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            geo_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            geo_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+        with gr.Row(elem_id="Texture Quality"):
+            text_md = gr.Markdown("Texture Quality: ", visible=False, elem_id="evaldim_markdown")
+            text_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            text_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            text_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            text_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+        
+        with gr.Row(elem_id="Alignment Quality"):
+            align_md = gr.Markdown("Alignment Quality: ", visible=False, elem_id="evaldim_markdown")
+            align_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            align_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            align_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            align_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+    with gr.Row():
+        textbox = gr.Textbox(
+            show_label=False,
+            placeholder="👉 Enter your prompt or Sample a random prompt, and press ENTER",
+            container=True,
+            elem_id="input_box",
+        )
+        sample_btn = gr.Button(value="🎲 Sample", variant="primary", scale=0)
+        send_btn = gr.Button(value="📤 Send", variant="primary", scale=0)
+
+    with gr.Row():
+        clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+        regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+        share_btn = gr.Button(value="📷  Share")
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+    geo_btn_list = [geo_leftvote_btn, geo_rightvote_btn, geo_tie_btn, geo_bothbad_btn]
+    text_btn_list = [text_leftvote_btn, text_rightvote_btn, text_tie_btn, text_bothbad_btn]
+    align_btn_list = [align_leftvote_btn, align_rightvote_btn, align_tie_btn, align_bothbad_btn]
+    states = [state_0, state_1]
+    model_selectors = [model_selector_left, model_selector_right]
+    results = [normal_left, rgb_left, normal_right, rgb_right]
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        leftvote_btn, rightvote_btn, tie_btn, bothbad_btn = btn_list
+
+        leftvote_btn.click(
+            leftvote_last_response_anony,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        rightvote_btn.click(
+            rightvote_last_response_anony,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        tie_btn.click(
+            tievote_last_response_anony,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+        bothbad_btn.click(
+            bothbad_vote_last_response_anony,
+            states + model_selectors,
+            [textbox] + btn_list + model_selectors
+        )
+
+    sample_btn.click(
+        sample_prompt_side_by_side,
+        states + model_selectors,
+        states + [textbox],
+        api_name="sample_btn_anony"
+    )
+
+    textbox.submit(
+        sample_model,
+        states + [model_str],
+        states + model_selectors
+    ).then(
+        gen_func,
+        states + [textbox] + model_selectors,
+        states + results + model_selectors,
+        api_name="submit_btn_anony"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        sample_model,
+        states + [model_str],
+        states + model_selectors
+    ).then(
+        gen_func,
+        states + [textbox] + model_selectors,
+        states + results + model_selectors,
+        api_name="send_btn_anony"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_t2s_history_side_by_side_anony, 
+        None, 
+        states + [textbox] + results + model_selectors,
+        api_name="clear_btn_anony"
+    ).then(
+        disable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        disable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        sample_model,
+        states + [model_str],
+        states + model_selectors
+    ).then(
+        gen_func,
+        states + [textbox] + model_selectors,
+        states + results + model_selectors,
+        api_name="regenerate_btn_anony"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    share_btn.click(
+        share_click,
+        states + model_selectors,
+        [],
+        js=share_js
+    )
+
+
+def build_t2s_ui_side_by_side_named(models):
+    notice_markdown = """
+# ⚔️  GenAI-Arena ⚔️ : Benchmarking Text-to-3D generative models 
+## 📜 Rules
+- Generate with any two selected models side-by-side and vote!
+- Sample or Input prompt you want to generate.
+- Click "Send" to submit the prompt.
+- Click "Clear" to start a new round.
+
+## 🏆 Arena Elo 
+Find out who is the 🥇conditional image generation models! More models are going to be supported.
+
+## 👇 Generating now!
+
+"""
+    model_list = models.get_t2s_models()
+    gen_func = partial(generate_t2s_multi, models.inference_parallel, models.render_parallel)
+
+    state_0 = gr.State()
+    state_1 = gr.State()
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+
+    with gr.Group(elem_id="share-region-named"):
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+            
+        with gr.Row():
+            with gr.Column():
+                model_selector_left = gr.Dropdown(
+                    choices=model_list,
+                    value=model_list[0] if len(model_list) > 0 else "",
+                    interactive=True,
+                    show_label=False,
+                    container=False,
+                    )
+            with gr.Column():
+                model_selector_right = gr.Dropdown(
+                    choices=model_list,
+                    value=model_list[1] if len(model_list) > 1 else "",
+                    interactive=True,
+                    show_label=False,
+                    container=False,
+                    )
+
+        with gr.Row():
+            with gr.Column():
+                normal_left = gr.Image(width=512, label = "Model A", show_download_button=True)
+                rgb_left = gr.Image(width=512, label = "Model A", show_download_button=True)
+            with gr.Column():
+                normal_right = gr.Image(width=512, label = "Model B", show_download_button=True,)
+                rgb_right = gr.Image(width=512, label = "Model B", show_download_button=True,)
+
+        with gr.Row():
+            slow_warning = gr.Markdown("", elem_id="notice_markdown")
+
+        with gr.Row(elem_id="Geometry Quality"):
+            geo_md = gr.Markdown("Geometry Quality: ", visible=False, elem_id="evaldim_markdown")
+            geo_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            geo_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            geo_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            geo_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+        with gr.Row(elem_id="Texture Quality"):
+            text_md = gr.Markdown("Texture Quality: ", visible=False, elem_id="evaldim_markdown")
+            text_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            text_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            text_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            text_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+        
+        with gr.Row(elem_id="Alignment Quality"):
+            align_md = gr.Markdown("Alignment Quality: ", visible=False, elem_id="evaldim_markdown")
+            align_leftvote_btn = gr.Button(
+                value="👈  A is better", visible=False, interactive=False
+            )
+            align_rightvote_btn = gr.Button(
+                value="👉  B is better", visible=False, interactive=False
+            )
+            align_tie_btn = gr.Button(value="🤝  Tie", visible=False, interactive=False)
+            align_bothbad_btn = gr.Button(
+                value="👎  Both are bad", visible=False, interactive=False
+            )
+
+    with gr.Row():
+        textbox = gr.Textbox(
+            show_label=False,
+            placeholder="👉 Enter your prompt or Sample a random prompt, and press ENTER",
+            container=True,
+            elem_id="input_box",
+        )
+        sample_btn = gr.Button(value="🎲 Sample", variant="primary", scale=0)
+        send_btn = gr.Button(value="📤 Send", variant="primary", scale=0)
+
+    with gr.Row():
+        clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+        regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+        share_btn = gr.Button(value="📷  Share")
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+    geo_btn_list = [geo_leftvote_btn, geo_rightvote_btn, geo_tie_btn, geo_bothbad_btn]
+    text_btn_list = [text_leftvote_btn, text_rightvote_btn, text_tie_btn, text_bothbad_btn]
+    align_btn_list = [align_leftvote_btn, align_rightvote_btn, align_tie_btn, align_bothbad_btn]
+    states = [state_0, state_1]
+    model_selectors = [model_selector_left, model_selector_right]
+    results = [normal_left, rgb_left, normal_right, rgb_right]
+
+    model_selector_left.change(
+        clear_t2s_history_side_by_side, 
+        None, 
+        states + [textbox] + results, 
+        api_name="model_selector_left"
+    )
+    model_selector_right.change(
+        clear_t2s_history_side_by_side, 
+        None, 
+        states + [textbox] + results, 
+        api_name="model_selector_right"
+    )
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        leftvote_btn, rightvote_btn, tie_btn, bothbad_btn = btn_list
+
+        leftvote_btn.click(
+            leftvote_last_response_named,
+            states + model_selectors,
+            [textbox] + btn_list
+        )
+        rightvote_btn.click(
+            rightvote_last_response_named,
+            states + model_selectors,
+            [textbox] + btn_list
+        )
+        tie_btn.click(
+            tievote_last_response_named,
+            states + model_selectors,
+            [textbox] + btn_list
+        )
+        bothbad_btn.click(
+            bothbad_vote_last_response_named,
+            states + model_selectors,
+            [textbox] + btn_list
+        )
+
+    sample_btn.click(
+        sample_prompt_side_by_side,
+        states + model_selectors,
+        states + [textbox],
+        api_name="sample_btn_named"
+    )
+
+    textbox.submit(
+        gen_func,
+        states + [textbox] + model_selectors,
+        states + results + model_selectors,
+        api_name="submit_btn_named"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        gen_func,
+        states + [textbox] + model_selectors,
+        states + results + model_selectors,
+        api_name="send_btn_named"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_t2s_history_side_by_side, 
+        None, 
+        states + [textbox] + results,
+        api_name="clear_btn_named"
+    ).then(
+        disable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        disable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        gen_func,
+        states + [textbox] + model_selectors,
+        states + results + model_selectors,
+        api_name="regenerate_btn_named"
+    ).then(
+        enable_mds,
+        None,
+        [geo_md, text_md, align_md]
+    ).then(
+        enable_buttons_side_by_side,
+        None,
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    share_btn.click(
+        share_click,
+        states + model_selectors,
+        [],
+        js=share_js
+    )
+
+
+def build_t2s_ui_single_model(models):
+    notice_markdown = """
+# 🏔️ Play with Image Generation Models
+{promotion}
+
+## 🤖 Choose any model to generate
+
+"""
+    model_list = models.get_t2s_models()
+    gen_func = partial(generate_t2s, models.inference_parallel, models.render_parallel)
+
+    gr.Markdown(notice_markdown, elem_id="notice_markdown")
+
+    with gr.Row():
+        with gr.Accordion("🔍 Expand to see all Arena players", open=False):
+            model_description_md = get_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+
+    with gr.Row(elem_id="model_selector_row"):
+        model_selector = gr.Dropdown(
+            choices=model_list,
+            value=model_list[0] if len(model_list) > 0 else "",
+            interactive=True,
+            show_label=False
+        )
+
+    with gr.Row():
+        normal = gr.Image(width=512, label = "Normal", show_download_button=True)
+        rgb = gr.Image(width=512, label = "RGB", show_download_button=True,)
+
+    with gr.Row():
+        textbox = gr.Textbox(
+            show_label=False,
+            placeholder="👉 Enter your prompt or Sample a random prompt, and press ENTER",
+            container=True,
+            elem_id="input_box",
+        )
+        sample_btn = gr.Button(value="🎲 Sample", variant="primary", scale=0)
+        send_btn = gr.Button(value="📤 Send", variant="primary", scale=0)
+
+    with gr.Row():
+        clear_btn = gr.Button(value="🗑️ Clear", interactive=False)
+        regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+
+    
+    with gr.Row(elem_id="Geometry Quality"):
+        gr.Markdown("Geometry Quality: ", elem_id="evaldim_markdown")
+        geo_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        geo_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        geo_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+
+    
+    with gr.Row(elem_id="Texture Quality"):
+        gr.Markdown("Texture Quality: ", elem_id="evaldim_markdown")
+        text_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        text_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        text_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+    
+    with gr.Row(elem_id="Alignment Quality"):
+        gr.Markdown("Alignment Quality: ", elem_id="evaldim_markdown")
+        align_upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+        align_downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+        align_flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+
+    gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+
+    state = gr.State()
+    geo_btn_list = [geo_upvote_btn, geo_downvote_btn, geo_flag_btn]
+    text_btn_list = [text_upvote_btn, text_downvote_btn, text_flag_btn]
+    align_btn_list = [align_upvote_btn, align_downvote_btn, align_flag_btn]
+
+    for btn_list in [geo_btn_list, text_btn_list, align_btn_list]:
+        upvote_btn, downvote_btn, flag_btn = btn_list
+
+        upvote_btn.click(
+            upvote_last_response,
+            [state, model_selector],
+            [textbox] + btn_list
+        )
+            
+        downvote_btn.click(
+            downvote_last_response,
+            [state, model_selector],
+            [textbox] + btn_list
+        )
+        flag_btn.click(
+            flag_last_response,
+            [state, model_selector],
+            [textbox] + btn_list
+        )
+
+    sample_btn.click(
+        sample_prompt,
+        [state, model_selector],
+        [state, textbox],
+        api_name="sample_btn_single"
+    )
+
+    textbox.submit(
+        gen_func,
+        [state, textbox, model_selector],
+        [state, normal, rgb],
+        api_name="submit_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    send_btn.click(
+        gen_func,
+        [state, textbox, model_selector],
+        [state, normal, rgb],
+        api_name="send_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    clear_btn.click(
+        clear_t2s_history, 
+        None, 
+        [state, textbox, normal, rgb], 
+        api_name="clear_history_single",
+        show_progress="full"
+    ).then(
+        disable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+
+    regenerate_btn.click(
+        gen_func,
+        [state, textbox, model_selector],
+        [state, normal, rgb],
+        api_name="regenerate_btn_single",
+        show_progress = "full"
+    ).then(
+        enable_buttons, 
+        None,  
+        geo_btn_list + text_btn_list + align_btn_list + [regenerate_btn, clear_btn]
+    )
+

serve/inference.py

@@ -0,0 +1,730 @@
+## All Generation Gradio Interface
+import uuid
+import time
+
+from .utils import *
+from .vote_utils import t2s_logger, t2s_multi_logger, i2s_logger, i2s_multi_logger
+from .constants import IMAGE_DIR, OFFLINE_DIR, TEXT_PROMPT_PATH
+
+with open(TEXT_PROMPT_PATH, 'r') as f:
+    prompt_list = json.load(f)
+
+
+class State:
+    def __init__(self, 
+                 model_name, i2s_mode=False, offline=False, 
+                 prompt=None, image=None, offline_idx=None, 
+                 normal_video=None , rgb_video=None):
+        self.conv_id = uuid.uuid4().hex
+        self.model_name = model_name
+        self.i2s_mode = i2s_mode
+        self.offline = offline
+        
+        self.prompt = prompt
+        self.image = image
+        self.offline_idx = offline_idx
+        # self.output = None
+        self.normal_video = normal_video
+        self.rgb_video = rgb_video
+
+    def dict(self):
+        base = {
+            "conv_id": self.conv_id,
+            "model_name": self.model_name,
+            "i2s_mode": self.i2s_mode,
+            "offline": self.offline,
+            "prompt": self.prompt
+            }
+        if not self.offline and not self.offline_idx:
+            base['offline_idx'] = self.offline_idx
+        return base
+
+# class StateI2S:
+#     def __init__(self, model_name):
+#         self.conv_id = uuid.uuid4().hex
+#         self.model_name = model_name
+#         self.image = None
+#         self.output = None
+
+#     def dict(self):
+#         base = {
+#             "conv_id": self.conv_id,
+#             "model_name": self.model_name,
+
+#             }
+#         return base
+
+def sample_t2s_model(state_0, state_1, model_list):
+    model_name_0, model_name_1 = random.sample(eval(model_list), 2)
+
+    if state_0 is None:
+        state_0 = State(model_name_0, i2s_mode=False)
+    if state_1 is None:
+        state_1 = State(model_name_1, i2s_mode=False)
+
+    state_0.model_name = model_name_0
+    state_0.i2s_mode = False
+    state_1.model_name = model_name_1
+    state_1.i2s_mode = False
+    return state_0, state_1, model_name_0, model_name_1
+
+def sample_i2s_model(state_0, state_1, model_list):
+    model_name_0, model_name_1 = random.sample(eval(model_list), 2)
+
+    if state_0 is None:
+        state_0 = State(model_name_0, i2s_mode=True)
+    if state_1 is None:
+        state_1 = State(model_name_1, i2s_mode=True)
+
+    state_0.model_name = model_name_0
+    state_0.i2s_mode = True
+    state_1.model_name = model_name_1
+    state_1.i2s_mode = True
+    return state_0, state_1, model_name_0, model_name_1
+
+def sample_prompt(state, model_name):
+    if state is None:
+        state = State(model_name)
+
+    idx = random.randint(0, len(prompt_list)-1)
+    prompt = prompt_list[idx]
+
+    state.model_name = model_name
+    state.prompt = prompt
+    return state, prompt
+
+def sample_prompt_side_by_side(state_0, state_1, model_name_0, model_name_1):
+    if state_0 is None:
+        state_0 = State(model_name_0)
+    if state_1 is None:
+        state_1 = State(model_name_1)
+
+    idx = random.randint(0, len(prompt_list)-1)
+    prompt = prompt_list[idx]
+
+    state_0.offline, state_1.offline = True, True
+    state_0.offline_idx, state_1.offline_idx = idx, idx
+    state_0.prompt, state_1.prompt = prompt, prompt
+    return state_0, state_1, prompt
+
+def sample_image(state, model_name):
+    if state is None:
+        state = State(model_name)
+
+    idx = random.randint(0, len(prompt_list)-1)
+    prompt = prompt_list[idx]
+
+    state.model_name = model_name
+    state.prompt = prompt
+    return state, prompt
+
+def sample_image_side_by_side(state_0, state_1, model_name_0, model_name_1):
+    if state_0 is None:
+        state_0 = State(model_name_0)
+    if state_1 is None:
+        state_1 = State(model_name_1)
+
+    idx = random.randint(0, len(prompt_list)-1)
+    prompt = prompt_list[idx]
+
+    state_0.offline, state_1.offline = True, True
+    state_0.offline_idx, state_1.offline_idx = idx, idx
+    state_0.prompt, state_1.prompt = prompt, prompt
+    return state_0, state_1, prompt
+
+def generate_t2s(gen_func, render_func, 
+                 state, 
+                 text, 
+                 model_name, 
+                 request: gr.Request):
+    if not text:
+        raise gr.Warning("Prompt cannot be empty.")
+    if not model_name:
+        raise gr.Warning("Model name cannot be empty.")
+    
+    if state is None:
+        state = State(model_name, i2s_mode=False, offline=False)
+
+    ip = get_ip(request)
+    t2s_logger.info(f"generate. ip: {ip}")
+
+    state.model_name = model_name
+    state.prompt = text
+    try:
+        idx = prompt_list.index(text)
+        state.offline = True
+        state.offline_idx = idx
+    except:
+        state.offline = False
+        state.offline_idx = None
+
+    if not state.offline and not state.offline_idx:
+        start_time = time.time()
+        normal_video = os.path.join(OFFLINE_DIR, "text2shape", model_name, "normal", f"{state.offline_idx}.mp4")
+        rgb_video = os.path.join(OFFLINE_DIR, "text2shape", model_name, "rgb", f"{state.offline_idx}.mp4")
+        
+        state.normal_video = normal_video
+        state.rgb_video = rgb_video
+        yield state, normal_video, rgb_video
+
+        # logger.info(f"===output===: {output}")
+        data = {
+            "ip": ip,
+            "model": model_name,
+            "type": "offline",
+            "gen_params": {},
+            "state": state.dict(),
+            "start": round(start_time, 4),
+        }
+    else:
+        start_time = time.time()
+        shape = gen_func(text, model_name)
+        generate_time = time.time() - start_time
+
+        normal_video, rgb_video = render_func(shape, model_name)
+        finish_time = time.time()
+        render_time = finish_time - start_time - generate_time
+
+        state.normal_video = normal_video
+        state.rgb_video = rgb_video        
+        yield state, normal_video, rgb_video
+
+        # logger.info(f"===output===: {output}")
+        data = {
+            "ip": ip,
+            "model": model_name,
+            "type": "online",
+            "gen_params": {},
+            "state": state.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+
+    with open(get_conv_log_filename(), "a") as fout:
+        fout.write(json.dumps(data) + "\n")
+    append_json_item_on_log_server(data, get_conv_log_filename())
+        
+    # output_file = f'{IMAGE_DIR}/text2shape/{state.conv_id}.png'
+    # os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    # with open(output_file, 'w') as f:
+    #     state.output.save(f, 'PNG')
+    # save_image_file_on_log_server(output_file)
+        
+def generate_t2s_multi(gen_func, render_func, 
+                       state_0, state_1,
+                       text, 
+                       model_name_0, model_name_1, 
+                       request: gr.Request):
+    if not text:
+        raise gr.Warning("Prompt cannot be empty.")
+    if not model_name_0:
+        raise gr.Warning("Model name A cannot be empty.")
+    if not model_name_1:
+        raise gr.Warning("Model name B cannot be empty.")
+    
+    if state_0 is None:
+        state_0 = State(model_name_0, i2s_mode=False, offline=False)
+    if state_1 is None:
+        state_1 = State(model_name_1, i2s_mode=False, offline=False)
+    
+    ip = get_ip(request)
+    t2s_multi_logger.info(f"generate. ip: {ip}")
+    
+    state_0.model_name, state_1.model_name = model_name_0, model_name_1
+    state_0.prompt, state_1.prompt = text, text
+    try:
+        idx = prompt_list.index(text)
+        state_0.offline, state_1.offline = True, True
+        state_0.offline_idx, state_1.offline_idx = idx, idx
+    except:
+        state_0.offline, state_1.offline = False, False
+        state_0.offline_idx, state_1.offline_idx = None, None
+
+    if not state_0.offline and not state_0.offline_idx:
+        start_time = time.time()
+        normal_video_0 = os.path.join(OFFLINE_DIR, "text2shape", model_name_0, "normal", f"{state_0.offline_idx}.mp4")
+        rgb_video_0 = os.path.join(OFFLINE_DIR, "text2shape", model_name_0, "rgb", f"{state_0.offline_idx}.mp4")
+        normal_video_1 = os.path.join(OFFLINE_DIR, "text2shape", model_name_1, "normal", f"{state_1.offline_idx}.mp4")
+        rgb_video_1 = os.path.join(OFFLINE_DIR, "text2shape", model_name_1, "rgb", f"{state_1.offline_idx}.mp4")
+        
+        state_0.normal_video = normal_video_0
+        state_0.rgb_video = rgb_video_0
+        state_1.normal_video = normal_video_1
+        state_1.rgb_video = rgb_video_1
+        yield state_0, state_1, normal_video_0, rgb_video_0, normal_video_0, rgb_video_1
+
+        # logger.info(f"===output===: {output}")
+        data_0 = {
+            "ip": get_ip(request),
+            "model": model_name_0,
+            "type": "offline",
+            "gen_params": {},
+            "state": state_0.dict(),
+            "start": round(start_time, 4),
+        }
+        data_1 = {
+            "ip": get_ip(request),
+            "model": model_name_1,
+            "type": "offline",
+            "gen_params": {},
+            "state": state_1.dict(),
+            "start": round(start_time, 4),
+        }
+    else:
+        start_time = time.time()
+        shape_0, shape_1 = gen_func(text, model_name_0, model_name_1)
+        generate_time = time.time() - start_time
+
+        normal_video_0, rgb_video_0, normal_video_1, rgb_video_1 = render_func(shape_0, model_name_0,
+                                                                               shape_1, model_name_1)
+        finish_time = time.time()
+        render_time = finish_time - start_time - generate_time
+
+        state_0.normal_video = normal_video_0
+        state_0.rgb_video = rgb_video_0
+        state_1.normal_video = normal_video_1
+        state_1.rgb_video = rgb_video_1
+        yield state_0, state_1, normal_video_0, rgb_video_0, normal_video_0, rgb_video_1
+
+        # logger.info(f"===output===: {output}")
+        data_0 = {
+            "ip": get_ip(request),
+            "model": model_name_0,
+            "type": "online",
+            "gen_params": {},
+            "state": state_0.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+        data_1 = {
+            "ip": get_ip(request),
+            "model": model_name_1,
+            "type": "online",
+            "gen_params": {},
+            "state": state_1.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+    
+    with open(get_conv_log_filename(), "a") as fout:
+        fout.write(json.dumps(data_0) + "\n")
+        fout.write(json.dumps(data_1) + "\n")
+    append_json_item_on_log_server(data_0, get_conv_log_filename())
+    append_json_item_on_log_server(data_1, get_conv_log_filename())
+
+    # for i, state in enumerate([state_0, state_1]):
+    #     output_file = f'{IMAGE_DIR}/text2shape/{state.conv_id}.png'
+    #     os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    #     with open(output_file, 'w') as f:
+    #         state.output.save(f, 'PNG')
+    #     save_image_file_on_log_server(output_file)
+            
+def generate_t2s_multi_annoy(gen_func, render_func,
+                             state_0, state_1, 
+                             text, 
+                             model_name_0, model_name_1, 
+                             request: gr.Request):
+    if not text:
+        raise gr.Warning("Prompt cannot be empty.")
+    if state_0 is None:
+        state_0 = State(model_name_0, i2s_mode=False, offline=False)
+    if state_1 is None:
+        state_1 = State(model_name_1, i2s_mode=False, offline=False)
+    
+    ip = get_ip(request)
+    t2s_multi_logger.info(f"generate. ip: {ip}")
+
+    state_0.model_name, state_1.model_name = model_name_0, model_name_1
+    state_0.prompt, state_1.prompt = text, text
+    try:
+        idx = prompt_list.index(text)
+        state_0.offline, state_1.offline = True, True
+        state_0.offline_idx, state_1.offline_idx = idx, idx
+    except:
+        state_0.offline, state_1.offline = False, False
+        state_0.offline_idx, state_1.offline_idx = None, None
+
+    if not state_0.offline and not state_0.offline_idx:
+        start_time = time.time()
+        normal_video_0 = os.path.join(OFFLINE_DIR, "text2shape", model_name_0, "normal", f"{state_0.offline_idx}.mp4")
+        rgb_video_0 = os.path.join(OFFLINE_DIR, "text2shape", model_name_0, "rgb", f"{state_0.offline_idx}.mp4")
+        normal_video_1 = os.path.join(OFFLINE_DIR, "text2shape", model_name_1, "normal", f"{state_1.offline_idx}.mp4")
+        rgb_video_1 = os.path.join(OFFLINE_DIR, "text2shape", model_name_1, "rgb", f"{state_1.offline_idx}.mp4")
+        
+        state_0.normal_video = normal_video_0
+        state_0.rgb_video = rgb_video_0
+        state_1.normal_video = normal_video_1
+        state_1.rgb_video = rgb_video_1
+        yield state_0, state_1, normal_video_0, rgb_video_0, normal_video_1, rgb_video_1, \
+            gr.Markdown(f"### Model A: {model_name_0}"), gr.Markdown(f"### Model B: {model_name_1}")
+
+        # logger.info(f"===output===: {output}")
+        data_0 = {
+            "ip": get_ip(request),
+            "model": model_name_0,
+            "type": "offline",
+            "gen_params": {},
+            "state": state_0.dict(),
+            "start": round(start_time, 4),
+        }
+        data_1 = {
+            "ip": get_ip(request),
+            "model": model_name_1,
+            "type": "offline",
+            "gen_params": {},
+            "state": state_1.dict(),
+            "start": round(start_time, 4),
+        }
+    else:
+        start_time = time.time()
+        shape_0, shape_1 = gen_func(text, model_name_0, model_name_1)
+        generate_time = time.time() - start_time
+
+        normal_video_0, rgb_video_0, normal_video_1, rgb_video_1 = render_func(shape_0, model_name_0,
+                                                                               shape_1, model_name_1)
+        finish_time = time.time()
+        render_time = finish_time - start_time - generate_time
+
+        state_0.normal_video = normal_video_0
+        state_0.rgb_video = rgb_video_0
+        state_1.normal_video = normal_video_1
+        state_1.rgb_video = rgb_video_1
+        yield state_0, state_1, normal_video_0, rgb_video_0, normal_video_0, rgb_video_1, \
+            gr.Markdown(f"### Model A: {model_name_0}"), gr.Markdown(f"### Model B: {model_name_1}")
+
+        # logger.info(f"===output===: {output}")
+        data_0 = {
+            "ip": get_ip(request),
+            "model": model_name_0,
+            "type": "online",
+            "gen_params": {},
+            "state": state_0.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+        data_1 = {
+            "ip": get_ip(request),
+            "model": model_name_1,
+            "type": "online",
+            "gen_params": {},
+            "state": state_1.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+    
+    with open(get_conv_log_filename(), "a") as fout:
+        fout.write(json.dumps(data_0) + "\n")
+        fout.write(json.dumps(data_1) + "\n")
+    append_json_item_on_log_server(data_0, get_conv_log_filename())
+    append_json_item_on_log_server(data_1, get_conv_log_filename())
+
+    # for i, state in enumerate([state_0, state_1]):
+    #     output_file = f'{IMAGE_DIR}/text2shape/{state.conv_id}.png'
+    #     os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    #     with open(output_file, 'w') as f:
+    #         state.output.save(f, 'PNG')
+    #     save_image_file_on_log_server(output_file)
+            
+            
+def generate_i2s(gen_func, render_func, state, image, model_name, request: gr.Request):
+    if not image:
+        raise gr.Warning("Image cannot be empty.")
+    if not model_name:
+        raise gr.Warning("Model name cannot be empty.")
+    if state is None:
+        state = State(model_name, i2s_mode=True, offline=False)
+    
+    ip = get_ip(request)
+    t2s_logger.info(f"generate. ip: {ip}")
+
+    state.model_name = model_name
+    state.image = image
+
+    if not state.offline and not state.offline_idx:
+        start_time = time.time()
+        normal_video = os.path.join(OFFLINE_DIR, "image2shape", model_name, "normal", f"{state.offline_idx}.mp4")
+        rgb_video = os.path.join(OFFLINE_DIR, "image2shape", model_name, "rgb", f"{state.offline_idx}.mp4")
+        
+        state.normal_video = normal_video
+        state.rgb_video = rgb_video
+        yield state, normal_video, rgb_video
+
+        # logger.info(f"===output===: {output}")
+        data = {
+            "ip": ip,
+            "model": model_name,
+            "type": "offline",
+            "gen_params": {},
+            "state": state.dict(),
+            "start": round(start_time, 4),
+        }
+    else:
+        start_time = time.time()
+        shape = gen_func(image, model_name)
+        generate_time = time.time() - start_time
+
+        normal_video, rgb_video = render_func(shape, model_name)
+        finish_time = time.time()
+        render_time = finish_time - start_time - generate_time
+
+        state.normal_video = normal_video
+        state.rgb_video = rgb_video        
+        yield state, normal_video, rgb_video
+
+        # logger.info(f"===output===: {output}")
+        data = {
+            "ip": ip,
+            "model": model_name,
+            "type": "online",
+            "gen_params": {},
+            "state": state.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+
+    with open(get_conv_log_filename(), "a") as fout:
+        fout.write(json.dumps(data) + "\n")
+    append_json_item_on_log_server(data, get_conv_log_filename())
+  
+    # src_img_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}_src.png'
+    # os.makedirs(os.path.dirname(src_img_file), exist_ok=True)
+    # with open(src_img_file, 'w') as f:
+    #     state.source_image.save(f, 'PNG')
+    # output_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}_out.png'
+    # with open(output_file, 'w') as f:
+    #     state.output.save(f, 'PNG')
+    # save_image_file_on_log_server(src_img_file)
+    # save_image_file_on_log_server(output_file)
+        
+def generate_i2s_multi(gen_func, render_func, 
+                       state_0, state_1, 
+                       image, 
+                       model_name_0, model_name_1,
+                       request: gr.Request):
+    if not image:
+        raise gr.Warning("Image cannot be empty.")
+    if not model_name_0:
+        raise gr.Warning("Model name A cannot be empty.")
+    if not model_name_1:
+        raise gr.Warning("Model name B cannot be empty.")
+    
+    if state_0 is None:
+        state_0 = State(model_name_0, i2s_mode=True, offline=False)
+    if state_1 is None:
+        state_1 = State(model_name_1, i2s_mode=True, offline=False)
+
+    ip = get_ip(request)
+    t2s_multi_logger.info(f"generate. ip: {ip}")
+
+    state_0.model_name, state_1.model_name = model_name_0, model_name_1
+    state_0.image, state_1.image = image, image
+
+    if not state_0.offline and not state_0.offline_idx and \
+        not state_1.offline and not state_1.offline_idx:
+        start_time = time.time()
+        normal_video_0 = os.path.join(OFFLINE_DIR, "image2shape", model_name_0, "normal", f"{state_0.offline_idx}.mp4")
+        rgb_video_0 = os.path.join(OFFLINE_DIR, "image2shape", model_name_0, "rgb", f"{state_0.offline_idx}.mp4")
+        normal_video_1 = os.path.join(OFFLINE_DIR, "image2shape", model_name_1, "normal", f"{state_1.offline_idx}.mp4")
+        rgb_video_1 = os.path.join(OFFLINE_DIR, "image2shape", model_name_1, "rgb", f"{state_1.offline_idx}.mp4")
+        
+        state_0.normal_video = normal_video_0
+        state_0.rgb_video = rgb_video_0
+        state_1.normal_video = normal_video_1
+        state_1.rgb_video = rgb_video_1
+        yield state_0, state_1, normal_video_0, rgb_video_0, normal_video_0, rgb_video_1, \
+            gr.Markdown(f"### Model A: {model_name_0}"), gr.Markdown(f"### Model B: {model_name_1}")
+
+        # logger.info(f"===output===: {output}")
+        data_0 = {
+            "ip": get_ip(request),
+            "model": model_name_0,
+            "type": "offline",
+            "gen_params": {},
+            "state": state_0.dict(),
+            "start": round(start_time, 4),
+        }
+        data_1 = {
+            "ip": get_ip(request),
+            "model": model_name_1,
+            "type": "offline",
+            "gen_params": {},
+            "state": state_1.dict(),
+            "start": round(start_time, 4),
+        }
+    else:
+        start_time = time.time()
+        shape_0, shape_1 = gen_func(image, model_name_0, model_name_1)
+        generate_time = time.time() - start_time
+
+        normal_video_0, rgb_video_0, normal_video_1, rgb_video_1 = render_func(shape_0, model_name_0,
+                                                                               shape_1, model_name_1)
+        finish_time = time.time()
+        render_time = finish_time - start_time - generate_time
+
+        state_0.normal_video = normal_video_0
+        state_0.rgb_video = rgb_video_0
+        state_1.normal_video = normal_video_1
+        state_1.rgb_video = rgb_video_1
+        yield state_0, state_1, normal_video_0, rgb_video_0, normal_video_0, rgb_video_1
+
+        # logger.info(f"===output===: {output}")
+        data_0 = {
+            "ip": get_ip(request),
+            "model": model_name_0,
+            "type": "online",
+            "gen_params": {},
+            "state": state_0.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+        data_1 = {
+            "ip": get_ip(request),
+            "model": model_name_1,
+            "type": "online",
+            "gen_params": {},
+            "state": state_1.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+    
+    with open(get_conv_log_filename(), "a") as fout:
+        fout.write(json.dumps(data_0) + "\n")
+        fout.write(json.dumps(data_1) + "\n")
+    append_json_item_on_log_server(data_0, get_conv_log_filename())
+    append_json_item_on_log_server(data_1, get_conv_log_filename())
+        
+    # for i, state in enumerate([state_0, state_1]):
+    #     src_img_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}_src.png'
+    #     os.makedirs(os.path.dirname(src_img_file), exist_ok=True)
+    #     with open(src_img_file, 'w') as f:
+    #         state.source_image.save(f, 'PNG')
+    #     output_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}_out.png'
+    #     with open(output_file, 'w') as f:
+    #         state.output.save(f, 'PNG')
+    #     save_image_file_on_log_server(src_img_file)
+    #     save_image_file_on_log_server(output_file)
+            
+
+def generate_i2s_multi_annoy(gen_func, 
+                             state_0, state_1, 
+                             image, 
+                             model_name_0, model_name_1, 
+                             request: gr.Request):
+    if not image:
+        raise gr.Warning("Image cannot be empty.")
+    if state_0 is None:
+        state_0 = State(model_name_0, i2s_mode=True, offline=False)
+    if state_1 is None:
+        state_1 = State(model_name_1, i2s_mode=True, offline=False)
+
+    ip = get_ip(request)
+    t2s_multi_logger.info(f"generate. ip: {ip}")
+
+    state_0.model_name, state_1.model_name = model_name_0, model_name_1
+    state_0.image, state_1.image = image, image
+
+    if not state_0.offline and not state_0.offline_idx and \
+        not state_1.offline and not state_1.offline_idx:
+        start_time = time.time()
+        normal_video_0 = os.path.join(OFFLINE_DIR, "image2shape", model_name_0, "normal", f"{state_0.offline_idx}.mp4")
+        rgb_video_0 = os.path.join(OFFLINE_DIR, "image2shape", model_name_0, "rgb", f"{state_0.offline_idx}.mp4")
+        normal_video_1 = os.path.join(OFFLINE_DIR, "image2shape", model_name_1, "normal", f"{state_1.offline_idx}.mp4")
+        rgb_video_1 = os.path.join(OFFLINE_DIR, "image2shape", model_name_1, "rgb", f"{state_1.offline_idx}.mp4")
+        
+        state_0.normal_video = normal_video_0
+        state_0.rgb_video = rgb_video_0
+        state_1.normal_video = normal_video_1
+        state_1.rgb_video = rgb_video_1
+        yield state_0, state_1, normal_video_0, rgb_video_0, normal_video_0, rgb_video_1, \
+            gr.Markdown(f"### Model A: {model_name_0}"), gr.Markdown(f"### Model B: {model_name_1}")
+
+        # logger.info(f"===output===: {output}")
+        data_0 = {
+            "ip": get_ip(request),
+            "model": model_name_0,
+            "type": "offline",
+            "gen_params": {},
+            "state": state_0.dict(),
+            "start": round(start_time, 4),
+        }
+        data_1 = {
+            "ip": get_ip(request),
+            "model": model_name_1,
+            "type": "offline",
+            "gen_params": {},
+            "state": state_1.dict(),
+            "start": round(start_time, 4),
+        }
+    else:
+        start_time = time.time()
+        shape_0, shape_1 = gen_func(image, model_name_0, model_name_1)
+        generate_time = time.time() - start_time
+
+        normal_video_0, rgb_video_0, normal_video_1, rgb_video_1 = render_func(shape_0, model_name_0,
+                                                                               shape_1, model_name_1)
+        finish_time = time.time()
+        render_time = finish_time - start_time - generate_time
+
+        state_0.normal_video = normal_video_0
+        state_0.rgb_video = rgb_video_0
+        state_1.normal_video = normal_video_1
+        state_1.rgb_video = rgb_video_1
+        yield state_0, state_1, normal_video_0, rgb_video_0, normal_video_0, rgb_video_1, \
+            gr.Markdown(f"### Model A: {model_name_0}"), gr.Markdown(f"### Model B: {model_name_1}")
+
+        # logger.info(f"===output===: {output}")
+        data_0 = {
+            "ip": get_ip(request),
+            "model": model_name_0,
+            "type": "online",
+            "gen_params": {},
+            "state": state_0.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+        data_1 = {
+            "ip": get_ip(request),
+            "model": model_name_1,
+            "type": "online",
+            "gen_params": {},
+            "state": state_1.dict(),
+            "start": round(start_time, 4),
+            "time": round(finish_time - start_time, 4),
+            "generate_time": round(generate_time, 4),
+            "render_time": round(render_time, 4),
+        }
+    
+    with open(get_conv_log_filename(), "a") as fout:
+        fout.write(json.dumps(data_0) + "\n")
+        fout.write(json.dumps(data_1) + "\n")
+    append_json_item_on_log_server(data_0, get_conv_log_filename())
+    append_json_item_on_log_server(data_1, get_conv_log_filename())
+        
+    # for i, state in enumerate([state_0, state_1]):
+    #     src_img_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}_src.png'
+    #     os.makedirs(os.path.dirname(src_img_file), exist_ok=True)
+    #     with open(src_img_file, 'w') as f:
+    #         state.source_image.save(f, 'PNG')
+    #     output_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}_out.png'
+    #     with open(output_file, 'w') as f:
+    #         state.output.save(f, 'PNG')
+    #     save_image_file_on_log_server(src_img_file)
+    #     save_image_file_on_log_server(output_file)

serve/leaderboard.py

@@ -0,0 +1,309 @@
+"""
+Live monitor of the website statistics and leaderboard.
+
+Dependency:
+sudo apt install pkg-config libicu-dev
+pip install pytz gradio gdown plotly polyglot pyicu pycld2 tabulate
+"""
+
+import argparse
+import ast
+import pickle
+import os
+import threading
+import time
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+
+
+basic_component_values = [None] * 6
+leader_component_values = [None] * 5
+
+
+# def make_leaderboard_md(elo_results):
+#     leaderboard_md = f"""
+# # 🏆 Chatbot Arena Leaderboard
+# | [Blog](https://lmsys.org/blog/2023-05-03-arena/) | [GitHub](https://github.com/lm-sys/FastChat) | [Paper](https://arxiv.org/abs/2306.05685) | [Dataset](https://github.com/lm-sys/FastChat/blob/main/docs/dataset_release.md) | [Twitter](https://twitter.com/lmsysorg) | [Discord](https://discord.gg/HSWAKCrnFx) |
+
+# This leaderboard is based on the following three benchmarks.
+# - [Chatbot Arena](https://lmsys.org/blog/2023-05-03-arena/) - a crowdsourced, randomized battle platform. We use 100K+ user votes to compute Elo ratings.
+# - [MT-Bench](https://arxiv.org/abs/2306.05685) - a set of challenging multi-turn questions. We use GPT-4 to grade the model responses.
+# - [MMLU](https://arxiv.org/abs/2009.03300) (5-shot) - a test to measure a model's multitask accuracy on 57 tasks.
+
+# 💻 Code: The Arena Elo ratings are computed by this [notebook]({notebook_url}). The MT-bench scores (single-answer grading on a scale of 10) are computed by [fastchat.llm_judge](https://github.com/lm-sys/FastChat/tree/main/fastchat/llm_judge). The MMLU scores are mostly computed by [InstructEval](https://github.com/declare-lab/instruct-eval). Higher values are better for all benchmarks. Empty cells mean not available. Last updated: November, 2023.
+# """
+#     return leaderboard_md
+
+def make_leaderboard_md(elo_results):
+    leaderboard_md = f"""
+# 🏆 GenAI-Arena Leaderboard
+| [GitHub](https://github.com/TIGER-AI-Lab/ImagenHub) | [Dataset](https://huggingface.co/ImagenHub) | [Twitter](https://twitter.com/TianleLI123/status/1757245259149422752) |
+
+"""
+    return leaderboard_md
+
+
+def make_leaderboard_md_live(elo_results):
+    leaderboard_md = f"""
+# Leaderboard
+Last updated: {elo_results["last_updated_datetime"]}
+{elo_results["leaderboard_table"]}
+"""
+    return leaderboard_md
+
+
+def model_hyperlink(model_name, link):
+    return f'<a target="_blank" href="{link}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{model_name}</a>'
+
+
+def load_leaderboard_table_csv(filename, add_hyperlink=True):
+    df = pd.read_csv(filename)
+    for col in df.columns:
+        if "Arena Elo rating" in col:
+            df[col] = df[col].apply(lambda x: int(x) if x != "-" else np.nan)
+        elif col == "MMLU":
+            df[col] = df[col].apply(lambda x: round(x * 100, 1) if x != "-" else np.nan)
+        elif col == "MT-bench (win rate %)":
+            df[col] = df[col].apply(lambda x: round(x, 1) if x != "-" else np.nan)
+        elif col == "MT-bench (score)":
+            df[col] = df[col].apply(lambda x: round(x, 2) if x != "-" else np.nan)
+        
+        if add_hyperlink and col == "Model":
+            df[col] = df.apply(lambda row: model_hyperlink(row[col], row["Link"]), axis=1)
+    return df
+
+
+
+def build_basic_stats_tab():
+    empty = "Loading ..."
+    basic_component_values[:] = [empty, None, empty, empty, empty, empty]
+
+    md0 = gr.Markdown(empty)
+    gr.Markdown("#### Figure 1: Number of model calls and votes")
+    plot_1 = gr.Plot(show_label=False)
+    with gr.Row():
+        with gr.Column():
+            md1 = gr.Markdown(empty)
+        with gr.Column():
+            md2 = gr.Markdown(empty)
+    with gr.Row():
+        with gr.Column():
+            md3 = gr.Markdown(empty)
+        with gr.Column():
+            md4 = gr.Markdown(empty)
+    return [md0, plot_1, md1, md2, md3, md4]
+
+
+def get_full_table(anony_arena_df, full_arena_df, model_table_df):
+    values = []
+    for i in range(len(model_table_df)):
+        row = []
+        model_key = model_table_df.iloc[i]["key"]
+        model_name = model_table_df.iloc[i]["Model"]
+        # model display name
+        row.append(model_name)
+        if model_key in anony_arena_df.index:
+            idx = anony_arena_df.index.get_loc(model_key)
+            row.append(round(anony_arena_df.iloc[idx]["rating"]))
+        else:
+            row.append(np.nan)
+        if model_key in full_arena_df.index:
+            idx = full_arena_df.index.get_loc(model_key)
+            row.append(round(full_arena_df.iloc[idx]["rating"]))
+        else:
+            row.append(np.nan)
+        # row.append(model_table_df.iloc[i]["MT-bench (score)"])
+        # row.append(model_table_df.iloc[i]["Num Battles"])
+        # row.append(model_table_df.iloc[i]["MMLU"])
+        # Organization
+        row.append(model_table_df.iloc[i]["Organization"])
+        # license
+        row.append(model_table_df.iloc[i]["License"])
+
+        values.append(row)
+    values.sort(key=lambda x: -x[1] if not np.isnan(x[1]) else 1e9)
+    return values
+
+
+def get_arena_table(arena_df, model_table_df):
+    # sort by rating
+    arena_df = arena_df.sort_values(by=["rating"], ascending=False)
+    values = []
+    for i in range(len(arena_df)):
+        row = []
+        model_key = arena_df.index[i]
+        model_name = model_table_df[model_table_df["key"] == model_key]["Model"].values[
+            0
+        ]
+
+        # rank
+        row.append(i + 1)
+        # model display name
+        row.append(model_name)
+        # elo rating
+        row.append(round(arena_df.iloc[i]["rating"]))
+        upper_diff = round(arena_df.iloc[i]["rating_q975"] - arena_df.iloc[i]["rating"])
+        lower_diff = round(arena_df.iloc[i]["rating"] - arena_df.iloc[i]["rating_q025"])
+        row.append(f"+{upper_diff}/-{lower_diff}")
+        # num battles
+        row.append(round(arena_df.iloc[i]["num_battles"]))
+        # Organization
+        row.append(
+            model_table_df[model_table_df["key"] == model_key]["Organization"].values[0]
+        )
+        # license
+        row.append(
+            model_table_df[model_table_df["key"] == model_key]["License"].values[0]
+        )
+
+        values.append(row)
+    return values
+
+def make_arena_leaderboard_md(elo_results):
+    arena_df = elo_results["leaderboard_table_df"]
+    last_updated = elo_results["last_updated_datetime"]
+    total_votes = sum(arena_df["num_battles"]) // 2
+    total_models = len(arena_df)
+
+    leaderboard_md = f"""
+
+
+Total #models: **{total_models}**(anonymous). Total #votes: **{total_votes}**. Last updated: {last_updated}.
+(Note: Only anonymous votes are considered here. Check the full leaderboard for all votes.)
+
+Contribute the votes 🗳️ at [GenAI-Arena](https://huggingface.co/spaces/TIGER-Lab/GenAI-Arena)! 
+
+If you want to see more models, please help us [add them](https://github.com/TIGER-AI-Lab/ImagenHub?tab=readme-ov-file#-contributing-).
+"""
+    return leaderboard_md
+
+def make_full_leaderboard_md(elo_results):
+    arena_df = elo_results["leaderboard_table_df"]
+    last_updated = elo_results["last_updated_datetime"]
+    total_votes = sum(arena_df["num_battles"]) // 2
+    total_models = len(arena_df)
+
+    leaderboard_md = f"""
+Total #models: **{total_models}**(full:anonymous+open). Total #votes: **{total_votes}**. Last updated: {last_updated}.
+
+Contribute your vote 🗳️ at [vision-arena](https://huggingface.co/spaces/WildVision/vision-arena)! 
+"""
+    return leaderboard_md
+
+def build_leaderboard_tab(elo_results_file, leaderboard_table_file, show_plot=False):
+    if elo_results_file is None:  # Do live update
+        md = "Loading ..."
+        p1 = p2 = p3 = p4 = None
+    else:
+        with open(elo_results_file, "rb") as fin:
+            elo_results = pickle.load(fin)
+
+        anony_elo_results = elo_results["anony"]
+        full_elo_results = elo_results["full"]
+        anony_arena_df = anony_elo_results["leaderboard_table_df"]
+        full_arena_df = full_elo_results["leaderboard_table_df"]
+        p1 = anony_elo_results["win_fraction_heatmap"]
+        p2 = anony_elo_results["battle_count_heatmap"]
+        p3 = anony_elo_results["bootstrap_elo_rating"]
+        p4 = anony_elo_results["average_win_rate_bar"]
+        
+        md = make_leaderboard_md(anony_elo_results)
+        
+    md_1 = gr.Markdown(md, elem_id="leaderboard_markdown")
+
+    if leaderboard_table_file:
+        model_table_df = load_leaderboard_table_csv(leaderboard_table_file)
+        with gr.Tabs() as tabs:
+            # arena table
+            arena_table_vals = get_arena_table(anony_arena_df, model_table_df)
+            with gr.Tab("Arena Elo", id=0):
+                md = make_arena_leaderboard_md(anony_elo_results)
+                gr.Markdown(md, elem_id="leaderboard_markdown")
+                gr.Dataframe(
+                    headers=[
+                        "Rank",
+                        "🤖 Model",
+                        "⭐ Arena Elo",
+                        "📊 95% CI",
+                        "🗳️ Votes",
+                        "Organization",
+                        "License",
+                    ],
+                    datatype=[
+                        "str",
+                        "markdown",
+                        "number",
+                        "str",
+                        "number",
+                        "str",
+                        "str",
+                    ],
+                    value=arena_table_vals,
+                    elem_id="arena_leaderboard_dataframe",
+                    height=700,
+                    column_widths=[50, 200, 100, 100, 100, 150, 150],
+                    wrap=True,
+                )
+            with gr.Tab("Full Leaderboard", id=1):
+                md = make_full_leaderboard_md(full_elo_results)
+                gr.Markdown(md, elem_id="leaderboard_markdown")
+                full_table_vals = get_full_table(anony_arena_df, full_arena_df, model_table_df)
+                gr.Dataframe(
+                    headers=[
+                        "🤖 Model",
+                        "⭐ Arena Elo (anony)",
+                        "⭐ Arena Elo (full)",
+                        "Organization",
+                        "License",
+                    ],
+                    datatype=["markdown", "number", "number", "str", "str"],
+                    value=full_table_vals,
+                    elem_id="full_leaderboard_dataframe",
+                    column_widths=[200, 100, 100, 100, 150, 150],
+                    height=700,
+                    wrap=True,
+                )
+        if not show_plot:
+            gr.Markdown(
+                """ ## We are still collecting more votes on more models. The ranking will be updated very fruquently. Please stay tuned! 
+                """,
+                elem_id="leaderboard_markdown",
+            )
+    else:
+        pass
+
+    leader_component_values[:] = [md, p1, p2, p3, p4]
+
+    """
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(
+                "#### Figure 1: Fraction of Model A Wins for All Non-tied A vs. B Battles"
+            )
+            plot_1 = gr.Plot(p1, show_label=False)
+        with gr.Column():
+            gr.Markdown(
+                "#### Figure 2: Battle Count for Each Combination of Models (without Ties)"
+            )
+            plot_2 = gr.Plot(p2, show_label=False)
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(
+                "#### Figure 3: Bootstrap of Elo Estimates (1000 Rounds of Random Sampling)"
+            )
+            plot_3 = gr.Plot(p3, show_label=False)
+        with gr.Column():
+            gr.Markdown(
+                "#### Figure 4: Average Win Rate Against All Other Models (Assuming Uniform Sampling and No Ties)"
+            )
+            plot_4 = gr.Plot(p4, show_label=False)
+    """
+
+    from .utils import acknowledgment_md
+
+    gr.Markdown(acknowledgment_md)
+
+    # return [md_1, plot_1, plot_2, plot_3, plot_4]
+    return [md_1]

serve/log_utils.py

@@ -0,0 +1,142 @@
+"""
+Common utilities.
+"""
+from asyncio import AbstractEventLoop
+import json
+import logging
+import logging.handlers
+import os
+import platform
+import sys
+from typing import AsyncGenerator, Generator
+import warnings
+from pathlib import Path
+
+import requests
+
+from .constants import LOGDIR, LOG_SERVER_ADDR, SAVE_LOG
+from .utils import save_log_str_on_log_server
+
+
+handler = None
+visited_loggers = set()
+
+
+# Assuming LOGDIR and other necessary imports and global variables are defined
+
+class APIHandler(logging.Handler):
+    """Custom logging handler that sends logs to an API."""
+
+    def __init__(self, apiUrl, log_path, *args, **kwargs):
+        super(APIHandler, self).__init__(*args, **kwargs)
+        self.apiUrl = apiUrl
+        self.log_path = log_path
+
+    def emit(self, record):
+        log_entry = self.format(record)
+        try:
+            save_log_str_on_log_server(log_entry, self.log_path)
+        except requests.RequestException as e:
+            print(f"Error sending log to API: {e}", file=sys.stderr)
+
+def build_logger(logger_name, logger_filename, add_remote_handler=False):
+    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:
+        if sys.version_info[1] >= 9:
+            # This is for windows
+            logging.basicConfig(level=logging.INFO, encoding="utf-8")
+        else:
+            if platform.system() == "Windows":
+                warnings.warn(
+                    "If you are running on Windows, "
+                    "we recommend you use Python >= 3.9 for UTF-8 encoding."
+                )
+            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)
+    
+    if add_remote_handler:
+        # Add APIHandler to send logs to your API
+        api_url = f"{LOG_SERVER_ADDR}/{SAVE_LOG}"
+        
+        remote_logger_filename = str(Path(logger_filename).stem + "_remote.log")
+        api_handler = APIHandler(apiUrl=api_url, log_path=f"{LOGDIR}/{remote_logger_filename}")
+        api_handler.setFormatter(formatter)
+        logger.addHandler(api_handler)
+        
+        stdout_logger.addHandler(api_handler)
+        stderr_logger.addHandler(api_handler)
+
+    # if LOGDIR is empty, then don't try output log to local file
+    if LOGDIR != "":
+        os.makedirs(LOGDIR, exist_ok=True)
+        filename = os.path.join(LOGDIR, logger_filename)
+        handler = logging.handlers.TimedRotatingFileHandler(
+            filename, when="D", utc=True, encoding="utf-8"
+        )
+        handler.setFormatter(formatter)
+
+        for l in [stdout_logger, stderr_logger, logger]:
+            if l in visited_loggers:
+                continue
+            visited_loggers.add(l)
+            l.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":
+                encoded_message = line.encode("utf-8", "ignore").decode("utf-8")
+                self.logger.log(self.log_level, encoded_message.rstrip())
+            else:
+                self.linebuf += line
+
+    def flush(self):
+        if self.linebuf != "":
+            encoded_message = self.linebuf.encode("utf-8", "ignore").decode("utf-8")
+            self.logger.log(self.log_level, encoded_message.rstrip())
+        self.linebuf = ""

serve/utils.py

@@ -0,0 +1,181 @@
+import os
+import json
+import random
+import datetime
+import requests
+import numpy as np
+import gradio as gr
+from pathlib import Path
+from model.model_registry import *
+from .constants import LOGDIR, LOG_SERVER_ADDR, APPEND_JSON, SAVE_IMAGE, SAVE_LOG
+from typing import Union
+
+
+enable_btn = gr.update(interactive=True, visible=True)
+disable_btn = gr.update(interactive=False)
+invisible_btn = gr.update(interactive=False, visible=False)
+no_change_btn = gr.update(value="No Change", interactive=True, visible=True)
+
+
+def build_about():
+    about_markdown = f"""
+# About Us
+This is a project from TIGER Lab at University of Waterloo. 
+
+## Contributors:
+[Tianle Li](https://scholar.google.com/citations?user=g213g7YAAAAJ&hl=en), [Dongfu Jiang](https://jdf-prog.github.io/), [Yuansheng Ni](https://yuanshengni.github.io/).
+
+## Contact:
+Email: t29li@uwaterloo.ca (Tianle Li)
+
+## Advisors
+[Wenhu Chen](https://wenhuchen.github.io/)
+
+## Sponsorship
+We are keep looking for sponsorship to support the arena project for the long term. Please contact us if you are interested in supporting this project.
+"""
+
+    gr.Markdown(about_markdown, elem_id="about_markdown")
+
+
+acknowledgment_md = """
+### Acknowledgment
+<div class="image-container">
+    <p> Our code base is built upon <a href="https://github.com/lm-sys/FastChat" target="_blank">FastChat</a> and <a href="https://github.com/TIGER-AI-Lab/ImagenHub" target="_blank">ImagenHub</a></p>.
+</div>
+"""
+
+block_css = """
+#notice_markdown {
+    font-size: 110%
+}
+#notice_markdown th {
+    display: none;
+}
+#notice_markdown td {
+    padding-top: 6px;
+    padding-bottom: 6px;
+}
+#model_description_markdown {
+    font-size: 110%
+}
+#leaderboard_markdown {
+    font-size: 110%
+}
+#leaderboard_markdown td {
+    padding-top: 6px;
+    padding-bottom: 6px;
+}
+#leaderboard_dataframe td {
+    line-height: 0.1em;
+}
+#about_markdown {
+    font-size: 110%
+}
+#ack_markdown {
+    font-size: 110%
+}
+#evaldim_markdown {
+    font-weight: bold;
+    text-align: center;
+    background-color: white;
+}
+#input_box textarea {
+}
+footer {
+    display:none !important
+}
+.image-about img {
+    margin: 0 30px;
+    margin-top:  30px;
+    height: 60px;
+    max-height: 100%;
+    width: auto;
+    float: left;
+.input-image, .image-preview {
+    margin: 0 30px;
+    height: 30px;
+    max-height: 100%;
+    width: auto;
+    max-width: 30%;}
+}
+"""
+def enable_mds():
+    return tuple(gr.update(visible=True) for _ in range(3))
+
+def disable_mds():
+    return tuple(gr.update(visible=False) for _ in range(3))
+
+def enable_buttons_side_by_side():
+    return tuple(gr.update(visible=True, interactive=True) for i in range(14))
+
+def disable_buttons_side_by_side():
+    return tuple(gr.update(visible=i>=12, interactive=False) for i in range(14))
+
+def enable_buttons():
+    return tuple(gr.update(interactive=True) for _ in range(11))
+
+def disable_buttons():
+    return tuple(gr.update(interactive=False) for _ in range(11))
+
+def clear_t2s_history():
+    return None, "", None, None
+   
+def clear_t2s_history_side_by_side():
+    return [None] * 2 + [""] + [None] * 4
+
+def clear_t2s_history_side_by_side_anony():
+    return [None] * 2 + [""] + [None] * 4 + [gr.Markdown("", visible=False), gr.Markdown("", visible=False)]
+
+def clear_i2s_history():
+    return None, None, None, None
+   
+def clear_i2s_history_side_by_side():
+    return [None] * 2 + [None] + [None] * 4
+
+def clear_i2s_history_side_by_side_anony():
+    return [None] * 2 + [None] + [None] * 4 + [gr.Markdown("", visible=False), gr.Markdown("", visible=False)]
+
+def get_ip(request: gr.Request):
+    if request:
+        if "cf-connecting-ip" in request.headers:
+            ip = request.headers["cf-connecting-ip"] or request.client.host
+        else:
+            ip = request.client.host
+    else:
+        ip = None
+    return ip
+
+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 save_image_file_on_log_server(image_file:str):
+
+    image_file = Path(image_file).absolute().relative_to(os.getcwd())
+    image_file = str(image_file)
+    # Open the image file in binary mode
+    url = f"{LOG_SERVER_ADDR}/{SAVE_IMAGE}"
+    with open(image_file, 'rb') as f:
+        # Make the POST request, sending the image file and the image path
+        response = requests.post(url, files={'image': f}, data={'image_path': image_file})
+    return response
+
+def append_json_item_on_log_server(json_item: Union[dict, str], log_file: str):
+    if isinstance(json_item, dict):
+        json_item = json.dumps(json_item)
+    log_file = Path(log_file).absolute().relative_to(os.getcwd())
+    log_file = str(log_file)
+    url = f"{LOG_SERVER_ADDR}/{APPEND_JSON}"
+    # Make the POST request, sending the JSON string and the log file name
+    response = requests.post(url, data={'json_str': json_item, 'file_name': log_file})
+    return response
+
+def save_log_str_on_log_server(log_str: str, log_file: str):
+    log_file = Path(log_file).absolute().relative_to(os.getcwd())
+    log_file = str(log_file)
+    url = f"{LOG_SERVER_ADDR}/{SAVE_LOG}"
+    # Make the POST request, sending the log message and the log file name
+    response = requests.post(url, data={'message': log_str, 'log_path': log_file})
+    return response

serve/vote_utils.py

@@ -0,0 +1,326 @@
+import datetime
+import time
+import json
+import uuid
+import gradio as gr
+from pathlib import Path
+from .utils import *
+from .log_utils import build_logger
+from .constants import IMAGE_DIR
+
+t2s_logger = build_logger("gradio_web_server_text2shape", "gr_web_text2shape.log") # t2s = image generation, loggers for single model direct chat
+t2s_multi_logger = build_logger("gradio_web_server_text2shape_multi", "gr_web_text2shape_multi.log") # t2s_multi = image generation multi, loggers for side-by-side and battle
+i2s_logger = build_logger("gradio_web_server_image2shape", "gr_web_image2shape.log") # i2s = image editing, loggers for single model direct chat
+i2s_multi_logger = build_logger("gradio_web_server_image2shape_multi", "gr_web_image2shape_multi.log") # i2s_multi = image editing multi, loggers for side-by-side and battle
+
+def vote_last_response_t2s(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": get_ip(request),
+        }
+        fout.write(json.dumps(data) + "\n")
+        append_json_item_on_log_server(data, get_conv_log_filename())
+        
+def vote_last_response_t2s_multi(states, vote_type, model_selectors, request: gr.Request):
+    with open(get_conv_log_filename(), "a") as fout:
+        data = {
+            "tstamp": round(time.time(), 4),
+            "type": vote_type,
+            "models": [x for x in model_selectors],
+            "states": [x.dict() for x in states],
+            "ip": get_ip(request),
+        }
+        fout.write(json.dumps(data) + "\n")
+        append_json_item_on_log_server(data, get_conv_log_filename())
+    # for state in states:
+    #     output_file = f'{IMAGE_DIR}/text2shape/{state.conv_id}.png'
+    #     with open(output_file, 'w') as f:
+    #         state.output.save(f, 'PNG')
+    #     save_image_file_on_log_server(output_file)
+
+def vote_last_response_i2s(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": get_ip(request),
+        }
+        fout.write(json.dumps(data) + "\n")
+        append_json_item_on_log_server(data, get_conv_log_filename())
+    # output_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}.png'
+    # source_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}_source.png'
+    # with open(output_file, 'w') as f:
+    #     state.output.save(f, 'PNG')
+    # with open(source_file, 'w') as sf:
+    #     state.source_image.save(sf, 'PNG')
+    # save_image_file_on_log_server(output_file)
+    # save_image_file_on_log_server(source_file)
+        
+def vote_last_response_i2s_multi(states, vote_type, model_selectors, request: gr.Request):
+    with open(get_conv_log_filename(), "a") as fout:
+        data = {
+            "tstamp": round(time.time(), 4),
+            "type": vote_type,
+            "models": [x for x in model_selectors],
+            "states": [x.dict() for x in states],
+            "ip": get_ip(request),
+        }
+        fout.write(json.dumps(data) + "\n")
+        append_json_item_on_log_server(data, get_conv_log_filename())
+    # for state in states:
+    #     output_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}.png'
+    #     source_file = f'{IMAGE_DIR}/image2shape/{state.conv_id}_source.png'
+    #     with open(output_file, 'w') as f:
+    #         state.output.save(f, 'PNG')
+    #     with open(source_file, 'w') as sf:
+    #         state.source_image.save(sf, 'PNG')
+    #     save_image_file_on_log_server(output_file)
+    #     save_image_file_on_log_server(source_file)
+            
+
+## Text-to-Shape Generation (t2s) Single Model Direct Chat
+def upvote_last_response_t2s(state, model_selector, request: gr.Request):
+    ip = get_ip(request)
+    t2s_logger.info(f"upvote. ip: {ip}")
+    vote_last_response_t2s(state, "upvote", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+def downvote_last_response_t2s(state, model_selector, request: gr.Request):
+    ip = get_ip(request)
+    t2s_logger.info(f"downvote. ip: {ip}")
+    vote_last_response_t2s(state, "downvote", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+def flag_last_response_t2s(state, model_selector, request: gr.Request):
+    ip = get_ip(request)
+    t2s_logger.info(f"flag. ip: {ip}")
+    vote_last_response_t2s(state, "flag", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+
+## Text-to-Shape Generation Multi (t2s_multi) Side-by-Side and Battle
+def leftvote_last_response_t2s_named(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    t2s_multi_logger.info(f"leftvote (named). ip: {get_ip(request)}")
+    vote_last_response_t2s_multi(
+        [state0, state1], "leftvote", [model_selector0, model_selector1], request
+    )
+    return ("",) + (disable_btn,) * 4
+
+def rightvote_last_response_t2s_named(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    t2s_multi_logger.info(f"rightvote (named). ip: {get_ip(request)}")
+    vote_last_response_t2s_multi(
+        [state0, state1], "rightvote", [model_selector0, model_selector1], request
+    )
+    return ("",) + (disable_btn,) * 4
+
+def tievote_last_response_t2s_named(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    t2s_multi_logger.info(f"tievote (named). ip: {get_ip(request)}")
+    vote_last_response_t2s_multi(
+        [state0, state1], "tievote", [model_selector0, model_selector1], request
+    )
+    return ("",) + (disable_btn,) * 4
+
+def bothbad_vote_last_response_t2s_named(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    t2s_multi_logger.info(f"bothbad_vote (named). ip: {get_ip(request)}")
+    vote_last_response_t2s_multi(
+        [state0, state1], "bothbad_vote", [model_selector0, model_selector1], request
+    )
+    return ("",) + (disable_btn,) * 4 
+
+
+def leftvote_last_response_t2s_anony(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    t2s_multi_logger.info(f"leftvote (named). ip: {get_ip(request)}")
+    vote_last_response_t2s_multi(
+        [state0, state1], "leftvote", [model_selector0, model_selector1], request
+    )
+    names = (gr.Markdown(f"### Model A: {state0.model_name}", visible=True), gr.Markdown(f"### Model B: {state1.model_name}", visible=True))
+    return ("",) + (disable_btn,) * 4 + names
+
+def rightvote_last_response_t2s_anony(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    t2s_multi_logger.info(f"rightvote (named). ip: {get_ip(request)}")
+    vote_last_response_t2s_multi(
+        [state0, state1], "rightvote", [model_selector0, model_selector1], request
+    )
+    names = (gr.Markdown(f"### Model A: {state0.model_name}", visible=True), gr.Markdown(f"### Model B: {state1.model_name}", visible=True))
+    return ("",) + (disable_btn,) * 4 + names
+
+def tievote_last_response_t2s_anony(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    t2s_multi_logger.info(f"tievote (named). ip: {get_ip(request)}")
+    vote_last_response_t2s_multi(
+        [state0, state1], "tievote", [model_selector0, model_selector1], request
+    )
+    names = (gr.Markdown(f"### Model A: {state0.model_name}", visible=True), gr.Markdown(f"### Model B: {state1.model_name}", visible=True))
+    return ("",) + (disable_btn,) * 4 + names
+
+def bothbad_vote_last_response_t2s_anony(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    t2s_multi_logger.info(f"bothbad_vote (named). ip: {get_ip(request)}")
+    vote_last_response_t2s_multi(
+        [state0, state1], "bothbad_vote", [model_selector0, model_selector1], request
+    )
+    names = (gr.Markdown(f"### Model A: {state0.model_name}", visible=True), gr.Markdown(f"### Model B: {state1.model_name}", visible=True))
+    return ("",) + (disable_btn,) * 4 + names
+
+## Image-to-Shape (i2s) Single Model Direct Chat
+def upvote_last_response_i2s(state, model_selector, request: gr.Request):
+    ip = get_ip(request)
+    i2s_logger.info(f"upvote. ip: {ip}")
+    vote_last_response_i2s(state, "upvote", model_selector, request)
+    return ("", "", gr.Image(height=512, width=512, type="pil"), "",) + (disable_btn,) * 3
+
+def downvote_last_response_i2s(state, model_selector, request: gr.Request):
+    ip = get_ip(request)
+    i2s_logger.info(f"downvote. ip: {ip}")
+    vote_last_response_i2s(state, "downvote", model_selector, request)
+    return ("", "", gr.Image(height=512, width=512, type="pil"), "",) + (disable_btn,) * 3
+
+def flag_last_response_i2s(state, model_selector, request: gr.Request):
+    ip = get_ip(request)
+    i2s_logger.info(f"flag. ip: {ip}")
+    vote_last_response_i2s(state, "flag", model_selector, request)
+    return ("", "", gr.Image(height=512, width=512, type="pil"), "",) + (disable_btn,) * 3
+
+
+## Image-to-Shape Multi (i2s_multi) Side-by-Side and Battle
+def leftvote_last_response_i2s_named(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    i2s_multi_logger.info(f"leftvote (anony). ip: {get_ip(request)}")
+    vote_last_response_i2s_multi(
+        [state0, state1], "leftvote", [model_selector0, model_selector1], request
+    )
+    return gr.Image(height=512, width=512, type="pil") + (disable_btn,) * 4
+        
+def rightvote_last_response_i2s_named(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    i2s_multi_logger.info(f"rightvote (anony). ip: {get_ip(request)}")
+    vote_last_response_i2s_multi(
+        [state0, state1], "rightvote", [model_selector0, model_selector1], request
+    )
+    return gr.Image(height=512, width=512, type="pil") + (disable_btn,) * 4
+
+def tievote_last_response_i2s_named(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    i2s_multi_logger.info(f"tievote (anony). ip: {get_ip(request)}")
+    vote_last_response_i2s_multi(
+        [state0, state1], "tievote", [model_selector0, model_selector1], request
+    )
+    return gr.Image(height=512, width=512, type="pil") + (disable_btn,) * 4
+
+def bothbad_vote_last_response_i2s_named(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    i2s_multi_logger.info(f"bothbad_vote (anony). ip: {get_ip(request)}")
+    vote_last_response_i2s_multi(
+        [state0, state1], "bothbad_vote", [model_selector0, model_selector1], request
+    )
+    return gr.Image(height=512, width=512, type="pil") + (disable_btn,) * 4
+
+
+def leftvote_last_response_i2s_anony(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    i2s_multi_logger.info(f"leftvote (anony). ip: {get_ip(request)}")
+    vote_last_response_i2s_multi(
+        [state0, state1], "leftvote", [model_selector0, model_selector1], request
+    )
+    # names = (
+    #     "### Model A: " + state0.model_name,
+    #     "### Model B: " + state1.model_name,
+    # )
+    # names = (state0.model_name, state1.model_name)
+    names = (gr.Markdown(f"### Model A: {state0.model_name}", visible=True), gr.Markdown(f"### Model B: {state1.model_name}", visible=True))
+    return gr.Image(height=512, width=512, type="pil") + (disable_btn,) * 4 + names
+        
+def rightvote_last_response_i2s_anony(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    i2s_multi_logger.info(f"rightvote (anony). ip: {get_ip(request)}")
+    vote_last_response_i2s_multi(
+        [state0, state1], "rightvote", [model_selector0, model_selector1], request
+    )
+    # names = (
+    #     "### Model A: " + state0.model_name,
+    #     "### Model B: " + state1.model_name,
+    # )
+    names = (gr.Markdown(f"### Model A: {state0.model_name}", visible=True), gr.Markdown(f"### Model B: {state1.model_name}", visible=True))
+    return gr.Image(height=512, width=512, type="pil") + (disable_btn,) * 4 + names
+
+def tievote_last_response_i2s_anony(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    i2s_multi_logger.info(f"tievote (anony). ip: {get_ip(request)}")
+    vote_last_response_i2s_multi(
+        [state0, state1], "tievote", [model_selector0, model_selector1], request
+    )
+    names = (gr.Markdown(f"### Model A: {state0.model_name}", visible=True), gr.Markdown(f"### Model B: {state1.model_name}", visible=True))
+    return gr.Image(height=512, width=512, type="pil") + (disable_btn,) * 4 + names
+
+def bothbad_vote_last_response_i2s_anony(
+    state0, state1, model_selector0, model_selector1, request: gr.Request
+):
+    i2s_multi_logger.info(f"bothbad_vote (anony). ip: {get_ip(request)}")
+    vote_last_response_i2s_multi(
+        [state0, state1], "bothbad_vote", [model_selector0, model_selector1], request
+    )
+    names = (gr.Markdown(f"### Model A: {state0.model_name}", visible=True), gr.Markdown(f"### Model B: {state1.model_name}", visible=True))
+    return gr.Image(height=512, width=512, type="pil") + (disable_btn,) * 4 + names
+
+
+share_js = """
+function (a, b, c, d) {
+    const captureElement = document.querySelector('#share-region-named');
+    html2canvas(captureElement)
+        .then(canvas => {
+            canvas.style.display = 'none'
+            document.body.appendChild(canvas)
+            return canvas
+        })
+        .then(canvas => {
+            const image = canvas.toDataURL('image/png')
+            const a = document.createElement('a')
+            a.setAttribute('download', 'chatbot-arena.png')
+            a.setAttribute('href', image)
+            a.click()
+            canvas.remove()
+        });
+    return [a, b, c, d];
+}
+"""
+def share_click_t2s_multi(state0, state1, model_selector0, model_selector1, request: gr.Request):
+    t2s_multi_logger.info(f"share (anony). ip: {get_ip(request)}")
+    if state0 is not None and state1 is not None:
+        vote_last_response_t2s_multi(
+            [state0, state1], "share", [model_selector0, model_selector1], request
+        )
+
+def share_click_i2s_multi(state0, state1, model_selector0, model_selector1, request: gr.Request):
+    i2s_multi_logger.info(f"share (anony). ip: {get_ip(request)}")
+    if state0 is not None and state1 is not None:
+        vote_last_response_i2s_multi(
+            [state0, state1], "share", [model_selector0, model_selector1], request
+        )
+