Add Video

app.py

@@ -1,7 +1,8 @@
 import gradio as gr
 import os
 from serve.gradio_web import *
-from serve.leaderboard import build_leaderboard_tab
+from serve.gradio_web_video import build_side_by_side_video_ui_anony
+from serve.leaderboard import build_leaderboard_tab, build_leaderboard_video_tab
 from model.model_manager import ModelManager
 from pathlib import Path
 from serve.constants import SERVER_PORT, ROOT_PATH, ELO_RESULTS_DIR
@@ -26,7 +27,14 @@ def build_combine_demo(models, elo_results_file, leaderboard_table_file):
                     
                     with gr.Tab("Generation Arena (battle)", id=1):
                         build_side_by_side_ui_anony(models)
-
+            with gr.Tab("Video Generation", id=1):
+                with gr.Tabs() as tabs_ig:
+                    with gr.Tab("Generation Leaderboard", id=0):
+                        # build_leaderboard_tab(elo_results_file['t2i_generation'], leaderboard_table_file['t2i_generation'])
+                        build_leaderboard_video_tab()
+                    
+                    with gr.Tab("Generation Arena (battle)", id=1):
+                        build_side_by_side_video_ui_anony(models)
     return demo
 
 

get_webvid_prompt.py

@@ -0,0 +1,32 @@
+from datasets import load_dataset
+import pandas as pd
+import re
+# # Load the WebVid dataset
+# dataset = load_dataset('webvid', 'webvid-10m', split='train')
+# from datasets import load_dataset
+
+ds = load_dataset("TempoFunk/webvid-10M", cache_dir="/mnt/data/lizhikai/webvid/")
+v = ds['validation']['name']
+# 定义字符串长度的合理范围
+MIN_LENGTH = 30
+MAX_LENGTH = 300
+pattern = re.compile(r'^[a-zA-Z\s]+$')
+
+# 过滤掉空字符串和特别长特别短的字符串
+v = [s for s in v if len(s) >= MIN_LENGTH and len(s) <= MAX_LENGTH and pattern.match(s)]
+
+# 指定保存文件的路径
+file_path = 'webvid_prompt.txt'
+
+# 打开文件，以写入模式
+with open(file_path, 'w', encoding='utf-8') as file:
+    # 遍历列表中的每个字符串并写入文件
+    for item in v:
+        if '\n' in item:
+            continue
+        else:
+            file.write(item + '\n')
+
+print("字符串列表已成功保存到文件中。")
+
+

model/matchmaker.py

@@ -79,7 +79,7 @@ def load_json_via_sftp():
 class RunningPivot(object):
     running_pivot = []
 
-not_run = []
+not_run = [20,21,22]
 
 def matchmaker(num_players, k_group=4):
     trueskill_env = TrueSkill()

model/matchmaker_video.py

@@ -0,0 +1,103 @@
+import numpy as np
+import json
+from trueskill import TrueSkill
+import paramiko
+import io, os
+import sys
+sys.path.append('../')
+from serve.constants import SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD, SSH_VIDEO_SKILL
+trueskill_env = TrueSkill()
+
+ssh_matchmaker_client = None
+sftp_matchmaker_client = None
+
+def create_ssh_matchmaker_client(server, port, user, password):
+    global ssh_matchmaker_client, sftp_matchmaker_client
+    ssh_matchmaker_client = paramiko.SSHClient()
+    ssh_matchmaker_client.load_system_host_keys()
+    ssh_matchmaker_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    ssh_matchmaker_client.connect(server, port, user, password)
+
+    transport = ssh_matchmaker_client.get_transport()
+    transport.set_keepalive(60)
+
+    sftp_matchmaker_client = ssh_matchmaker_client.open_sftp()
+def is_connected():
+    global ssh_matchmaker_client, sftp_matchmaker_client
+    if ssh_matchmaker_client is None or sftp_matchmaker_client is None:
+        return False
+    # 检查SSH连接是否正常
+    if not ssh_matchmaker_client.get_transport().is_active():
+        return False
+    # 检查SFTP连接是否正常
+    try:
+        sftp_matchmaker_client.listdir('.')  # 尝试列出根目录
+    except Exception as e:
+        print(f"Error checking SFTP connection: {e}")
+        return False
+    return True
+def ucb_score(trueskill_diff, t, n):
+    exploration_term = np.sqrt((2 * np.log(t + 1e-5)) / (n + 1e-5))
+    ucb = -trueskill_diff + 1.0 * exploration_term
+    return ucb
+
+def update_trueskill(ratings, ranks):
+    new_ratings = trueskill_env.rate(ratings, ranks)
+    return new_ratings
+
+def serialize_rating(rating):
+    return {'mu': rating.mu, 'sigma': rating.sigma}
+
+def deserialize_rating(rating_dict):
+    return trueskill_env.Rating(mu=rating_dict['mu'], sigma=rating_dict['sigma'])
+
+def save_json_via_sftp(ratings, comparison_counts, total_comparisons):
+    global sftp_matchmaker_client
+    if not is_connected():
+        create_ssh_matchmaker_client(SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD)
+    data = {
+        'ratings': [serialize_rating(r) for r in ratings],
+        'comparison_counts': comparison_counts.tolist(),
+        'total_comparisons': total_comparisons
+    }  
+    json_data = json.dumps(data)
+    with sftp_matchmaker_client.open(SSH_VIDEO_SKILL, 'w') as f:
+        f.write(json_data)
+
+def load_json_via_sftp():
+    global sftp_matchmaker_client
+    if not is_connected():
+        create_ssh_matchmaker_client(SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD)
+    with sftp_matchmaker_client.open(SSH_VIDEO_SKILL, 'r') as f:
+        data = json.load(f)
+    ratings = [deserialize_rating(r) for r in data['ratings']]
+    comparison_counts = np.array(data['comparison_counts'])
+    total_comparisons = data['total_comparisons']
+    return ratings, comparison_counts, total_comparisons
+
+
+def matchmaker_video(num_players, k_group=4):
+    trueskill_env = TrueSkill()
+    
+    ratings, comparison_counts, total_comparisons = load_json_via_sftp()
+
+    ratings = ratings[:num_players]
+    comparison_counts = comparison_counts[:num_players, :num_players]
+
+    selected_player = np.argmin(comparison_counts.sum(axis=1))
+
+    selected_trueskill_score = trueskill_env.expose(ratings[selected_player])
+    trueskill_scores = np.array([trueskill_env.expose(p) for p in ratings])
+    trueskill_diff = np.abs(trueskill_scores - selected_trueskill_score)
+    n = comparison_counts[selected_player]
+    ucb_scores = ucb_score(trueskill_diff, total_comparisons, n)
+
+    # Exclude self, select opponent with highest UCB score
+    ucb_scores[selected_player] = -float('inf')  # minimize the score for the selected player to exclude it
+    opponents = np.argsort(ucb_scores)[-k_group + 1:].tolist()
+
+    # Group players
+    model_ids = [selected_player] + opponents
+        
+    return model_ids
+

model/model_manager.py

@@ -1,13 +1,13 @@
 import concurrent.futures 
 import random
 import gradio as gr
-import requests
+import requests, os
 import io, base64, json
 import spaces
 import torch
 from PIL import Image
 from openai import OpenAI
-from .models import IMAGE_GENERATION_MODELS, IMAGE_EDITION_MODELS, load_pipeline
+from .models import IMAGE_GENERATION_MODELS, IMAGE_EDITION_MODELS, VIDEO_GENERATION_MODELS, load_pipeline
 from .fetch_museum_results import draw_from_imagen_museum, draw2_from_imagen_museum
 from serve.upload import get_random_mscoco_prompt
 
@@ -15,6 +15,7 @@ class ModelManager:
     def __init__(self):
         self.model_ig_list = IMAGE_GENERATION_MODELS
         self.model_ie_list = IMAGE_EDITION_MODELS
+        self.model_vg_list = VIDEO_GENERATION_MODELS
         self.loaded_models = {}
 
     def load_model_pipe(self, model_name):
@@ -92,6 +93,34 @@ class ModelManager:
         return results[0], results[1], results[2], results[3], \
             model_names[0], model_names[1], model_names[2], model_names[3]
 
+    def generate_video_ig_parallel_anony(self, prompt_num, model_A, model_B, model_C, model_D):
+        if model_A == "" and model_B == "" and model_C == "" and model_D == "":
+            # model_names = random.sample([model for model in self.model_vg_list], 4)
+
+            from .matchmaker_video import matchmaker_video
+            model_ids = matchmaker_video(num_players=len(self.model_vg_list))
+            print(model_ids)
+            model_names = [self.model_vg_list[i] for i in model_ids]
+            print(model_names)
+        else:
+            model_names = [model_A, model_B, model_C, model_D]
+
+        cache_dir = os.path.join("/mnt/data/lizhikai/ksort_video_cache/", f'cache_{prompt_num}')
+        results = []
+        for name in model_names:
+            model_source, model_name, model_type = name.split("_")
+            video_path = os.path.join(cache_dir, f'{model_name}.mp4')
+            print(video_path)
+            results.append(video_path)
+
+        # with concurrent.futures.ThreadPoolExecutor() as executor:
+        #     futures = [executor.submit(self.generate_image_ig, prompt, model) if model.startswith("huggingface")
+        #                else executor.submit(self.generate_image_ig_api, prompt, model) for model in model_names]
+        #     results = [future.result() for future in futures]
+
+        return results[0], results[1], results[2], results[3], \
+            model_names[0], model_names[1], model_names[2], model_names[3]
+
     def generate_image_ig_museum_parallel_anony(self, model_A, model_B, model_C, model_D):
         if model_A == "" and model_B == "" and model_C == "" and model_D == "":
             # model_names = random.sample([model for model in self.model_ig_list], 4)

model/model_registry.py

@@ -45,7 +45,29 @@ def get_model_description_md(model_list):
         ct += 1
     return model_description_md
 
-# regist image generation models
+def get_video_model_description_md(model_list):
+    model_description_md = """
+| | | | | | |
+| ---- | ---- | ---- | ---- | ---- | ---- |
+"""
+    ct = 0
+    visited = set()
+    for i, name in enumerate(model_list):
+        model_source, model_name, model_type = name.split("_")
+        minfo = get_model_info(model_name)
+        if minfo.simple_name in visited:
+            continue
+        visited.add(minfo.simple_name)
+        # one_model_md = f"[{minfo.simple_name}]({minfo.link}): {minfo.description}"
+        one_model_md = f"{minfo.simple_name}"
+
+        if ct % 7 == 0:
+            model_description_md += "|"
+        model_description_md += f" {one_model_md} |"
+        if ct % 7 == 6:
+            model_description_md += "\n"
+        ct += 1
+    return model_description_md
 
 register_model_info(
     ["imagenhub_LCM_generation", "fal_LCM_text2image"],

model/models/__init__.py

@@ -43,11 +43,18 @@ IMAGE_EDITION_MODELS = ['imagenhub_CycleDiffusion_edition', 'imagenhub_Pix2PixZe
                         'imagenhub_SDEdit_edition', 'imagenhub_InstructPix2Pix_edition', 
                         'imagenhub_MagicBrush_edition', 'imagenhub_PNP_edition', 
                         'imagenhub_InfEdit_edition', 'imagenhub_CosXLEdit_edition']
-VIDEO_GENERATION_MODELS = ['fal_AnimateDiff_text2video',
-                           'fal_AnimateDiffTurbo_text2video',
-                           'videogenhub_LaVie_generation', 'videogenhub_VideoCrafter2_generation',
-                           'videogenhub_ModelScope_generation', 'videogenhub_OpenSora_generation']
-
+# VIDEO_GENERATION_MODELS = ['fal_AnimateDiff_text2video',
+#                            'fal_AnimateDiffTurbo_text2video',
+#                            'videogenhub_LaVie_generation', 'videogenhub_VideoCrafter2_generation',
+#                            'videogenhub_ModelScope_generation', 'videogenhub_OpenSora_generation']
+VIDEO_GENERATION_MODELS = ['replicate_Zeroscope-v2-xl_text2video',
+                        #    'replicate_Damo-Text-to-Video_text2video',
+                           'replicate_Animate-Diff_text2video',
+                           'replicate_OpenSora_text2video',
+                           'replicate_LaVie_text2video',
+                           'replicate_VideoCrafter2_text2video',
+                           'replicate_Stable-Video-Diffusion_text2video',
+                           ]
 
 def load_pipeline(model_name):
     """

model/models/huggingface_models.py

@@ -28,9 +28,32 @@ def load_huggingface_model(model_name, model_type):
 
 
 if __name__ == "__main__":
-    for name in ["SD-turbo", "SDXL-turbo"]: #"SD-turbo", "SDXL-turbo"
-        pipe = load_huggingface_model(name, "text2image")
+    # for name in ["SD-turbo", "SDXL-turbo"]: #"SD-turbo", "SDXL-turbo"
+    #     pipe = load_huggingface_model(name, "text2image")
 
     # for name in ["IF-I-XL-v1.0"]:
     #     pipe = load_huggingface_model(name, 'text2image')
-    # pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
+    # pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
+
+    prompt = 'draw a tiger'
+    pipe = load_huggingface_model('Stable-cascade', "text2image")
+    prior, decoder = pipe
+    prior.enable_model_cpu_offload()
+    prior_output = prior(
+        prompt=prompt,
+        height=512,
+        width=512,
+        negative_prompt='',
+        guidance_scale=4.0,
+        num_images_per_prompt=1,
+        num_inference_steps=20
+    )
+    decoder.enable_model_cpu_offload()
+    result = decoder(
+        image_embeddings=prior_output.image_embeddings.to(torch.float16),
+        prompt=prompt,
+        negative_prompt='',
+        guidance_scale=0.0,
+        output_type="pil",
+        num_inference_steps=10
+    ).images[0]

model/models/other_api_models.py

@@ -8,9 +8,9 @@ class OtherModel():
     def __init__(self, model_name, model_type):
         self.model_name = model_name
         self.model_type = model_type
-        self.url = "https://www.xdai.online/mj/submit/imagine"
+        self.image_url = "https://www.xdai.online/mj/submit/imagine"
         self.key = os.environ.get('MIDJOURNEY_KEY')
-        self.get_url = "https://www.xdai.online/mj/image/"
+        self.get_image_url = "https://www.xdai.online/mj/image/"
         self.repeat_num = 5
     
     def __call__(self, *args, **kwargs):
@@ -40,12 +40,12 @@ class OtherModel():
                 "Content-Type": "application/json"
             }
             while 1:
-                response = requests.post(self.url, data=json.dumps(data), headers=headers)
+                response = requests.post(self.image_url, data=json.dumps(data), headers=headers)
                 if response.status_code == 200:
                     print("Submit success!")
                     response_json = json.loads(response.content.decode('utf-8'))
                     img_id = response_json["result"]
-                    result_url = self.get_url + img_id
+                    result_url = self.get_image_url + img_id
                     print(result_url)
                     self.repeat_num = 800
                     while 1:
@@ -70,6 +70,9 @@ class OtherModel():
                     if self.repeat_num == 0:
                         raise ValueError("API request failed.")
                     continue
+        if self.model_type == "text2video":
+            assert "prompt" in kwargs, "prompt is required for text2video model"
+
         else:
             raise ValueError("model_type must be text2image")
 def load_other_model(model_name, model_type):
@@ -77,9 +80,34 @@ def load_other_model(model_name, model_type):
 
 if __name__ == "__main__":
 
-    pipe = load_other_model("Midjourney-v5.0", "text2image")
-    result = pipe(prompt="a good girl")
-    print(result)
+    # pipe = load_other_model("Midjourney-v5.0", "text2image")
+    # result = pipe(prompt="a good girl")
+    # print(result)
 
+    import http.client
+    import json
+    key = os.environ.get('MIDJOURNEY_KEY')
+    prompt = "a good girl"
 
+    conn = http.client.HTTPSConnection("xdai.online")
+    payload = json.dumps({
+    "messages": [
+        {
+            "role": "user",
+            "content": "{}".format(prompt)
+        }
+    ],
+    "stream": True,
+    "model": "luma-video",
+    # "model": "pika-text-to-video",
+    })
+    headers = {
+        'Authorization': "Bearer {}".format(key),
+        'Content-Type': 'application/json'
+    }
+    conn.request("POST", "/v1/chat/completions", payload, headers)
+    res = conn.getresponse()
+    data = res.read()
+    info = data.decode("utf-8")
+    print(data.decode("utf-8"))
     

model/models/replicate_api_models.py

@@ -27,6 +27,14 @@ Replicate_MODEl_NAME_MAP = {
     "SSD-1b": "lucataco/ssd-1b:b19e3639452c59ce8295b82aba70a231404cb062f2eb580ea894b31e8ce5bbb6",
     "Open-Dalle-v1.1": "lucataco/open-dalle-v1.1:1c7d4c8dec39c7306df7794b28419078cb9d18b9213ab1c21fdc46a1deca0144",
     "Deepfloyd-IF": "andreasjansson/deepfloyd-if:fb84d659df149f4515c351e394d22222a94144aa1403870c36025c8b28846c8d",
+
+    "Zeroscope-v2-xl": "anotherjesse/zeroscope-v2-xl:9f747673945c62801b13b84701c783929c0ee784e4748ec062204894dda1a351",
+    # "Damo-Text-to-Video": "cjwbw/damo-text-to-video:1e205ea73084bd17a0a3b43396e49ba0d6bc2e754e9283b2df49fad2dcf95755",
+    "Animate-Diff": "lucataco/animate-diff:beecf59c4aee8d81bf04f0381033dfa10dc16e845b4ae00d281e2fa377e48a9f",
+    "OpenSora": "camenduru/open-sora:8099e5722ba3d5f408cd3e696e6df058137056268939337a3fbe3912e86e72ad",
+    "LaVie": "cjwbw/lavie:0bca850c4928b6c30052541fa002f24cbb4b677259c461dd041d271ba9d3c517",
+    "VideoCrafter2": "lucataco/video-crafter:7757c5775e962c618053e7df4343052a21075676d6234e8ede5fa67c9e43bce0",
+    "Stable-Video-Diffusion": "sunfjun/stable-video-diffusion:d68b6e09eedbac7a49e3d8644999d93579c386a083768235cabca88796d70d82",
     }
 
 class ReplicateModel():
@@ -36,20 +44,6 @@ class ReplicateModel():
         # os.environ['FAL_KEY'] = os.environ['FalAPI']
     
     def __call__(self, *args, **kwargs):
-        # def decode_data_url(data_url):
-        #     # Find the start of the Base64 encoded data
-        #     base64_start = data_url.find(",") + 1
-        #     if base64_start == 0:
-        #         raise ValueError("Invalid data URL provided")
-
-        #     # Extract the Base64 encoded data
-        #     base64_string = data_url[base64_start:]
-
-        #     # Decode the Base64 string
-        #     decoded_bytes = base64.b64decode(base64_string)
-
-        #     return decoded_bytes
-
         if self.model_type == "text2image":
             assert "prompt" in kwargs, "prompt is required for text2image model"
             output  = replicate.run(
@@ -71,60 +65,101 @@ class ReplicateModel():
             print(result_url)
             response = requests.get(result_url)
             result = Image.open(io.BytesIO(response.content))
-            # fal_client.submit(
-            #     f"fal-ai/{FAL_MODEl_NAME_MAP[self.model_name]}",
-            #     arguments={
-            #         "prompt": kwargs["prompt"]
-            #     },
-            # )
-            # for event in handler.iter_events(with_logs=True):
-            #     if isinstance(event, fal_client.InProgress):
-            #         print('Request in progress')
-            #         print(event.logs)
-            # result = handler.get()
-            # print(result)
-            # result_url = result['images'][0]['url']
-            # if self.model_name in ["SDXLTurbo", "LCM(v1.5/XL)"]:
-            #     result_url = io.BytesIO(decode_data_url(result_url))
-            #     result = Image.open(result_url)
-            # else:
-            #     response = requests.get(result_url)
-            #     result = Image.open(io.BytesIO(response.content))
             return result
-        # elif self.model_type == "image2image":
-        #     raise NotImplementedError("image2image model is not implemented yet")
-        #     # 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_client.submit(
-        #     #     f"fal-ai/{self.model_name}",
-        #     #     arguments={
-        #     #         "image_url": image_url
-        #     #     },
-        #     # )
-        #     #
-        #     # for event in handler.iter_events():
-        #     #     if isinstance(event, fal_client.InProgress):
-        #     #         print('Request in progress')
-        #     #         print(event.logs)
-        #     #
-        #     # result = handler.get()
-        #     # return result
-        # elif self.model_type == "text2video":
-        #     assert "prompt" in kwargs, "prompt is required for text2video model"
-        #     if self.model_name == 'AnimateDiff':
-        #         fal_model_name = 'fast-animatediff/text-to-video'
-        #     elif self.model_name == 'AnimateDiffTurbo':
-        #         fal_model_name = 'fast-animatediff/turbo/text-to-video'
-        #     else:
-        #         raise NotImplementedError(f"text2video model of {self.model_name} in fal is not implemented yet")
-        #     handler = fal_client.submit(
-        #         f"fal-ai/{fal_model_name}",
-        #         arguments={
-        #             "prompt": kwargs["prompt"]
-        #         },
-        #     )
+        elif self.model_type == "text2video":
+            assert "prompt" in kwargs, "prompt is required for text2image model"
+            if self.model_name == "Zeroscope-v2-xl":
+                input = {
+                            "fps": 24,
+                            "width": 512,
+                            "height": 512,
+                            "prompt": kwargs["prompt"],
+                            "guidance_scale": 17.5,
+                            # "negative_prompt": "very blue, dust, noisy, washed out, ugly, distorted, broken",
+                            "num_frames": 48,
+                        }
+            elif self.model_name == "Damo-Text-to-Video":
+                input={
+                    "fps": 8,
+                    "prompt": kwargs["prompt"],
+                    "num_frames": 16,
+                    "num_inference_steps": 50
+                }
+            elif self.model_name == "Animate-Diff":
+                input={
+                    "path": "toonyou_beta3.safetensors",
+                    "seed": 255224557,
+                    "steps": 25,
+                    "prompt": kwargs["prompt"],
+                    "n_prompt": "badhandv4, easynegative, ng_deepnegative_v1_75t, verybadimagenegative_v1.3, bad-artist, bad_prompt_version2-neg, teeth",
+                    "motion_module": "mm_sd_v14",
+                    "guidance_scale": 7.5
+                }
+            elif self.model_name == "OpenSora":
+                input={
+                    "seed": 1234,
+                    "prompt": kwargs["prompt"],
+                }
+            elif self.model_name == "LaVie":
+                input={
+                    "width": 512,
+                    "height": 512,
+                    "prompt": kwargs["prompt"],
+                    "quality": 9,
+                    "video_fps": 8,
+                    "interpolation": False,
+                    "sample_method": "ddpm",
+                    "guidance_scale": 7,
+                    "super_resolution": False,
+                    "num_inference_steps": 50
+                }
+            elif self.model_name == "VideoCrafter2":
+                input={
+                    "fps": 24,
+                    "seed": 64045,
+                    "steps": 40,
+                    "width": 512,
+                    "height": 512,
+                    "prompt": kwargs["prompt"],
+                }
+            elif self.model_name == "Stable-Video-Diffusion":
+                text2image_name = "SD-v2.1"
+                output = replicate.run(
+                                        f"{Replicate_MODEl_NAME_MAP[text2image_name]}",
+                                        input={
+                                                "width": 512,
+                                                "height": 512,
+                                                "prompt": kwargs["prompt"]
+                                            },
+                                    )
+                if isinstance(output, list):
+                    image_url = output[0]
+                else:
+                    image_url = output
+                print(image_url)
+
+                input={
+                    "cond_aug": 0.02,
+                    "decoding_t": 14,
+                    "input_image": "{}".format(image_url),
+                    "video_length": "14_frames_with_svd",
+                    "sizing_strategy": "maintain_aspect_ratio",
+                    "motion_bucket_id": 127,
+                    "frames_per_second": 6
+                }
+
+            output  = replicate.run(
+                                    f"{Replicate_MODEl_NAME_MAP[self.model_name]}",
+                                    input=input,
+                                )
+            if isinstance(output, list):
+                result_url = output[0]
+            else:
+                result_url = output
+            print(self.model_name)
+            print(result_url)
+            # response = requests.get(result_url)
+            # result = Image.open(io.BytesIO(response.content))
 
         #     for event in handler.iter_events(with_logs=True):
         #         if isinstance(event, fal_client.InProgress):
@@ -136,6 +171,7 @@ class ReplicateModel():
         #     print(result)
         #     result_url = result['video']['url']
         #     return result_url
+            return result_url
         else:
             raise ValueError("model_type must be text2image or image2image")
 
@@ -146,30 +182,116 @@ def load_replicate_model(model_name, model_type):
 if __name__ == "__main__":
     import replicate
     import time
-    input = {
-        "seed": 1,
-        "width": 512,
-        "height": 512,
-        "grid_size": 1,
-        "prompt": "anime astronaut riding a horse on mars"
-    }
+    import concurrent.futures 
+    import os
+    import requests
+    # model_name = 'replicate_zeroscope-v2-xl_text2video'
+    # model_name = 'replicate_Damo-Text-to-Video_text2video'
+    # model_name = 'replicate_Animate-Diff_text2video'
+    # model_name = 'replicate_open-sora_text2video'
+    # model_name = 'replicate_lavie_text2video'
+    # model_name = 'replicate_video-crafter_text2video'
+    # model_name = 'replicate_stable-video-diffusion_text2video'
+    # model_source, model_name, model_type = model_name.split("_")
+    # pipe = load_replicate_model(model_name, model_type)
+    # prompt = "Clown fish swimming in a coral reef, beautiful, 8k, perfect, award winning, national geographic"
+    # result = pipe(prompt=prompt)
+
+    # url = "https://replicate.delivery/yhqm/ucuUNHBetmQVJiogeNiDpxJoccKxPvxzTXQPZO53azfHfwvMB/out.mp4"
+    # response = requests.get(url, stream=True)
+    # if response.status_code == 200:
+    #     file_path = os.path.join("/mnt/data/lizhikai/ksort_video_cache/", '1.mp4')
+    #     with open(file_path, 'wb') as file:
+    #         for chunk in response.iter_content(chunk_size=8192):
+    #             file.write(chunk)
+    #     print(f"视频 {j} 已保存到 {file_path}")
+
+    file_path = '/home/lizhikai/webvid_prompt100.txt'
+    str_list = []
+    with open(file_path, 'r', encoding='utf-8') as file:
+        for line in file:
+            str_list.append(line.strip())
+            if len(str_list) == 100:
+                break
+
+    def generate_image_ig_api(prompt, model_name):
+        model_source, model_name, model_type = model_name.split("_")
+        pipe = load_replicate_model(model_name, model_type)
+        result = pipe(prompt=prompt)
+        return result
+    model_names = ['replicate_Zeroscope-v2-xl_text2video',
+                        #    'replicate_Damo-Text-to-Video_text2video',
+                           'replicate_Animate-Diff_text2video',
+                           'replicate_OpenSora_text2video',
+                           'replicate_LaVie_text2video',
+                           'replicate_VideoCrafter2_text2video',
+                           'replicate_Stable-Video-Diffusion_text2video',
+                           ]
+    save_names = []
+    for name in model_names:
+        model_source, model_name, model_type = name.split("_")
+        save_names.append(model_name)
+
+    for i, prompt in enumerate(str_list):
+        print("save the {} prompt".format(i+1))
+        # if i+1 < 97:
+        #     continue
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = [executor.submit(generate_image_ig_api, prompt, model) for model in model_names]
+            results = [future.result() for future in futures]
+
+        root_dir = '/mnt/data/lizhikai/ksort_video_cache/'
+        save_dir = os.path.join(root_dir, f'cache_{i+1}')
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir, exist_ok=True)
+        with open(os.path.join(save_dir, "prompt.txt"), 'w', encoding='utf-8') as file:
+            file.write(prompt)
+
+        # 下载视频并保存
+        repeat_num = 5
+        for j, url in enumerate(results):
+            while 1:
+                time.sleep(1)
+                response = requests.get(url, stream=True)
+                if response.status_code == 200:
+                    file_path = os.path.join(save_dir, f'{save_names[j]}.mp4')
+                    with open(file_path, 'wb') as file:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            file.write(chunk)
+                    print(f"视频 {j} 已保存到 {file_path}")
+                    break
+                else:
+                    repeat_num = repeat_num - 1
+                    if repeat_num == 0:
+                        print(f"视频 {j} 保存失败")
+                        # raise ValueError("Video request failed.")
+                    continue
+
+
+    # input = {
+    #     "seed": 1,
+    #     "width": 512,
+    #     "height": 512,
+    #     "grid_size": 1,
+    #     "prompt": "anime astronaut riding a horse on mars"
+    # }
 
 
-    for name, address in Replicate_MODEl_NAME_MAP.items():
-        print('*'*50)
-        print(name)
+    # for name, address in Replicate_MODEl_NAME_MAP.items():
+    #     print('*'*50)
+    #     print(name)
 
-        t1 = time.time()
-        output = replicate.run(
-            address,
-            input=input
-        )
-        # for item in output:
-        #     print(item)
-        print(output)
+    #     t1 = time.time()
+    #     output = replicate.run(
+    #         address,
+    #         input=input
+    #     )
+    #     # for item in output:
+    #     #     print(item)
+    #     print(output)
 
 
-        t2 = time.time()
-        print(t2-t1)
-        print('*'*50)
+    #     t2 = time.time()
+    #     print(t2-t1)
+    #     print('*'*50)
     

serve/Ksort.py

@@ -5,7 +5,7 @@ from .constants import KSORT_IMAGE_DIR
 from .constants import COLOR1, COLOR2, COLOR3, COLOR4
 from .vote_utils import save_any_image
 from .utils import disable_btn, enable_btn, invisible_btn
-from .upload import create_remote_directory, upload_ssh_all
+from .upload import create_remote_directory, upload_ssh_all, upload_ssh_data
 import json
 
 def reset_level(Top_btn):
@@ -149,7 +149,7 @@ def vote_submit(states, textbox, rank, request: gr.Request):
         }
         fout.write(json.dumps(data) + "\n")
 
-def vote_ssh_submit(states, textbox, rank):
+def vote_ssh_submit(states, textbox, rank, user_name, user_institution):
     conv_id = states[0].conv_id
     output_dir = create_remote_directory(conv_id)
     # upload_image(states, output_dir)
@@ -158,6 +158,7 @@ def vote_ssh_submit(states, textbox, rank):
         "models_name": [x.model_name for x in states],
         "img_rank": [x for x in rank],
         "prompt": [textbox],
+        "user_info": {"name": [user_name], "institution": [user_institution]}, 
     }
     output_file = os.path.join(output_dir, "result.json")
     # upload_informance(data, output_file)
@@ -166,12 +167,48 @@ def vote_ssh_submit(states, textbox, rank):
     from .update_skill import update_skill
     update_skill(rank, [x.model_name for x in states])
 
+def vote_video_ssh_submit(states, textbox, prompt_num, rank, user_name, user_institution):
+    conv_id = states[0].conv_id
+    output_dir = create_remote_directory(conv_id, video=True)
+
+    data = {
+        "models_name": [x.model_name for x in states],
+        "video_rank": [x for x in rank],
+        "prompt": [textbox],
+        "prompt_num": [prompt_num],
+        "video_path": [x.output for x in states],
+        "user_info": {"name": [user_name], "institution": [user_institution]}, 
+    }
+    output_file = os.path.join(output_dir, "result.json")
+
+    upload_ssh_data(data, output_file)
+
+    from .update_skill_video import update_skill_video
+    update_skill_video(rank, [x.model_name for x in states])
 
 def submit_response_igm(
-    state0, state1, state2, state3, model_selector0, model_selector1, model_selector2, model_selector3, textbox, rank, request: gr.Request
+    state0, state1, state2, state3, model_selector0, model_selector1, model_selector2, model_selector3, textbox, rank, user_name, user_institution, request: gr.Request
 ):
     # vote_submit([state0, state1, state2, state3], textbox, rank, request)
-    vote_ssh_submit([state0, state1, state2, state3], textbox, rank)
+    vote_ssh_submit([state0, state1, state2, state3], textbox, rank, user_name, user_institution)
+    if model_selector0 == "":
+        return (disable_btn,) * 6 + (
+            gr.Markdown(f"### Model A: {state0.model_name.split('_')[1]}", visible=True),
+            gr.Markdown(f"### Model B: {state1.model_name.split('_')[1]}", visible=True),
+            gr.Markdown(f"### Model C: {state2.model_name.split('_')[1]}", visible=True),
+            gr.Markdown(f"### Model D: {state3.model_name.split('_')[1]}", visible=True)
+            ) + (disable_btn,)
+    else:
+        return (disable_btn,) * 6 + (
+            gr.Markdown(state0.model_name, visible=True),
+            gr.Markdown(state1.model_name, visible=True),
+            gr.Markdown(state2.model_name, visible=True),
+            gr.Markdown(state3.model_name, visible=True)
+            ) + (disable_btn,)
+def submit_response_vg(
+    state0, state1, state2, state3, model_selector0, model_selector1, model_selector2, model_selector3, textbox, prompt_num, rank, user_name, user_institution, request: gr.Request
+):
+    vote_video_ssh_submit([state0, state1, state2, state3], textbox, prompt_num, rank, user_name, user_institution)
     if model_selector0 == "":
         return (disable_btn,) * 6 + (
             gr.Markdown(f"### Model A: {state0.model_name.split('_')[1]}", visible=True),
@@ -186,14 +223,35 @@ def submit_response_igm(
             gr.Markdown(state2.model_name, visible=True),
             gr.Markdown(state3.model_name, visible=True)
             ) + (disable_btn,)
-    
 def submit_response_rank_igm(
-    state0, state1, state2, state3, model_selector0, model_selector1, model_selector2, model_selector3, textbox, rank, right_vote_text, request: gr.Request
+    state0, state1, state2, state3, model_selector0, model_selector1, model_selector2, model_selector3, textbox, rank, right_vote_text, user_name, user_institution, request: gr.Request
 ):
     print(rank)
     if right_vote_text == "right":
         # vote_submit([state0, state1, state2, state3], textbox, rank, request)
-        vote_ssh_submit([state0, state1, state2, state3], textbox, rank)
+        vote_ssh_submit([state0, state1, state2, state3], textbox, rank, user_name, user_institution)
+        if model_selector0 == "":
+            return (disable_btn,) * 16 + (disable_btn,) * 3 + ("wrong",) + (
+                gr.Markdown(f"### Model A: {state0.model_name.split('_')[1]}", visible=True),
+                gr.Markdown(f"### Model B: {state1.model_name.split('_')[1]}", visible=True),
+                gr.Markdown(f"### Model C: {state2.model_name.split('_')[1]}", visible=True),
+                gr.Markdown(f"### Model D: {state3.model_name.split('_')[1]}", visible=True)
+                )
+        else:
+            return (disable_btn,) * 16 + (disable_btn,) * 3 + ("wrong",) + (
+                gr.Markdown(state0.model_name, visible=True),
+                gr.Markdown(state1.model_name, visible=True),
+                gr.Markdown(state2.model_name, visible=True),
+                gr.Markdown(state3.model_name, visible=True)
+                )
+    else:
+        return (enable_btn,) * 16 + (enable_btn,) * 3 + ("wrong",) + (gr.Markdown("", visible=False),) * 4
+def submit_response_rank_vg(
+    state0, state1, state2, state3, model_selector0, model_selector1, model_selector2, model_selector3, textbox, prompt_num, rank, right_vote_text, user_name, user_institution, request: gr.Request
+):
+    print(rank)
+    if right_vote_text == "right":
+        vote_video_ssh_submit([state0, state1, state2, state3], textbox, prompt_num, rank, user_name, user_institution)
         if model_selector0 == "":
             return (disable_btn,) * 16 + (disable_btn,) * 3 + ("wrong",) + (
                 gr.Markdown(f"### Model A: {state0.model_name.split('_')[1]}", visible=True),
@@ -260,37 +318,24 @@ def text_response_rank_igm(generate_ig0, generate_ig1, generate_ig2, generate_ig
     
     return chatbot + [rank_str] + ["right"] + [rank]
 
-# def add_foreground(image, vote_level, Top1_text, Top2_text, Top3_text, Top4_text):
-#     base_image = Image.fromarray(image).convert("RGBA")
-#     if vote_level == 0:
-#         txt_layer = Image.new('RGBA', base_image.size, (0, 255, 0, 64))
-#     elif vote_level == 1:
-#         txt_layer = Image.new('RGBA', base_image.size, (0, 255, 255, 64))
-#     elif vote_level == 2:
-#         txt_layer = Image.new('RGBA', base_image.size, (255, 0, 255, 64))
-#     elif vote_level == 3:
-#         txt_layer = Image.new('RGBA', base_image.size, (255, 0, 0, 64))
-
-#     draw = ImageDraw.Draw(txt_layer)
-#     font = ImageFont.truetype("./serve/Arial.ttf", 86)
+def text_response_rank_vg(vote_textbox):
+    rank_list = [char for char in vote_textbox if char.isdigit()]
+    rank = [None, None, None, None]
+    if len(rank_list) != 4:
+        return ["error rank"] + ["wrong"] + [rank]
+    for num in range(len(rank_list)):
+        if rank_list[num] in ['1', '2', '3', '4']:
+            continue
+        else:
+            return ["error rank"] + ["wrong"] + [rank]
+    rank_str = ""
+    for str_num in rank_list:
+        rank_str = rank_str + str_num
+        rank_str = rank_str + "  "
+    rank = [int(x) for x in rank_list]
     
-#     text_position = (156, 212)
-#     if vote_level == 0:
-#         text_color = (0, 255, 0, 200)  
-#         draw.text(text_position, Top1_text, font=font, fill=text_color)
-#     elif vote_level == 1:
-#         text_color = (0, 255, 255, 200)  
-#         draw.text(text_position, Top2_text, font=font, fill=text_color)
-#     elif vote_level == 2:
-#         text_color = (255, 0, 255, 200)  
-#         draw.text(text_position, Top3_text, font=font, fill=text_color)
-#     elif vote_level == 3:
-#         text_color = (255, 0, 0, 200)  
-#         draw.text(text_position, Top4_text, font=font, fill=text_color)
+    return [rank_str] + ["right"] + [rank]
 
-#     combined = Image.alpha_composite(base_image, txt_layer)
-#     combined = combined.convert("RGB")
-#     return combined
 def add_foreground(image, vote_level, Top1_text, Top2_text, Top3_text, Top4_text):
     base_image = Image.fromarray(image).convert("RGBA")
     base_image = base_image.resize((512, 512), Image.ANTIALIAS)

serve/gradio_web.py

@@ -48,7 +48,7 @@ def set_ssh():
 
 def build_side_by_side_ui_anony(models):
     notice_markdown = """
-# ⚔️  K-Sort-Arena ⚔️
+# ⚔️  K-Sort-Arena (Text-to-Image) ⚔️
 ## 📜 Rules
 - Input prompt to Four anonymous models (e.g., SD, SDXL, OpenJourney in Text-guided Image Generation Model) and vote on the outputs!
 - Two voting mode: Rand Mode and Best Mode. Please feel free to switch them!
@@ -220,7 +220,15 @@ def build_side_by_side_ui_anony(models):
         clear_btn = gr.Button(value="🎲 New Round", interactive=False)
         # regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
         # share_btn = gr.Button(value="📷  Share")
-
+    with gr.Blocks(): 
+        with gr.Row(elem_id="centered-text"): # 
+            user_info = gr.Markdown("User information", visible=True, elem_id="centered-text") #, elem_id="centered-text"
+            # with gr.Blocks(): 
+            # name = gr.Markdown("Name", visible=True)
+            user_name = gr.Textbox(show_label=False,placeholder="👉 Enter your name (optional)", elem_classes="custom-width")
+            # with gr.Blocks(): 
+            # institution = gr.Markdown("Institution", visible=True)
+            user_institution = gr.Textbox(show_label=False,placeholder="👉 Enter your affiliation (optional)", elem_classes="custom-width")
     #gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
     dummy_img_output = gr.Image(width=512, visible=False)
     gr.Examples(
@@ -382,7 +390,7 @@ def build_side_by_side_ui_anony(models):
         outputs=[chatbot_left, chatbot_left1, chatbot_right, chatbot_right1, vote_textbox, right_vote_text, rank]
     ).then(
         submit_response_rank_igm,
-        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rank, right_vote_text],
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rank, right_vote_text, user_name, user_institution],
         outputs=[A1_btn, A2_btn, A3_btn, A4_btn, B1_btn, B2_btn, B3_btn, B4_btn, C1_btn, C2_btn, C3_btn, C4_btn, D1_btn, D2_btn, D3_btn, D4_btn, \
                     vote_textbox, vote_submit_btn, vote_mode_btn, right_vote_text, \
                     model_selector_left, model_selector_left1, model_selector_right, model_selector_right1],
@@ -399,7 +407,7 @@ def build_side_by_side_ui_anony(models):
         outputs=[chatbot_left, chatbot_left1, chatbot_right, chatbot_right1, vote_textbox, right_vote_text, rank]
     ).then(
         submit_response_rank_igm,
-        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rank, right_vote_text],
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rank, right_vote_text, user_name, user_institution],
         outputs=[A1_btn, A2_btn, A3_btn, A4_btn, B1_btn, B2_btn, B3_btn, B4_btn, C1_btn, C2_btn, C3_btn, C4_btn, D1_btn, D2_btn, D3_btn, D4_btn, \
                     vote_textbox, vote_submit_btn, vote_mode_btn, right_vote_text, \
                     model_selector_left, model_selector_left1, model_selector_right, model_selector_right1],
@@ -462,35 +470,35 @@ def build_side_by_side_ui_anony(models):
 
     leftvote_btn.click(
         submit_response_igm,
-        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankA],
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankA, user_name, user_institution],
         outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
                  model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
                  vote_mode_btn]
     )
     left1vote_btn.click(
         submit_response_igm,
-        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankB],
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankB, user_name, user_institution],
         outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
                  model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
                  vote_mode_btn]
     )
     rightvote_btn.click(
         submit_response_igm,
-        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankC],
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankC, user_name, user_institution],
         outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
                  model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
                  vote_mode_btn]
     )
     right1vote_btn.click(
         submit_response_igm,
-        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankD],
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankD, user_name, user_institution],
         outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
                  model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
                  vote_mode_btn]
     )
     tie_btn.click(
         submit_response_igm,
-        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankTie],
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, rankTie, user_name, user_institution],
         outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
                  model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
                  vote_mode_btn]

serve/gradio_web_video.py

@@ -0,0 +1,611 @@
+from .utils import *
+from .vote_utils import (
+    upvote_last_response_ig as upvote_last_response,
+    downvote_last_response_ig as downvote_last_response,
+    flag_last_response_ig as flag_last_response,
+    leftvote_last_response_igm as leftvote_last_response,
+    left1vote_last_response_igm as left1vote_last_response,
+    rightvote_last_response_igm as rightvote_last_response,
+    right1vote_last_response_igm as right1vote_last_response,
+    tievote_last_response_igm as tievote_last_response,
+    bothbad_vote_last_response_igm as bothbad_vote_last_response,
+    share_click_igm as share_click,
+    generate_igv_annoy,
+    share_js
+)
+from .Ksort import (
+    add_foreground,
+    reset_level,
+    reset_rank,
+    revote_windows,
+    submit_response_vg,
+    submit_response_rank_vg,
+    reset_submit,
+    clear_rank,
+    reset_mode,
+    reset_chatbot,
+    reset_btn_rank,
+    reset_vote_text,
+    text_response_rank_vg,
+    check_textbox,
+)
+
+from functools import partial
+from serve.constants import SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD
+from serve.upload import get_random_webvid_prompt, create_ssh_client
+from serve.update_skill import create_ssh_skill_client
+from model.matchmaker import create_ssh_matchmaker_client
+
+def build_side_by_side_video_ui_anony(models):
+    notice_markdown = """
+# ⚔️  K-Sort-Arena (Text-to-Video) ⚔️
+## 📜 Rules
+- Input prompt to Four anonymous models (e.g., OpenSora, StableVideoDiffusion in Text-guided Video Generation Model) and vote on the outputs!
+- Two voting mode: Rand Mode and Best Mode. Please feel free to switch them!
+- Users are encouraged to make evaluations based on subjective preferences. As an aid, they can refer to the following criteria: Alignment (50%) + Aesthetics (50%).
+    - Alignment includes: Video Content Matching (30%) + Inter-frame Consistency (20%);
+    - Aesthetics includes: Photorealism (30%) + Physical Correctness (10%) + Absence of Artifacts (10%).
+
+## 👇 Generating now!
+
+"""
+
+    model_list = models.model_vg_list
+
+    state0 = gr.State()
+    state1 = gr.State()
+    state2 = gr.State()
+    state3 = gr.State()
+
+    gen_func = partial(generate_igv_annoy, models.generate_video_ig_parallel_anony)
+    # gen_func_random = partial(generate_igm_annoy_museum, models.generate_image_ig_museum_parallel_anony)
+    
+    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_video_model_description_md(model_list)
+            gr.Markdown(model_description_md, elem_id="model_description_markdown")
+        with gr.Row():
+            with gr.Column():
+                chatbot_left = gr.Video(width=512, label = "Model A", autoplay=True)
+            with gr.Column():
+                chatbot_left1 = gr.Video(width=512, label = "Model B", autoplay=True)
+            with gr.Column():
+                chatbot_right = gr.Video(width=512, label = "Model C", autoplay=True)
+            with gr.Column():
+                chatbot_right1 = gr.Video(width=512, label = "Model D", autoplay=True)
+
+        with gr.Row():
+            with gr.Column():
+                model_selector_left = gr.Markdown("", visible=False)
+            with gr.Column():
+                model_selector_left1 = gr.Markdown("", visible=False)
+            with gr.Column():
+                model_selector_right = gr.Markdown("", visible=False)
+            with gr.Column():
+                model_selector_right1 = gr.Markdown("", visible=False)
+        with gr.Row():
+            slow_warning = gr.Markdown("", elem_id="notice_markdown")
+
+        with gr.Row(elem_classes="row"):
+            with gr.Column(scale=1, min_width=10):
+                leftvote_btn = gr.Button(
+                    value="A is Best", visible=False, interactive=False, elem_id="btncolor1", elem_classes="best-button"
+                )
+            with gr.Column(scale=1, min_width=10):
+                left1vote_btn = gr.Button(
+                    value="B is Best", visible=False, interactive=False, elem_id="btncolor1", elem_classes="best-button"
+                )
+            with gr.Column(scale=1, min_width=10):
+                rightvote_btn = gr.Button(
+                    value="C is Best", visible=False, interactive=False, elem_id="btncolor1", elem_classes="best-button"
+                )
+            with gr.Column(scale=1, min_width=10):
+                right1vote_btn = gr.Button(
+                    value="D is Best", visible=False, interactive=False, elem_id="btncolor1", elem_classes="best-button"
+                )
+            with gr.Column(scale=1, min_width=10):
+                tie_btn = gr.Button(
+                    value="🤝  Tie", visible=False, interactive=False, elem_id="btncolor2", elem_classes="best-button"
+                )
+
+        with gr.Row():
+            with gr.Blocks():
+                with gr.Row():
+                    with gr.Column(scale=1, min_width=10):
+                        A1_btn = gr.Button(
+                            value="1", visible=False, interactive=False, elem_id="btncolor1", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        A2_btn = gr.Button(
+                            value="2", visible=False, interactive=False, elem_id="btncolor2", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        A3_btn = gr.Button(
+                            value="3", visible=False, interactive=False, elem_id="btncolor3", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        A4_btn = gr.Button(
+                            value="4", visible=False, interactive=False, elem_id="btncolor4", elem_classes="custom-button"
+                        )
+            with gr.Blocks(): 
+                with gr.Row():
+                    with gr.Column(scale=1, min_width=10):
+                        B1_btn = gr.Button(
+                            value="1", visible=False, interactive=False, elem_id="btncolor1", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        B2_btn = gr.Button(
+                            value="2", visible=False, interactive=False, elem_id="btncolor2", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        B3_btn = gr.Button(
+                            value="3", visible=False, interactive=False, elem_id="btncolor3", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        B4_btn = gr.Button(
+                            value="4", visible=False, interactive=False, elem_id="btncolor4", elem_classes="custom-button"
+                        )
+            with gr.Blocks(): 
+                with gr.Row():
+                    with gr.Column(scale=1, min_width=10):
+                        C1_btn = gr.Button(
+                            value="1", visible=False, interactive=False, elem_id="btncolor1", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        C2_btn = gr.Button(
+                            value="2", visible=False, interactive=False, elem_id="btncolor2", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        C3_btn = gr.Button(
+                            value="3", visible=False, interactive=False, elem_id="btncolor3", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        C4_btn = gr.Button(
+                            value="4", visible=False, interactive=False, elem_id="btncolor4", elem_classes="custom-button"
+                        )
+            with gr.Blocks(): 
+                with gr.Row():
+                    with gr.Column(scale=1, min_width=10):
+                        D1_btn = gr.Button(
+                            value="1", visible=False, interactive=False, elem_id="btncolor1", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        D2_btn = gr.Button(
+                            value="2", visible=False, interactive=False, elem_id="btncolor2", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        D3_btn = gr.Button(
+                            value="3", visible=False, interactive=False, elem_id="btncolor3", elem_classes="custom-button"
+                        )
+                    with gr.Column(scale=1, min_width=10):
+                        D4_btn = gr.Button(
+                            value="4", visible=False, interactive=False, elem_id="btncolor4", elem_classes="custom-button"
+                        )
+
+    with gr.Row():
+        vote_textbox = gr.Textbox(
+            show_label=False,
+            placeholder="👉 Enter your rank",
+            container=True,
+            elem_id="input_box",
+            visible=False,
+        )
+        vote_submit_btn = gr.Button(value="Submit", visible=False, interactive=False, variant="primary", scale=0, elem_id="btnpink", elem_classes="submit-button")
+        vote_mode_btn = gr.Button(value="🔄 Mode", visible=False, interactive=False, variant="primary", scale=0, elem_id="btnpink", elem_classes="submit-button")
+
+    with gr.Row():
+        textbox = gr.Textbox(
+            show_label=False,
+            placeholder="👉 Generate the rand prompt and Send",
+            container=True,
+            elem_id="input_box",
+            interactive=False,
+        )
+
+        send_btn = gr.Button(value="Send", variant="primary", scale=0, elem_id="btnblue")
+        draw_btn = gr.Button(value="🎲 Random Prompt", variant="primary", scale=0, elem_id="btnblue")
+    with gr.Row():
+        clear_btn = gr.Button(value="🎲 New Round", interactive=False)
+    with gr.Blocks(): 
+        with gr.Row(elem_id="centered-text"): # 
+            user_info = gr.Markdown("User information", visible=True, elem_id="centered-text") #, elem_id="centered-text"
+            # with gr.Blocks(): 
+            # name = gr.Markdown("Name", visible=True)
+            user_name = gr.Textbox(show_label=False,placeholder="👉 Enter your name (optional)", elem_classes="custom-width")
+            # with gr.Blocks(): 
+            # institution = gr.Markdown("Institution", visible=True)
+            user_institution = gr.Textbox(show_label=False,placeholder="👉 Enter your affiliation (optional)", elem_classes="custom-width")
+
+    prompt_num = gr.Number(value=0, visible=False, interactive=False) # record the num of prompt
+    #gr.Markdown(acknowledgment_md, elem_id="ack_markdown")
+    example1_text = gr.Textbox(value="Chef with recipe book watching young cook preparing dish in the kitchen.", visible=False, interactive=False)
+    example2_text = gr.Textbox(value="A baker turns freshly baked loaves of sourdough bread.", visible=False, interactive=False)
+    example3_text = gr.Textbox(value="Dense fog glows orange and covers hills at dawn.", visible=False, interactive=False)
+    example4_text = gr.Textbox(value="Happy extended family on the sofa at home.", visible=False, interactive=False)
+    dummy_video_output = gr.Video(width=512, visible=False)
+    gr.Examples(
+        examples=[["Chef with recipe book watching young cook preparing dish in the kitchen.", os.path.join("./examples", "video_example1.mp4")],
+                  ["A baker turns freshly baked loaves of sourdough bread.", os.path.join("./examples", "video_example2.mp4")],
+                  ["Dense fog glows orange and covers hills at dawn.",os.path.join("./examples", "video_example3.mp4")],
+                  ["Happy extended family on the sofa at home.", os.path.join("./examples", "video_example4.mp4")]],
+        inputs = [textbox, dummy_video_output])
+
+    order_btn_list = [textbox, send_btn, draw_btn, clear_btn]
+    vote_order_list = [leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
+                       A1_btn, A2_btn, A3_btn, A4_btn, B1_btn, B2_btn, B3_btn, B4_btn, C1_btn, C2_btn, C3_btn, C4_btn, D1_btn, D2_btn, D3_btn, D4_btn, \
+                       vote_textbox, vote_submit_btn, vote_mode_btn]
+
+    generate_ig0 = gr.Video(width=512, label = "generate A", visible=False, interactive=False)
+    generate_ig1 = gr.Video(width=512, label = "generate B", visible=False, interactive=False)
+    generate_ig2 = gr.Video(width=512, label = "generate C", visible=False, interactive=False)
+    generate_ig3 = gr.Video(width=512, label = "generate D", visible=False, interactive=False)
+    dummy_left_model = gr.State("")
+    dummy_left1_model = gr.State("")
+    dummy_right_model = gr.State("")
+    dummy_right1_model = gr.State("")
+
+    ig_rank = [None, None, None, None]
+    bastA_rank = [0, 3, 3, 3]
+    bastB_rank = [3, 0, 3, 3]
+    bastC_rank = [3, 3, 0, 3]
+    bastD_rank = [3, 3, 3, 0]
+    tie_rank = [0, 0, 0, 0]
+    rank = gr.State(ig_rank)
+    rankA = gr.State(bastA_rank)
+    rankB = gr.State(bastB_rank)
+    rankC = gr.State(bastC_rank)
+    rankD = gr.State(bastD_rank)
+    rankTie = gr.State(tie_rank)
+    Top1_text = gr.Textbox(value="Top 1", visible=False, interactive=False)
+    Top2_text = gr.Textbox(value="Top 2", visible=False, interactive=False)
+    Top3_text = gr.Textbox(value="Top 3", visible=False, interactive=False)
+    Top4_text = gr.Textbox(value="Top 4", visible=False, interactive=False)
+    window1_text = gr.Textbox(value="Model A", visible=False, interactive=False)
+    window2_text = gr.Textbox(value="Model B", visible=False, interactive=False)
+    window3_text = gr.Textbox(value="Model C", visible=False, interactive=False)
+    window4_text = gr.Textbox(value="Model D", visible=False, interactive=False)
+    vote_level = gr.Number(value=0, visible=False, interactive=False) # record the level of now object
+    vote_mode = gr.Textbox(value="Rank", visible=False, interactive=False)
+    right_vote_text = gr.Textbox(value="wrong", visible=False, interactive=False)
+
+    send_btn.click(
+        disable_video_order_buttons,
+        inputs=[textbox, example1_text, example2_text, example3_text, example4_text],
+        outputs=[textbox, send_btn, draw_btn, clear_btn, prompt_num]
+    ).then(
+        gen_func, # 修改为调取函数而不是生成函数
+        inputs=[state0, state1, state2, state3, textbox, prompt_num, model_selector_left, model_selector_left1, model_selector_right, model_selector_right1],
+        outputs=[state0, state1, state2, state3, generate_ig0, generate_ig1, generate_ig2, generate_ig3, chatbot_left, chatbot_left1, chatbot_right, chatbot_right1, \
+                 model_selector_left, model_selector_left1, model_selector_right, model_selector_right1],
+        api_name="send_btn_annony"
+    ).then(
+        enable_vote_mode_buttons,
+        inputs=[vote_mode, textbox],
+        outputs=vote_order_list
+    )
+
+    draw_btn.click(
+        get_random_webvid_prompt,
+        inputs=None, 
+        outputs=[prompt_num, textbox],
+        api_name="draw_btn_annony"
+    )
+
+    clear_btn.click(
+        clear_history_side_by_side_anony, 
+        inputs=None, 
+        outputs=[state0, state1, state2, state3, textbox, vote_textbox, chatbot_left, chatbot_left1, chatbot_right, chatbot_right1, \
+                 model_selector_left, model_selector_left1, model_selector_right, model_selector_right1],
+        api_name="clear_btn_annony"
+    ).then(
+        enable_order_buttons,
+        inputs=None,
+        outputs=order_btn_list
+    ).then(
+        clear_rank,
+        inputs=[rank, vote_level],
+        outputs=[rank, vote_level]
+    ).then(
+        disable_vote_mode_buttons,
+        inputs=None,
+        outputs=vote_order_list
+    )
+    
+    vote_mode_btn.click(
+        reset_chatbot,
+        inputs=[vote_mode, generate_ig0, generate_ig1, generate_ig2, generate_ig3], 
+        outputs=[chatbot_left, chatbot_left1, chatbot_right, chatbot_right1]
+    ).then(
+        reset_mode, 
+        inputs=[vote_mode], 
+        outputs=[leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
+                    A1_btn, A2_btn, A3_btn, A4_btn, B1_btn, B2_btn, B3_btn, B4_btn, C1_btn, C2_btn, C3_btn, C4_btn, D1_btn, D2_btn, D3_btn, D4_btn, \
+                    vote_textbox, vote_submit_btn, vote_mode_btn, vote_mode]
+    )
+
+    vote_textbox.submit(
+        disable_vote,
+        inputs=None,
+        outputs=[vote_submit_btn, vote_mode_btn, \
+                 A1_btn, A2_btn, A3_btn, A4_btn, B1_btn, B2_btn, B3_btn, B4_btn, C1_btn, C2_btn, C3_btn, C4_btn, D1_btn, D2_btn, D3_btn, D4_btn]
+    ).then(
+        text_response_rank_vg,
+        inputs=[vote_textbox], 
+        outputs=[vote_textbox, right_vote_text, rank]
+    ).then(
+        submit_response_rank_vg,
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, prompt_num, rank, right_vote_text, user_name, user_institution],
+        outputs=[A1_btn, A2_btn, A3_btn, A4_btn, B1_btn, B2_btn, B3_btn, B4_btn, C1_btn, C2_btn, C3_btn, C4_btn, D1_btn, D2_btn, D3_btn, D4_btn, \
+                    vote_textbox, vote_submit_btn, vote_mode_btn, right_vote_text, \
+                    model_selector_left, model_selector_left1, model_selector_right, model_selector_right1],
+        api_name="submit_btn_annony"
+    ) 
+
+    vote_submit_btn.click(
+        disable_vote,
+        inputs=None,
+        outputs=[vote_submit_btn, vote_mode_btn, \
+                 A1_btn, A2_btn, A3_btn, A4_btn, B1_btn, B2_btn, B3_btn, B4_btn, C1_btn, C2_btn, C3_btn, C4_btn, D1_btn, D2_btn, D3_btn, D4_btn]
+    ).then(
+        text_response_rank_vg,
+        inputs=[vote_textbox], 
+        outputs=[vote_textbox, right_vote_text, rank]
+    ).then(
+        submit_response_rank_vg,
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, prompt_num, rank, right_vote_text, user_name, user_institution],
+        outputs=[A1_btn, A2_btn, A3_btn, A4_btn, B1_btn, B2_btn, B3_btn, B4_btn, C1_btn, C2_btn, C3_btn, C4_btn, D1_btn, D2_btn, D3_btn, D4_btn, \
+                    vote_textbox, vote_submit_btn, vote_mode_btn, right_vote_text, \
+                    model_selector_left, model_selector_left1, model_selector_right, model_selector_right1],
+        api_name="submit_btn_annony"
+    ) 
+
+
+    leftvote_btn.click(
+        submit_response_vg,
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, prompt_num, rankA, user_name, user_institution],
+        outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
+                 model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
+                 vote_mode_btn]
+    )
+    left1vote_btn.click(
+        submit_response_vg,
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, prompt_num, rankB, user_name, user_institution],
+        outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
+                 model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
+                 vote_mode_btn]
+    )
+    rightvote_btn.click(
+        submit_response_vg,
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, prompt_num, rankC, user_name, user_institution],
+        outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
+                 model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
+                 vote_mode_btn]
+    )
+    right1vote_btn.click(
+        submit_response_vg,
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, prompt_num, rankD, user_name, user_institution],
+        outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
+                 model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
+                 vote_mode_btn]
+    )
+    tie_btn.click(
+        submit_response_vg,
+        inputs=[state0, state1, state2, state3, dummy_left_model, dummy_left1_model, dummy_right_model, dummy_right1_model, textbox, prompt_num, rankTie, user_name, user_institution],
+        outputs=[textbox, leftvote_btn, left1vote_btn, rightvote_btn, right1vote_btn, tie_btn, \
+                 model_selector_left, model_selector_left1, model_selector_right, model_selector_right1, \
+                 vote_mode_btn]
+    )
+
+    A1_btn.click(
+        reset_btn_rank, 
+        inputs=[window1_text, rank, A1_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    A2_btn.click(
+        reset_btn_rank, 
+        inputs=[window1_text, rank, A2_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    A3_btn.click(
+        reset_btn_rank, 
+        inputs=[window1_text, rank, A3_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    A4_btn.click(
+        reset_btn_rank, 
+        inputs=[window1_text, rank, A4_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    
+    B1_btn.click(
+        reset_btn_rank, 
+        inputs=[window2_text, rank, B1_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    B2_btn.click(
+        reset_btn_rank, 
+        inputs=[window2_text, rank, B2_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    B3_btn.click(
+        reset_btn_rank, 
+        inputs=[window2_text, rank, B3_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    B4_btn.click(
+        reset_btn_rank, 
+        inputs=[window2_text, rank, B4_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+
+    C1_btn.click(
+        reset_btn_rank, 
+        inputs=[window3_text, rank, C1_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    C2_btn.click(
+        reset_btn_rank, 
+        inputs=[window3_text, rank, C2_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    C3_btn.click(
+        reset_btn_rank, 
+        inputs=[window3_text, rank, C3_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    C4_btn.click(
+        reset_btn_rank, 
+        inputs=[window3_text, rank, C4_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+
+    D1_btn.click(
+        reset_btn_rank, 
+        inputs=[window4_text, rank, D1_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    D2_btn.click(
+        reset_btn_rank, 
+        inputs=[window4_text, rank, D2_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    D3_btn.click(
+        reset_btn_rank, 
+        inputs=[window4_text, rank, D3_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )
+    D4_btn.click(
+        reset_btn_rank, 
+        inputs=[window4_text, rank, D4_btn, vote_level], 
+        outputs=[rank, vote_level]
+    ).then(
+        reset_submit,
+        inputs = [rank],
+        outputs = [vote_submit_btn]
+    ).then(
+        reset_vote_text,
+        inputs = [rank],
+        outputs = [vote_textbox]
+    )

serve/leaderboard.py

@@ -36,103 +36,59 @@ from datetime import datetime
 
 def make_leaderboard_md():
     leaderboard_md = f"""
-# 🏆 K-Sort-Arena Leaderboard
+# 🏆 K-Sort-Arena Leaderboard (Text-to-Image)
 """
+    return leaderboard_md
 
+def make_leaderboard_video_md():
+    leaderboard_md = f"""
+# 🏆 K-Sort-Arena Leaderboard (Text-to-Video)
+"""
     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 make_arena_leaderboard_md(total_models, total_votes):
-    last_updated = datetime.now()
-    last_updated = last_updated.strftime("%Y-%m-%d")
+def make_arena_leaderboard_md(total_models, total_votes, last_updated):
+    # last_updated = datetime.now()
+    # last_updated = last_updated.strftime("%Y-%m-%d")
 
     leaderboard_md = f"""
-Total #models: **{total_models}**(anonymous). Total #votes: **{total_votes}** (Equivalent to **{total_votes*6}** votes for one-on-one games). 
+Total #models: **{total_models}** (anonymous). Total #votes: **{total_votes}** (Equivalent to **{total_votes*6}** votes for one-on-one games). 
 \n Last updated: {last_updated}.
 """
 
     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 Score", 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,
-                )
-
-        if not show_plot:
-            gr.Markdown(
-                """ ## The leaderboard is updated frequently and continues to incorporate new models. 
-                """,
-                elem_id="leaderboard_markdown",
-            )
-    else:
-        pass
-
-    leader_component_values[:] = [md, p1, p2, p3, p4]
+def make_disclaimer_md():
+    disclaimer_md = f'''
+        <div id="modal" style="display:none; position:fixed; top:50%; left:50%; transform:translate(-50%, -50%); padding:20px; background:white; box-shadow:0 0 10px rgba(0,0,0,0.5); z-index:1000;">
+            <p style="font-size:24px;"><strong>Disclaimer</strong></p>
+            <p style="font-size:18px;"><b>Purpose and Scope</b></b></p>
+            <p><b>This platform is designed for academic use, providing a space for evaluating and comparing Visual Generation Models. The information and services provided are intended for research and educational purposes only.</b></p>
 
+            <p style="font-size:18px;"><b>Privacy and Data Protection</b></p>
+            <p><b>While users may voluntarily submit their names and institutional affiliations, this information is not required and is collected solely for the purpose of academic recognition. Personal information submitted to this platform will be handled with care and used solely for the intended academic purposes. We are committed to protecting your privacy, and we will not share personal data with third parties without explicit consent.</b></p>
 
-    from .utils import acknowledgment_md
+            <p style="font-size:18px;"><b>Source of Models</b></p>
+            <p><b>All models evaluated and displayed on this platform are obtained from official sources, including but not limited to official repositories and Replicate.</b></p>
 
-    gr.Markdown(acknowledgment_md)
+            <p style="font-size:18px;"><b>Limitations of Liability</b></p>
+            <p><b>The platform and its administrators do not assume any legal liability for the use or interpretation of the information provided. The evaluations and comparisons are for academic purposes. Users should verify the information independently and must not use the platform for any illegal, harmful, violent, racist, or sexual purposes.</b></p>
 
-    # return [md_1, plot_1, plot_2, plot_3, plot_4]
-    return [md_1]
-'''
+            <p style="font-size:18px;"><b>Modification of Terms</b></p>
+            <p><b>We reserve the right to modify these terms at any time. Users will be notified of significant changes through updates on the platform.</b></p>
 
+            <p style="font-size:18px;"><b>Contact Information</b></p>
+            <p><b>For any questions or to report issues, please contact us at info@ksort.org.</b></p>
+        </div>
+        <div id="overlay" style="display:none; position:fixed; top:0; left:0; width:100%; height:100%; background:rgba(0,0,0,0.5); z-index:999;" onclick="document.getElementById('modal').style.display='none'; document.getElementById('overlay').style.display='none'"></div>
+        <p> ⚠️ This platform is designed for academic usage, for details please refer to <a href="#" id="open_link" onclick="document.getElementById('modal').style.display='block'; document.getElementById('overlay').style.display='block'">disclaimer</a>.</p>
+        '''
+    
+    return disclaimer_md
 
 
 def make_arena_leaderboard_data(results):
@@ -146,12 +102,42 @@ def build_leaderboard_tab(score_result_file = 'sorted_score_list.json'):
     score_results = data["sorted_score_list"]
     total_models = data["total_models"]
     total_votes = data["total_votes"]
+    last_updated = data["last_updated"]
 
     md = make_leaderboard_md()
     md_1 = gr.Markdown(md, elem_id="leaderboard_markdown")
+    gr.HTML(make_disclaimer_md)
+
+    with gr.Tab("Arena Score", id=0):
+        md = make_arena_leaderboard_md(total_models, total_votes, last_updated)
+        gr.Markdown(md, elem_id="leaderboard_markdown")
+        md = make_arena_leaderboard_data(score_results)
+        gr.Dataframe(md)
+    
+    gr.Markdown(
+                """ ## The leaderboard is updated frequently and continues to incorporate new models. 
+                """,
+                elem_id="leaderboard_markdown",
+            )
+    from .utils import acknowledgment_md, html_code
+    with gr.Blocks():
+        gr.Markdown(acknowledgment_md)
+
+
+def build_leaderboard_video_tab(score_result_file = 'sorted_score_list_video.json'):
+    with open(score_result_file, "r") as json_file:
+        data = json.load(json_file)
+    score_results = data["sorted_score_list"]
+    total_models = data["total_models"]
+    total_votes = data["total_votes"]
+    last_updated = data["last_updated"]
+
+    md = make_leaderboard_video_md()
+    md_1 = gr.Markdown(md, elem_id="leaderboard_markdown")
+    gr.HTML(make_disclaimer_md)
 
     with gr.Tab("Arena Score", id=0):
-        md = make_arena_leaderboard_md(total_models, total_votes)
+        md = make_arena_leaderboard_md(total_models, total_votes, last_updated)
         gr.Markdown(md, elem_id="leaderboard_markdown")
         md = make_arena_leaderboard_data(score_results)
         gr.Dataframe(md)
@@ -161,5 +147,6 @@ def build_leaderboard_tab(score_result_file = 'sorted_score_list.json'):
                 """,
                 elem_id="leaderboard_markdown",
             )
-    from .utils import acknowledgment_md
-    gr.Markdown(acknowledgment_md)
+    from .utils import acknowledgment_md, html_code
+    with gr.Blocks():
+        gr.Markdown(acknowledgment_md)

serve/update_skill_video.py

@@ -0,0 +1,107 @@
+import numpy as np
+import json
+from trueskill import TrueSkill
+import paramiko
+import io, os
+import sys
+from serve.constants import SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD, SSH_VIDEO_SKILL
+trueskill_env = TrueSkill()
+sys.path.append('../')
+from model.models import VIDEO_GENERATION_MODELS
+
+ssh_skill_client = None
+sftp_skill_client = None
+
+def create_ssh_skill_client(server, port, user, password):
+    global ssh_skill_client, sftp_skill_client
+    ssh_skill_client = paramiko.SSHClient()
+    ssh_skill_client.load_system_host_keys()
+    ssh_skill_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    ssh_skill_client.connect(server, port, user, password)
+
+    transport = ssh_skill_client.get_transport()
+    transport.set_keepalive(60)
+
+    sftp_skill_client = ssh_skill_client.open_sftp()
+def is_connected():
+    global ssh_skill_client, sftp_skill_client
+    if ssh_skill_client is None or sftp_skill_client is None:
+        return False
+    # 检查SSH连接是否正常
+    if not ssh_skill_client.get_transport().is_active():
+        return False
+    # 检查SFTP连接是否正常
+    try:
+        sftp_skill_client.listdir('.')  # 尝试列出根目录
+    except Exception as e:
+        print(f"Error checking SFTP connection: {e}")
+        return False
+    return True
+def ucb_score(trueskill_diff, t, n):
+    exploration_term = np.sqrt((2 * np.log(t + 1e-5)) / (n + 1e-5))
+    ucb = -trueskill_diff + 1.0 * exploration_term
+    return ucb
+
+def update_trueskill(ratings, ranks):
+    new_ratings = trueskill_env.rate(ratings, ranks)
+    return new_ratings
+
+def serialize_rating(rating):
+    return {'mu': rating.mu, 'sigma': rating.sigma}
+
+def deserialize_rating(rating_dict):
+    return trueskill_env.Rating(mu=rating_dict['mu'], sigma=rating_dict['sigma'])
+
+
+def save_json_via_sftp(ratings, comparison_counts, total_comparisons):
+    global sftp_skill_client
+    if not is_connected():
+        create_ssh_skill_client(SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD)
+    data = {
+        'ratings': [serialize_rating(r) for r in ratings],
+        'comparison_counts': comparison_counts.tolist(),
+        'total_comparisons': total_comparisons
+    }  
+    json_data = json.dumps(data)
+    with sftp_skill_client.open(SSH_VIDEO_SKILL, 'w') as f:
+        f.write(json_data)
+
+def load_json_via_sftp():
+    global sftp_skill_client
+    if not is_connected():
+        create_ssh_skill_client(SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD)
+    with sftp_skill_client.open(SSH_VIDEO_SKILL, 'r') as f:
+        data = json.load(f)
+    ratings = [deserialize_rating(r) for r in data['ratings']]
+    comparison_counts = np.array(data['comparison_counts'])
+    total_comparisons = data['total_comparisons']
+    return ratings, comparison_counts, total_comparisons
+
+
+def update_skill_video(rank, model_names, k_group=4):
+
+    ratings, comparison_counts, total_comparisons = load_json_via_sftp()
+
+    # group = Model_ID.group
+    group = []
+    for model_name in model_names:
+        group.append(VIDEO_GENERATION_MODELS.index(model_name))
+    print(group)
+
+    pairwise_comparisons = [(i, j) for i in range(len(group)) for j in range(i+1, len(group))]
+    for player1, player2 in pairwise_comparisons:
+        if rank[player1] < rank[player2]:
+            ranks = [0, 1]
+            updated_ratings = update_trueskill([[ratings[group[player1]]], [ratings[group[player2]]]], ranks)
+            ratings[group[player1]], ratings[group[player2]] = updated_ratings[0][0], updated_ratings[1][0]
+        elif rank[player1] > rank[player2]:
+            ranks = [1, 0]
+            updated_ratings = update_trueskill([[ratings[group[player1]]], [ratings[group[player2]]]], ranks)
+            ratings[group[player1]], ratings[group[player2]] = updated_ratings[0][0], updated_ratings[1][0]
+            
+        comparison_counts[group[player1], group[player2]] += 1
+        comparison_counts[group[player2], group[player1]] += 1
+    
+    total_comparisons += 1
+
+    save_json_via_sftp(ratings, comparison_counts, total_comparisons)

serve/upload.py

@@ -1,12 +1,13 @@
 import paramiko
 import numpy as np
 import io, os
+import gradio as gr
 from PIL import Image
 import requests
 import json
 import random
 import concurrent.futures
-from .constants import SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD, SSH_LOG, SSH_MSCOCO
+from .constants import SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD, SSH_LOG, SSH_VIDEO_LOG, SSH_MSCOCO
 
 ssh_client = None
 sftp_client = None
@@ -71,26 +72,38 @@ def get_image_from_url(image_url):
 
 def get_random_mscoco_prompt():
 
-    file_path = './sum_prompt.txt'
+    file_path = './coco_prompt.txt'
     with open(file_path, 'r') as file:
         lines = file.readlines()
 
     random_line = random.choice(lines).strip()
     return random_line
+def get_random_webvid_prompt():
 
+    file_path = './webvid_prompt.txt'
+    with open(file_path, 'r', encoding='utf-8') as file:
+        lines = file.readlines()
+    line_number = random.randint(0, len(lines) - 1)
+    print(line_number + 1)
+    random_line = lines[line_number].strip()
+    print(random_line)
+    return line_number + 1, random_line
 
-def create_remote_directory(remote_directory):
+def create_remote_directory(remote_directory, video=False):
     global ssh_client
     if not is_connected():
         create_ssh_client(SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD)
-    stdin, stdout, stderr = ssh_client.exec_command(f'mkdir -p {SSH_LOG}/{remote_directory}')
+    if video:
+        log_dir = f'{SSH_VIDEO_LOG}/{remote_directory}'
+    else:
+        log_dir = f'{SSH_LOG}/{remote_directory}'
+    stdin, stdout, stderr = ssh_client.exec_command(f'mkdir -p {log_dir}')
     error = stderr.read().decode('utf-8')
     if error:
         print(f"Error: {error}")
     else:
         print(f"Directory {remote_directory} created successfully.")
-    return f'{SSH_LOG}/{remote_directory}'
-
+    return log_dir
 
 def upload_images(i, image_list, output_file_list, sftp_client):
     with sftp_client as sftp:
@@ -122,19 +135,21 @@ def upload_ssh_all(states, output_dir, data, data_path):
     with concurrent.futures.ThreadPoolExecutor() as executor:
         futures = [executor.submit(upload_images, i, image_list, output_file_list, sftp_client_imgs[i]) for i in range(len(output_file_list))]
 
-    # for i in range(len(output_file_list)):
-    #     if isinstance(image_list[i], str):
-    #         print("get url image")
-    #         image_list[i] = get_image_from_url(image_list[i])
-    #     with io.BytesIO() as image_byte_stream:
-    #         image_list[i] = image_list[i].resize((512, 512), Image.ANTIALIAS)
-    #         image_list[i].save(image_byte_stream, format='JPEG')
-    #         image_byte_stream.seek(0)  
-    #         sftp.putfo(image_byte_stream, output_file_list[i])
-    #     print(f"Successfully uploaded image to {output_file_list[i]}")
     with sftp_client as sftp:
         json_data = json.dumps(data, indent=4)
         with io.BytesIO(json_data.encode('utf-8')) as json_byte_stream:
             sftp.putfo(json_byte_stream, data_path)
         print(f"Successfully uploaded JSON data to {data_path}")
-    # create_ssh_client(SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD)
+    # create_ssh_client(SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD)
+
+def upload_ssh_data(data, data_path):
+    global sftp_client
+    global sftp_client_imgs
+    if not is_connected():
+        create_ssh_client(SSH_SERVER, SSH_PORT, SSH_USER, SSH_PASSWORD)
+
+    with sftp_client as sftp:
+        json_data = json.dumps(data, indent=4)
+        with io.BytesIO(json_data.encode('utf-8')) as json_byte_stream:
+            sftp.putfo(json_byte_stream, data_path)
+        print(f"Successfully uploaded JSON data to {data_path}")

serve/utils.py

@@ -31,6 +31,16 @@ acknowledgment_md = """
     <p> Our codebase is built upon <a href="https://github.com/lm-sys/FastChat" target="_blank">FastChat</a>, <a href="https://github.com/TIGER-AI-Lab/ImagenHub" target="_blank">ImagenHub</a>.</p>
 </div>
 """
+# 定义一个HTML组件来创建链接和处理点击事件
+html_code = """
+<p> This platform is designed for academic usage, for details please refer to <a href="#" id="open_link">disclaimer</a>.</p>
+<p id="link_text" style="display:none;">这里是弹出的文本链接: <a href="https://example.com" target="_blank">example.com</a></p>
+<script>
+document.getElementById('open_link').addEventListener('click', function() {
+    document.getElementById('link_text').style.display = 'block';
+});
+</script>
+"""
 block_css = """
 #notice_markdown {
     font-size: 110%
@@ -98,6 +108,11 @@ footer {
 .submit-button {
     color: red;
 }
+#custom-width {width: 100px !important;}
+#centered-row {
+    display: flex;
+    justify-content: center;
+}
 #btncolor1 {background: rgb(168, 230, 207);} 
 #btncolor2 {background: rgb(253, 255, 171);} 
 #btncolor3 {background: rgb(255, 211, 182);} 
@@ -105,6 +120,8 @@ footer {
 
 #btnblue {background: linear-gradient(to bottom right, rgb(222, 235, 247), rgb(189,215,238)); color: rgb(0, 112, 192); border: 1px solid rgb(189,215,238);} 
 #btnpink {background: rgb(255, 168, 184);} 
+#centered-text { display: flex; justify-content: center; align-items: center; height: 100%; width: 100%; font-size: 150%; }
+
 """
 
 #
@@ -159,6 +176,8 @@ footer {
 # .custom-button:hover {
 # background-color: darkgreen; /* 悬停时的背景颜色 */
 # }
+def enable_loop_buttons():
+    return tuple(gr.update(loop=True) for i in range(4))
 def enable_vote_buttons():
     return tuple(gr.update(visible=True, interactive=i<=4) for i in range(6))
 def disable_vote_buttons():
@@ -185,11 +204,25 @@ def disable_vote_mode_buttons():
     
 def enable_order_buttons():
     return tuple(gr.update(interactive=True) for _ in range(4))
-def disable_order_buttons(textbox):
+def disable_order_buttons(textbox, video=False):
     if not textbox.strip():
         return (gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True))
     else:
         return (gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True))
+def disable_video_order_buttons(textbox, example1_text, example2_text, example3_text, example4_text):
+    example_list = [example1_text, example2_text, example3_text, example4_text]
+    if not textbox.strip():
+        return (gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(visible=False))
+    else:
+        if textbox == example_list[0]:
+            return (gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), gr.update(value=8))
+        elif textbox == example_list[1]:
+            return (gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), gr.update(value=3))
+        elif textbox == example_list[2]:
+            return (gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), gr.update(value=93))
+        elif textbox == example_list[3]:
+            return (gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), gr.update(value=84))
+        return (gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=True), gr.update(visible=False))
 
 def clear_history():
     return None, "", None

serve/vote_utils.py

@@ -806,8 +806,6 @@ def generate_igm_annoy(gen_func, state0, state1, state2, state3, text, model_nam
     state2.model_name = model_name2
     state3.model_name = model_name3
 
-
-    
     yield state0, state1, state2, state3, generated_image0, generated_image1, generated_image2, generated_image3, \
         generated_image0, generated_image1, generated_image2, generated_image3, \
         gr.Markdown(f"### Model A: {model_name0}", visible=False), gr.Markdown(f"### Model B: {model_name1}", visible=False), \
@@ -872,7 +870,51 @@ def generate_igm_annoy(gen_func, state0, state1, state2, state3, text, model_nam
     #     with open(output_file, 'w') as f:
     #         save_any_image(state.output, f)
     #     save_image_file_on_log_server(output_file)
+
+def generate_igv_annoy(gen_func, state0, state1, state2, state3, text, prompt_num, model_name0, model_name1, model_name2, model_name3, request: gr.Request):
+    if not text.strip():
+        return (gr.update(visible=False),) * 16
+    if state0 is None:
+        state0 = ImageStateIG(model_name0)
+    if state1 is None:
+        state1 = ImageStateIG(model_name1)
+    if state2 is None:
+        state2 = ImageStateIG(model_name2)
+    if state3 is None:
+        state3 = ImageStateIG(model_name3)
+
+
+    ip = get_ip(request)
+    igm_logger.info(f"generate. ip: {ip}")
+    start_tstamp = time.time()
+    model_name0 = ""
+    model_name1 = ""
+    model_name2 = ""
+    model_name3 = ""
+
+    generated_video0, generated_video1, generated_video2, generated_video3, model_name0, model_name1, model_name2, model_name3 \
+        = gen_func(prompt_num, model_name0, model_name1, model_name2, model_name3)
+    state0.prompt = text
+    state1.prompt = text
+    state2.prompt = text
+    state3.prompt = text
+
+    state0.output = generated_video0
+    state1.output = generated_video1
+    state2.output = generated_video2
+    state3.output = generated_video3
+
+    state0.model_name = model_name0
+    state1.model_name = model_name1
+    state2.model_name = model_name2
+    state3.model_name = model_name3
+
+    yield state0, state1, state2, state3, generated_video0, generated_video1, generated_video2, generated_video3, \
+        generated_video0, generated_video1, generated_video2, generated_video3, \
+        gr.Markdown(f"### Model A: {model_name0}", visible=False), gr.Markdown(f"### Model B: {model_name1}", visible=False), \
+        gr.Markdown(f"### Model C: {model_name2}", visible=False), gr.Markdown(f"### Model D: {model_name3}", visible=False)
             
+
 def generate_igm_annoy_museum(gen_func, state0, state1, state2, state3, model_name0, model_name1, model_name2, model_name3, request: gr.Request):
     if state0 is None:
         state0 = ImageStateIG(model_name0)

sorted_score_list.json

@@ -1,82 +1,83 @@
 {
     "total_models": 27,
-    "total_votes": 945,
+    "total_votes": 965,
+    "last_updated": "2024-07-29",
     "sorted_score_list": [
         {
             "Rank": 0,
             "\ud83e\udd16 Model": "Midjourney-v6.0",
-            "\u2b50 Score (\u03bc/\u03c3)": "32.64 (35.04/0.799)",
-            "\ud83d\uddf3\ufe0f Votes": 422.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "32.36 (34.75/0.796)",
+            "\ud83d\uddf3\ufe0f Votes": 425.0,
             "Organization": "Midjourney"
         },
         {
             "Rank": 1,
             "\ud83e\udd16 Model": "Midjourney-v5.0",
-            "\u2b50 Score (\u03bc/\u03c3)": "31.61 (33.99/0.793)",
-            "\ud83d\uddf3\ufe0f Votes": 435.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "31.36 (33.74/0.791)",
+            "\ud83d\uddf3\ufe0f Votes": 438.0,
             "Organization": "Midjourney"
         },
         {
             "Rank": 2,
             "\ud83e\udd16 Model": "SD-v3.0",
-            "\u2b50 Score (\u03bc/\u03c3)": "29.07 (31.44/0.789)",
-            "\ud83d\uddf3\ufe0f Votes": 423.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "29.33 (31.7/0.788)",
+            "\ud83d\uddf3\ufe0f Votes": 426.0,
             "Organization": "Stability AI"
         },
         {
             "Rank": 3,
             "\ud83e\udd16 Model": "Dalle-3",
-            "\u2b50 Score (\u03bc/\u03c3)": "28.26 (30.65/0.797)",
-            "\ud83d\uddf3\ufe0f Votes": 424.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "28.55 (30.94/0.795)",
+            "\ud83d\uddf3\ufe0f Votes": 427.0,
             "Organization": "OpenAI"
         },
         {
             "Rank": 4,
-            "\ud83e\udd16 Model": "Dreamshaper-xl",
-            "\u2b50 Score (\u03bc/\u03c3)": "26.09 (28.45/0.789)",
-            "\ud83d\uddf3\ufe0f Votes": 425.0,
-            "Organization": "Lykon"
+            "\ud83e\udd16 Model": "Pixart-Sigma",
+            "\u2b50 Score (\u03bc/\u03c3)": "26.33 (28.7/0.79)",
+            "\ud83d\uddf3\ufe0f Votes": 441.0,
+            "Organization": "PixArt-Alpha"
         },
         {
             "Rank": 5,
             "\ud83e\udd16 Model": "Proteus-v0.2",
-            "\u2b50 Score (\u03bc/\u03c3)": "25.97 (28.33/0.787)",
-            "\ud83d\uddf3\ufe0f Votes": 420.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "26.15 (28.52/0.79)",
+            "\ud83d\uddf3\ufe0f Votes": 423.0,
             "Organization": "DataAutoGPT3"
         },
         {
             "Rank": 6,
-            "\ud83e\udd16 Model": "Open-Dalle-v1.1",
-            "\u2b50 Score (\u03bc/\u03c3)": "25.84 (28.19/0.784)",
-            "\ud83d\uddf3\ufe0f Votes": 414.0,
-            "Organization": "DataAutoGPT3"
+            "\ud83e\udd16 Model": "Dreamshaper-xl",
+            "\u2b50 Score (\u03bc/\u03c3)": "25.66 (28.02/0.786)",
+            "\ud83d\uddf3\ufe0f Votes": 434.0,
+            "Organization": "Lykon"
         },
         {
             "Rank": 7,
-            "\ud83e\udd16 Model": "Realvisxl-v3.0",
-            "\u2b50 Score (\u03bc/\u03c3)": "25.35 (27.71/0.787)",
-            "\ud83d\uddf3\ufe0f Votes": 412.0,
-            "Organization": "Realistic Vision"
+            "\ud83e\udd16 Model": "Open-Dalle-v1.1",
+            "\u2b50 Score (\u03bc/\u03c3)": "25.51 (27.85/0.782)",
+            "\ud83d\uddf3\ufe0f Votes": 429.0,
+            "Organization": "DataAutoGPT3"
         },
         {
             "Rank": 8,
-            "\ud83e\udd16 Model": "Pixart-Sigma",
-            "\u2b50 Score (\u03bc/\u03c3)": "25.32 (27.69/0.79)",
+            "\ud83e\udd16 Model": "Deepfloyd-IF",
+            "\u2b50 Score (\u03bc/\u03c3)": "25.22 (27.58/0.789)",
             "\ud83d\uddf3\ufe0f Votes": 426.0,
-            "Organization": "PixArt-Alpha"
+            "Organization": "DeepFloyd"
         },
         {
             "Rank": 9,
-            "\ud83e\udd16 Model": "Deepfloyd-IF",
-            "\u2b50 Score (\u03bc/\u03c3)": "25.29 (27.66/0.791)",
-            "\ud83d\uddf3\ufe0f Votes": 411.0,
-            "Organization": "DeepFloyd"
+            "\ud83e\udd16 Model": "Realvisxl-v3.0",
+            "\u2b50 Score (\u03bc/\u03c3)": "24.9 (27.26/0.785)",
+            "\ud83d\uddf3\ufe0f Votes": 424.0,
+            "Organization": "Realistic Vision"
         },
         {
             "Rank": 10,
             "\ud83e\udd16 Model": "Realvisxl-v2.0",
-            "\u2b50 Score (\u03bc/\u03c3)": "25.13 (27.49/0.786)",
-            "\ud83d\uddf3\ufe0f Votes": 427.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "24.75 (27.11/0.785)",
+            "\ud83d\uddf3\ufe0f Votes": 436.0,
             "Organization": "Realistic Vision"
         },
         {
@@ -89,106 +90,106 @@
         {
             "Rank": 12,
             "\ud83e\udd16 Model": "Dalle-2",
-            "\u2b50 Score (\u03bc/\u03c3)": "22.92 (25.28/0.787)",
-            "\ud83d\uddf3\ufe0f Votes": 411.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "23.04 (25.4/0.787)",
+            "\ud83d\uddf3\ufe0f Votes": 423.0,
             "Organization": "OpenAI"
         },
         {
             "Rank": 13,
             "\ud83e\udd16 Model": "Playground-v2.5",
-            "\u2b50 Score (\u03bc/\u03c3)": "21.76 (24.16/0.8)",
-            "\ud83d\uddf3\ufe0f Votes": 415.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "21.98 (24.36/0.795)",
+            "\ud83d\uddf3\ufe0f Votes": 430.0,
             "Organization": "Playground AI"
         },
         {
             "Rank": 14,
             "\ud83e\udd16 Model": "Kandinsky-v2.0",
-            "\u2b50 Score (\u03bc/\u03c3)": "21.37 (23.74/0.792)",
-            "\ud83d\uddf3\ufe0f Votes": 421.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "21.86 (24.23/0.791)",
+            "\ud83d\uddf3\ufe0f Votes": 427.0,
             "Organization": "AI-Forever"
         },
         {
             "Rank": 15,
-            "\ud83e\udd16 Model": "Playground-v2.0",
-            "\u2b50 Score (\u03bc/\u03c3)": "21.2 (23.59/0.798)",
-            "\ud83d\uddf3\ufe0f Votes": 434.0,
-            "Organization": "Playground AI"
-        },
-        {
-            "Rank": 16,
             "\ud83e\udd16 Model": "SDXL-turbo",
             "\u2b50 Score (\u03bc/\u03c3)": "21.05 (23.42/0.79)",
-            "\ud83d\uddf3\ufe0f Votes": 433.0,
+            "\ud83d\uddf3\ufe0f Votes": 436.0,
             "Organization": "Stability AI"
         },
+        {
+            "Rank": 16,
+            "\ud83e\udd16 Model": "Playground-v2.0",
+            "\u2b50 Score (\u03bc/\u03c3)": "20.71 (23.1/0.795)",
+            "\ud83d\uddf3\ufe0f Votes": 449.0,
+            "Organization": "Playground AI"
+        },
         {
             "Rank": 17,
             "\ud83e\udd16 Model": "Openjourney-v4",
-            "\u2b50 Score (\u03bc/\u03c3)": "20.37 (22.74/0.791)",
-            "\ud83d\uddf3\ufe0f Votes": 414.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "20.4 (22.76/0.789)",
+            "\ud83d\uddf3\ufe0f Votes": 426.0,
             "Organization": "Prompthero"
         },
         {
             "Rank": 18,
-            "\ud83e\udd16 Model": "SDXL",
-            "\u2b50 Score (\u03bc/\u03c3)": "20.07 (22.44/0.789)",
-            "\ud83d\uddf3\ufe0f Votes": 435.0,
+            "\ud83e\udd16 Model": "SD-v2.1",
+            "\u2b50 Score (\u03bc/\u03c3)": "20.19 (22.57/0.792)",
+            "\ud83d\uddf3\ufe0f Votes": 424.0,
             "Organization": "Stability AI"
         },
         {
             "Rank": 19,
-            "\ud83e\udd16 Model": "SD-v2.1",
-            "\u2b50 Score (\u03bc/\u03c3)": "19.91 (22.3/0.794)",
-            "\ud83d\uddf3\ufe0f Votes": 418.0,
-            "Organization": "Stability AI"
+            "\ud83e\udd16 Model": "LCM-v1.5",
+            "\u2b50 Score (\u03bc/\u03c3)": "19.79 (22.18/0.797)",
+            "\ud83d\uddf3\ufe0f Votes": 429.0,
+            "Organization": "Tsinghua"
         },
         {
             "Rank": 20,
-            "\ud83e\udd16 Model": "LCM-v1.5",
-            "\u2b50 Score (\u03bc/\u03c3)": "19.69 (22.07/0.792)",
-            "\ud83d\uddf3\ufe0f Votes": 426.0,
-            "Organization": "Tsinghua"
+            "\ud83e\udd16 Model": "SDXL",
+            "\u2b50 Score (\u03bc/\u03c3)": "19.78 (22.15/0.789)",
+            "\ud83d\uddf3\ufe0f Votes": 441.0,
+            "Organization": "Stability AI"
         },
         {
             "Rank": 21,
-            "\ud83e\udd16 Model": "SD-v1.5",
-            "\u2b50 Score (\u03bc/\u03c3)": "18.65 (21.03/0.794)",
-            "\ud83d\uddf3\ufe0f Votes": 419.0,
-            "Organization": "Stability AI"
+            "\ud83e\udd16 Model": "SSD-1b",
+            "\u2b50 Score (\u03bc/\u03c3)": "18.53 (20.91/0.794)",
+            "\ud83d\uddf3\ufe0f Votes": 427.0,
+            "Organization": "Segmind"
         },
         {
             "Rank": 22,
-            "\ud83e\udd16 Model": "SD-turbo",
-            "\u2b50 Score (\u03bc/\u03c3)": "18.42 (20.82/0.798)",
-            "\ud83d\uddf3\ufe0f Votes": 411.0,
+            "\ud83e\udd16 Model": "SD-v1.5",
+            "\u2b50 Score (\u03bc/\u03c3)": "18.52 (20.92/0.799)",
+            "\ud83d\uddf3\ufe0f Votes": 437.0,
             "Organization": "Stability AI"
         },
         {
             "Rank": 23,
-            "\ud83e\udd16 Model": "SSD-1b",
-            "\u2b50 Score (\u03bc/\u03c3)": "18.22 (20.61/0.796)",
-            "\ud83d\uddf3\ufe0f Votes": 415.0,
-            "Organization": "Segmind"
+            "\ud83e\udd16 Model": "SD-turbo",
+            "\u2b50 Score (\u03bc/\u03c3)": "18.41 (20.8/0.794)",
+            "\ud83d\uddf3\ufe0f Votes": 423.0,
+            "Organization": "Stability AI"
         },
         {
             "Rank": 24,
             "\ud83e\udd16 Model": "Stable-cascade",
-            "\u2b50 Score (\u03bc/\u03c3)": "15.58 (17.93/0.785)",
-            "\ud83d\uddf3\ufe0f Votes": 417.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "15.27 (17.64/0.789)",
+            "\ud83d\uddf3\ufe0f Votes": 426.0,
             "Organization": "Stability AI"
         },
         {
             "Rank": 25,
             "\ud83e\udd16 Model": "SDXL-Lightning",
-            "\u2b50 Score (\u03bc/\u03c3)": "14.41 (16.78/0.791)",
-            "\ud83d\uddf3\ufe0f Votes": 416.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "15.05 (17.43/0.794)",
+            "\ud83d\uddf3\ufe0f Votes": 428.0,
             "Organization": "ByteDance"
         },
         {
             "Rank": 26,
             "\ud83e\udd16 Model": "SDXL-Deepcache",
-            "\u2b50 Score (\u03bc/\u03c3)": "10.28 (12.72/0.813)",
-            "\ud83d\uddf3\ufe0f Votes": 414.0,
+            "\u2b50 Score (\u03bc/\u03c3)": "10.0 (12.46/0.821)",
+            "\ud83d\uddf3\ufe0f Votes": 423.0,
             "Organization": "NUS"
         }
     ]

sorted_score_list_video.json

@@ -0,0 +1,49 @@
+{
+    "total_models": 6,
+    "total_votes": 52,
+    "last_updated": "2024-07-29",
+    "sorted_score_list": [
+        {
+            "Rank": 0,
+            "\ud83e\udd16 Model": "VideoCrafter2",
+            "\u2b50 Score (\u03bc/\u03c3)": "25.33 (28.23/0.966)",
+            "\ud83d\uddf3\ufe0f Votes": 90.0,
+            "Organization": "Tencent"
+        },
+        {
+            "Rank": 1,
+            "\ud83e\udd16 Model": "LaVie",
+            "\u2b50 Score (\u03bc/\u03c3)": "25.08 (27.83/0.917)",
+            "\ud83d\uddf3\ufe0f Votes": 108.0,
+            "Organization": "Shanghai AI Lab"
+        },
+        {
+            "Rank": 2,
+            "\ud83e\udd16 Model": "OpenSora",
+            "\u2b50 Score (\u03bc/\u03c3)": "24.9 (27.65/0.918)",
+            "\ud83d\uddf3\ufe0f Votes": 111.0,
+            "Organization": "HPC-AI"
+        },
+        {
+            "Rank": 3,
+            "\ud83e\udd16 Model": "AnimateDiff",
+            "\u2b50 Score (\u03bc/\u03c3)": "23.85 (26.56/0.903)",
+            "\ud83d\uddf3\ufe0f Votes": 123.0,
+            "Organization": "CUHK etc."
+        },
+        {
+            "Rank": 4,
+            "\ud83e\udd16 Model": "StableVideoDiffusion",
+            "\u2b50 Score (\u03bc/\u03c3)": "20.96 (24.0/1.015)",
+            "\ud83d\uddf3\ufe0f Votes": 96.0,
+            "Organization": "Stability AI"
+        },
+        {
+            "Rank": 5,
+            "\ud83e\udd16 Model": "Zeroscope-v2-xl",
+            "\u2b50 Score (\u03bc/\u03c3)": "9.39 (13.91/1.508)",
+            "\ud83d\uddf3\ufe0f Votes": 96.0,
+            "Organization": "Cerspense"
+        }
+    ]
+}

webvid_prompt.txt

@@ -0,0 +1,100 @@
+Cloudy moscow kremlin time lapse
+Sharp knife to cut delicious smoked fish
+A baker turns freshly baked loaves of sourdough bread
+Shot of beautiful dinnerware and cutlery on a banquet table at restaurant
+Corn husks in field for agriculture farming
+Pear fruits hanging on a branch of a tree rulevogo
+Peaceful girl doing yoga meditate virabhasana sunrise coast slow motion
+Chef with recipe book watching young cook preparing dish in the kitchen
+Man walking in deep snow under the branches
+Fist patting down sand in an orange bucket
+Old decrepit house in the center of the city surrounded by new buildings
+Green grape plants in the middle of nature
+Climbers go up to the mountain pass
+Bodrum holiday resort seashore marina
+A flight over a beautiful stream in the forest
+Attractive young couple at home laughing at funny internet joke online using digital tablet having fun
+A small animation for the design video about redcurrant
+Time lapse of sky clouds storm
+Happy young caucasian baby boy playing toy bucket spade sandy beach with father while mother takes photograph sun lens flare shot on red epic
+A young woman having dental treatment
+Huge waterfall in chilean scenery huilo huilo
+Yellow bird and nest on the branch
+Little girl playing in the garden in summer
+Hands of girl fall out sweets from bowl on white floor
+Woman hairdresser put on curlers to long hair plus size woman
+Pov of two hands and young woman putting the propellers on a drone
+Video of watering a flower pot
+Woman look at the city in hong kong
+Sexy woman posing sitting on chair
+Coconat palm tree on sky tropical view
+Dog sitting tied to a post and waiting for the owner
+Asian female cyclist blogger live stream happily to show her ride on the road
+Pretty student learning in computer class at the university
+Storm clouds and rainbow  over bordeaux vineyards
+Aerial view of roof tops of old city
+Mountain area with fog and mist time lapse
+The famous waterfall of niagara falls in canada
+Low section of ice fisherman fishing in tent
+Medical students in training assisting surgeon in hospital operating room
+Passing by a cruise ship in the evening in ha long bay
+London skyline with building site at sunset
+The red deer female close up in the summertime
+Chinese new year flat icon chinese decor lantern
+The waiters in the restaurant put the glasses on buffet table
+Makeup artist dips brush into a makeup kit
+Panning down on team of businesswomen and businessmen in an office working and talking about new projects
+Time lapse in the mountains of brazil tree line
+Sick man in bed measuring temperature feeling fever medium shot
+Santa claus sitting in a chair with a little girl dreaming about her christmas presents
+Abused woman lying in the bathtub screams in despair
+Young mime is juggling in the park
+Countryside timelapse in spain
+Green branches of a coniferous tree with needles fill the entire screen
+Closeup of pouring healthy black chia seeds into a bowl 
+South korea high resolution victory concept
+Inspecting south african passport
+Attractive business woman reading documents in busy office female executive working on company project deadline
+Slow dolly in towards beautiful waterfall through bright fall colors
+Digital animation of american flag waving while background shows silhouette of hill with tree during sunset
+Hud multipath target monitoring
+Happy young businessman thinking while using phone
+Thick morning fog in the summer forest
+Group of children play a game of reaction speed in scientific museum
+Abstract chrisanthemum background
+Inside processor of a battery chip 
+Big and small frog sitting in the water and  swimming away
+Street lamp fallen down on ground with shattered glass from snow storm
+Rustic cabin in early autumn in the great smoky mountains with dark shadows and some autumn color as seen from a window pane from another historical cabin
+Night vision view of timber wolf
+Pseudo galena by pyrrhotite hematitiziran 
+Gorgeous couple in love have a romantic walk in magnificent budapest blurred background at night
+Close up thoughtful pretty young woman relaxing at the beach resort
+Happy senior woman working on laptop computer 
+Singing nightingale on a tree branch
+Pouring of rice water from jug into glass on table
+Flaming gorge national park in summer in utah with handheld shot of brown cow grazing closeup on grass herd near ranch
+Aerial flyby miami beach condominiums
+Jungle covered mountain on panay island in the philippines
+Close up portrait of two caucasian young girl and boy playing together on digital tablet
+White spools are getting wound by textile equipment
+The wedge newport beach california waves crashing aerial footage
+Peak at kaengkrachan national park thailand
+Christmas bauble dropping and bouncing beside crackers and presents in slow motion
+Happy extended family on the sofa at home
+Closeup shot of young female confectioner decorating delicious handmade cake placed on rotating stand with freshly baked meringues
+Non smoking sign in the airplane cabin
+Swan opening up wings and flapping them to dry off while grooming
+A series of explosions in the winter tundra
+Man actor wearing a tiger clothe preparing his acting with a tambourine
+Abstract shape pattern texture moving background
+Above the thermal station two pipes smoking in the gray sky
+Vacation water villas on tropical island
+Dense fog glows orange and covers hills at dawn
+People walking on the beach in timelapse 
+Aerial view of wind turbines energy production in yellow fields
+Preparing and mixing a fresh salad
+A jetsurfer taking various turns while jet surfing on water
+Happy little girl jumping in swimming pool and learning how to swim with help of father
+Student boy wash the school board
+Office workers showing work on laptop