1st draft release

.gitignore

@@ -0,0 +1,177 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+.idea
+.DS_Store

app.py

@@ -1,64 +1,27 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-if __name__ == "__main__":
-    demo.launch()
+from indiebot_arena.config import MONGO_DB_URI, MONGO_DB_NAME, LANGUAGE
+from indiebot_arena.dao.mongo_dao import MongoDAO
+from indiebot_arena.service.bootstrap_service import BootstrapService
+from indiebot_arena.ui.battle import battle_content
+from indiebot_arena.ui.leaderboard import leaderboard_content
+from indiebot_arena.ui.registration import registration_content
+
+dao = MongoDAO(MONGO_DB_URI, MONGO_DB_NAME)
+bootstrap_service = BootstrapService(dao)
+bootstrap_service.provision_database()
+
+with open("style.css", "r") as f:
+  custom_css = f.read()
+
+with gr.Blocks(css=custom_css) as demo:
+  with gr.Tabs():
+    with gr.TabItem("🏆 リーダーボード"):
+      leaderboard_content(dao, LANGUAGE)
+    with gr.TabItem("⚔️ モデルに投票"):
+      battle_content(dao, LANGUAGE)
+    with gr.TabItem("📚️ モデルの登録"):
+      registration_content(dao, LANGUAGE)
+
+if __name__=="__main__":
+  demo.queue(max_size=20).launch()

docs/leaderboard_header.md

@@ -0,0 +1,16 @@
+# 🚀 IndieBot Arena
+
+インディーボットアリーナはChatbot Arenaのインディーズ版のようなWebアプリです。  
+Chatbot Arenaにインスパイアされて開発されましが、以下のような違いがあります。
+
+- 誰でもモデルを登録してコンペに参加可能
+- 階級別にチャットバトルとリーダーボードがある
+
+初期データとして、Google公式のInstruction-Tuning済みモデルを登録しています。  
+【モデルに投票】から匿名のチャットバトルで投票することが出来ます。  
+【モデルの登録】から自分の事後学習済みモデルを登録することも出来ます。
+
+Google公式モデルを上回る日本語性能スコアのモデルをぜひ皆で作りましょう！
+
+
+

docs/model_registration_guide.md

@@ -0,0 +1,74 @@
+## 登録可能なモデルの要件
+
+登録可能なモデルは、Hugging Faceのモデルハブで公開されているPyTorchベースのモデルで、transformersライブラリのgenerate APIに対応している必要があります。
+重みのファイル形式はsafetensorsのみで、量子化する場合はBitsAndBytesのバージョン0.44.1以降で量子化されている必要があります。
+tokenizer_config.jsonで正しくchat_templateが設定されている必要があります。
+パラメータ数ではなく、重みのファイルのサイズが5GB未満または10GB未満で階級ごとに分かれてリーダーボードが作れます。
+
+- **GPU環境**: HF SpacesのZeroGPU A100(40GB)
+- **LLM実行環境**: transformersライブラリ（4.50.0）
+- **量子化**: BitsAndBytesのみ対応（0.44.1）
+- **ファイル形式**: safetensorsのみ
+- **ファイルサイズ**:　5GB又は10GB未満
+- **チャットテンプレート**: chat_template設定が必要（tokenizer_config.json）
+
+非量子化モデルでもファイルサイズ制限をクリアすれば登録可能ですが、サーバーの負荷低減のためにBitsAndBytesによる量子化を推奨します。
+将来的には、llama.cppの実行環境でGGUF形式に対応する予定です。
+
+## モデルの登録方法
+
+このページの一番下にある、モデルの新規登録フォームから登録できます。
+モデルIDとエントリーしたいファイルサイズ区分を選択してロードテストボタンを押して下さい。
+
+### ① ロードテスト
+ロードテストではファイル形式やサイズなどのチェックが行われます。
+
+### ② チャットテスト 
+チャットテストでは簡単な日本語応答が出来るかチェックが行われます。
+
+### ③ 登録
+ロードテストとチャットテストをクリアしたモデルだけ登録可能です。
+登録が完了すると、登録済みモデル一覧にあなたのモデルが表示されます。
+
+## 量子化サンプルコード
+
+以下はBitsAndBytesで4bit量子化して自分のリポジトリにPushするまでのサンプルコードです。
+
+```
+# python 3.10
+pip install bitsandbytes==0.44.1
+pip install accelerate==1.2.1
+pip install transformers==4.50.0
+pip install huggingface_hub[cli]
+```
+```
+# アクセストークンを入力してログイン
+huggingface-cli login
+```
+```python
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+
+model_id = "google/gemma-2-2b-it" 
+repo_id = "xxxxx/gemma-2-2b-it-bnb-4bit" 
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config, device_map="auto")
+
+tokenizer.push_to_hub(repo_id)
+model.push_to_hub(repo_id)
+
+```
+
+量子化後のモデルIDは任意の名前が可能ですが、以下の形式を推奨します。
+
+* BitsAndBytesの4bit量子化の場合
+```
+[量子化前のモデルID]-bnb-4bit
+```

indiebot_arena/config.py

@@ -0,0 +1,15 @@
+import os
+
+MONGO_DB_URI = os.environ.get("MONGO_DB_URI", "mongodb://localhost:27017")
+MONGO_DB_NAME = os.environ.get("MONGO_DB_NAME", "test_db")
+LANGUAGE = "ja"
+
+DEBUG = os.getenv("DEBUG", "False").lower() in ["true", "1", "yes"]
+LOCAL_TESTING = os.getenv("LOCAL_TESTING", "False").lower() in ["true", "1", "yes"]
+MODEL_SELECTION_MODE = os.getenv("MODEL_SELECTION_MODE", "random")
+MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "4096"))
+
+if LOCAL_TESTING:
+  MAX_NEW_TOKENS = 20
+else:
+  MAX_NEW_TOKENS = 512

indiebot_arena/dao/mongo_dao.py

@@ -0,0 +1,156 @@
+from dataclasses import asdict
+from typing import List, Optional
+
+from bson import ObjectId
+from pymongo import MongoClient
+
+from indiebot_arena.model.domain_model import Model, Battle, LeaderboardEntry
+
+
+class MongoDAO:
+  def __init__(self, uri: str, db_name: str):
+    self.client = MongoClient(uri)
+    self.db = self.client[db_name]
+    self.models_collection = self.db["models"]
+    self.battles_collection = self.db["battles"]
+    self.leaderboard_collection = self.db["leaderboard"]
+
+    self.models_collection.create_index(
+      [("language", 1), ("weight_class", 1), ("model_name", 1)], unique=True
+    )
+    self.leaderboard_collection.create_index(
+      [("language", 1), ("weight_class", 1), ("model_id", 1)], unique=True
+    )
+    self.battles_collection.create_index(
+      [("language", 1), ("weight_class", 1), ("vote_timestamp", 1)]
+    )
+
+  # ---------- Model ----------
+
+  def insert_model(self, model: Model) -> ObjectId:
+    data = asdict(model)
+    if data.get("_id") is None:
+      data.pop("_id")
+    result = self.models_collection.insert_one(data)
+    return result.inserted_id
+
+  def get_model(self, model_id: ObjectId) -> Optional[Model]:
+    data = self.models_collection.find_one({"_id": model_id})
+    if data:
+      return Model(**data)
+    return None
+
+  def update_model(self, model: Model) -> bool:
+    data = asdict(model)
+    if data.get("_id") is None:
+      raise ValueError("model _id is required for updating.")
+    result = self.models_collection.replace_one({"_id": data["_id"]}, data)
+    return result.modified_count > 0
+
+  def delete_model(self, model_id: ObjectId) -> bool:
+    result = self.models_collection.delete_one({"_id": model_id})
+    return result.deleted_count > 0
+
+  def find_models(self, language: str, weight_class: str) -> List[Model]:
+    query = {
+      "language": language,
+      "weight_class": weight_class
+    }
+    cursor = self.models_collection.find(query).sort("_id", 1)
+    return [Model(**doc) for doc in cursor]
+
+  def find_one_model(self, language: str, weight_class: str, model_name: str) -> Optional[Model]:
+    query = {
+      "language": language,
+      "weight_class": weight_class,
+      "model_name": model_name
+    }
+    data = self.models_collection.find_one(query)
+    if data:
+      return Model(**data)
+    return None
+
+  # ---------- Battle ----------
+
+  def insert_battle(self, battle: Battle) -> ObjectId:
+    data = asdict(battle)
+    if data.get("_id") is None:
+      data.pop("_id")
+    result = self.battles_collection.insert_one(data)
+    return result.inserted_id
+
+  def get_battle(self, battle_id: ObjectId) -> Optional[Battle]:
+    data = self.battles_collection.find_one({"_id": battle_id})
+    if data:
+      return Battle(**data)
+    return None
+
+  def update_battle(self, battle: Battle) -> bool:
+    data = asdict(battle)
+    if data.get("_id") is None:
+      raise ValueError("battle _id is required for updating.")
+    result = self.battles_collection.replace_one({"_id": data["_id"]}, data)
+    return result.modified_count > 0
+
+  def delete_battle(self, battle_id: ObjectId) -> bool:
+    result = self.battles_collection.delete_one({"_id": battle_id})
+    return result.deleted_count > 0
+
+  def find_battles(self, language: str, weight_class: str) -> List[Battle]:
+    query = {
+      "language": language,
+      "weight_class": weight_class
+    }
+    cursor = self.battles_collection.find(query)
+    return [Battle(**doc) for doc in cursor]
+
+  def find_last_battle(self) -> Optional[Battle]:
+    battle_doc = self.battles_collection.find_one(sort=[("_id", -1)])
+    if battle_doc:
+      return Battle(**battle_doc)
+    return None
+
+  # ---------- LeaderboardEntry ----------
+
+  def insert_leaderboard_entry(self, entry: LeaderboardEntry) -> ObjectId:
+    data = asdict(entry)
+    if data.get("_id") is None:
+      data.pop("_id")
+    result = self.leaderboard_collection.insert_one(data)
+    return result.inserted_id
+
+  def get_leaderboard_entry(self, entry_id: ObjectId) -> Optional[LeaderboardEntry]:
+    data = self.leaderboard_collection.find_one({"_id": entry_id})
+    if data:
+      return LeaderboardEntry(**data)
+    return None
+
+  def update_leaderboard_entry(self, entry: LeaderboardEntry) -> bool:
+    data = asdict(entry)
+    if data.get("_id") is None:
+      raise ValueError("leaderboard _id is required for updating.")
+    result = self.leaderboard_collection.replace_one({"_id": data["_id"]}, data)
+    return result.modified_count > 0
+
+  def delete_leaderboard_entry(self, entry_id: ObjectId) -> bool:
+    result = self.leaderboard_collection.delete_one({"_id": entry_id})
+    return result.deleted_count > 0
+
+  def find_leaderboard_entries(self, language: str, weight_class: str) -> List[LeaderboardEntry]:
+    query = {
+      "language": language,
+      "weight_class": weight_class
+    }
+    cursor = self.leaderboard_collection.find(query).sort("elo_score", -1)
+    return [LeaderboardEntry(**doc) for doc in cursor]
+
+  def find_one_leaderboard_entry(self, language: str, weight_class: str, model_id: ObjectId) -> Optional[
+    LeaderboardEntry]:
+    data = self.leaderboard_collection.find_one({
+      "language": language,
+      "weight_class": weight_class,
+      "model_id": model_id
+    })
+    if data:
+      return LeaderboardEntry(**data)
+    return None

indiebot_arena/model/domain_model.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+from bson import ObjectId
+
+
+@dataclass
+class Model:
+  language: str               # 言語区分 (例: "ja", "en")
+  weight_class: str           # サイズ区分 (例: "U-5GB", "U-10GB")
+  model_name: str             # 例: "fukugawa/gemma-2-9b-finetuned-bnb-4bit"
+  runtime: str                # 実行環境 (例: "transformers", "llama.cpp")
+  quantization: str           # 量子化方式 (例: "none", "bnb", "gptq")
+  file_format: str            # 保存形式 (例: "safetensors", "gguf")
+  file_size_gb: float         # ファイルサイズ（単位: GB）
+  description: Optional[str] = None
+  created_at: datetime = field(default_factory=datetime.utcnow)
+  _id: Optional[ObjectId] = None
+
+
+@dataclass
+class Battle:
+  language: str
+  weight_class: str
+  model_a_id: ObjectId
+  model_b_id: ObjectId
+  winner_model_id: ObjectId
+  user_id: str
+  vote_timestamp: datetime = field(default_factory=datetime.utcnow)
+  _id: Optional[ObjectId] = None
+
+
+@dataclass
+class LeaderboardEntry:
+  language: str
+  weight_class: str
+  model_id: ObjectId
+  elo_score: int
+  last_updated: datetime = field(default_factory=datetime.utcnow)
+  _id: Optional[ObjectId] = None

indiebot_arena/service/arena_service.py

@@ -0,0 +1,232 @@
+import random
+import re
+from datetime import datetime
+from typing import List, Optional, Tuple, Dict
+
+from bson import ObjectId
+
+from indiebot_arena.dao.mongo_dao import MongoDAO
+from indiebot_arena.model.domain_model import Model, Battle, LeaderboardEntry
+
+INITIAL_RATING = 1000
+K_FACTOR = 32
+
+
+class ArenaService:
+  def __init__(self, dao: MongoDAO):
+    self.dao = dao
+
+  # ---------- Model ----------
+
+  def register_model(
+      self,
+      language: str,
+      weight_class: str,
+      model_name: str,
+      runtime: str,
+      quantization: str,
+      file_format: str,
+      file_size_gb: float,
+      description: Optional[str] = ""
+  ) -> ObjectId:
+    # Non-empty checks
+    if not model_name.strip():
+      raise ValueError("Model name cannot be empty.")
+    if not runtime.strip():
+      raise ValueError("Runtime cannot be empty.")
+    if not quantization.strip():
+      raise ValueError("Quantization cannot be empty.")
+    if not file_format.strip():
+      raise ValueError("File format cannot be empty.")
+
+    # Validation
+    if runtime!="transformers":
+      raise ValueError("Runtime must be 'transformers'.")
+    if quantization not in ("bnb", "none"):
+      raise ValueError("Quantization must be 'bnb' or 'none'.")
+    if file_format!="safetensors":
+      raise ValueError("File format must be 'safetensors'.")
+    if language not in ("ja", "en"):
+      raise ValueError("Language must be 'ja' or 'en'.")
+    if weight_class not in ("U-5GB", "U-10GB"):
+      raise ValueError("Weight class must be 'U-5GB' or 'U-10GB'.")
+    if file_size_gb <= 0:
+      raise ValueError("File size must be greater than 0.")
+    if weight_class=="U-5GB" and file_size_gb >= 5.0:
+      raise ValueError("For U-5GB, file size must be less than 5.0.")
+    if weight_class=="U-10GB" and file_size_gb >= 10.0:
+      raise ValueError("For U-10GB, file size must be less than 10.0.")
+    if not re.match(r"^[^/]+/[^/]+$", model_name):
+      raise ValueError("Model name must be in 'xxxxx/xxxxxx' format.")
+
+    # Description length check
+    if description is not None and len(description) > 1024:
+      raise ValueError("Description must be 1024 characters or less.")
+
+    # Duplicate check
+    if self.dao.find_one_model(language, weight_class, model_name) is not None:
+      raise ValueError("A model with this language, weight class and model name already exists.")
+
+    model = Model(
+      model_name=model_name,
+      runtime=runtime,
+      quantization=quantization,
+      file_format=file_format,
+      file_size_gb=file_size_gb,
+      language=language,
+      weight_class=weight_class,
+      description=description
+    )
+    return self.dao.insert_model(model)
+
+  def get_one_model(
+      self,
+      language: str,
+      weight_class: str,
+      model_name: str
+  ) -> Optional[Model]:
+    return self.dao.find_one_model(language, weight_class, model_name)
+
+  def get_two_random_models(
+      self,
+      language: str,
+      weight_class: str
+  ) -> Tuple[Model, Model]:
+    models = self.dao.find_models(language, weight_class)
+    if len(models) < 2:
+      raise ValueError("Need at least 2 models for a battle.")
+    return tuple(random.sample(models, 2))
+
+  def get_model_dropdown_list(
+      self,
+      language: str,
+      weight_class: str
+  ) -> List[Dict[str, str]]:
+    models = self.dao.find_models(language, weight_class)
+    return [
+      {"label": model.model_name, "value": model.model_name}
+      for model in models if model.model_name
+    ]
+
+  # ---------- Battle ----------
+
+  def record_battle(
+      self,
+      language: str,
+      weight_class: str,
+      model_a_id: ObjectId,
+      model_b_id: ObjectId,
+      winner_model_id: ObjectId,
+      user_id: str
+  ) -> ObjectId:
+    # Validation
+    if language not in ("ja", "en"):
+      raise ValueError("Language must be 'ja' or 'en'.")
+    if weight_class not in ("U-5GB", "U-10GB"):
+      raise ValueError("Weight class must be 'U-5GB' or 'U-10GB'.")
+
+    if model_a_id is None or model_b_id is None or winner_model_id is None:
+      raise ValueError("All model IDs must be provided.")
+
+    if model_a_id==model_b_id:
+      raise ValueError("Model A and Model B must be different.")
+
+    if winner_model_id!=model_a_id and winner_model_id!=model_b_id:
+      raise ValueError("Winner model ID must be either model_a_id or model_b_id.")
+
+    # Check duplicate
+    last_battle = self.dao.find_last_battle()
+    if last_battle is not None:
+      if (last_battle.language==language and
+          last_battle.weight_class==weight_class and
+          last_battle.model_a_id==model_a_id and
+          last_battle.model_b_id==model_b_id and
+          last_battle.winner_model_id==winner_model_id and
+          last_battle.user_id==user_id):
+        raise ValueError("Duplicate battle record detected: the latest record already matches the provided battle details.")
+
+    # Check model exists
+    model_a = self.dao.get_model(model_a_id)
+    model_b = self.dao.get_model(model_b_id)
+    if model_a is None or model_b is None:
+      raise ValueError("Both Model A and Model B must exist in the database.")
+
+    battle = Battle(
+      model_a_id=model_a_id,
+      model_b_id=model_b_id,
+      language=language,
+      weight_class=weight_class,
+      winner_model_id=winner_model_id,
+      user_id=user_id,
+    )
+    battle_id = self.dao.insert_battle(battle)
+    return battle_id
+
+  # ---------- LeaderboardEntry ----------
+
+  def get_leaderboard(
+      self,
+      language: str,
+      weight_class: str
+  ) -> List[LeaderboardEntry]:
+    return self.dao.find_leaderboard_entries(language, weight_class)
+
+  def update_leaderboard(
+      self,
+      language: str,
+      weight_class: str
+  ) -> bool:
+    """
+    Update the leaderboard using battle history.
+    Each model starts at INITIAL_RATING and K is K_FACTOR.
+    """
+    models = self.dao.find_models(language, weight_class)
+    if not models:
+      return False
+
+    ratings = {
+      str(model._id): INITIAL_RATING for model in models if model._id is not None
+    }
+
+    battles = self.dao.find_battles(language, weight_class)
+    battles.sort(key=lambda b: b.vote_timestamp)
+
+    for battle in battles:
+      model_a_id_str = str(battle.model_a_id)
+      model_b_id_str = str(battle.model_b_id)
+
+      if model_a_id_str not in ratings:
+        ratings[model_a_id_str] = INITIAL_RATING
+      if model_b_id_str not in ratings:
+        ratings[model_b_id_str] = INITIAL_RATING
+
+      if str(battle.winner_model_id)==model_a_id_str:
+        score_a, score_b = 1, 0
+      else:
+        score_a, score_b = 0, 1
+
+      exp_a = 1 / (1 + 10 ** ((ratings[model_b_id_str] - ratings[model_a_id_str]) / 400))
+      exp_b = 1 / (1 + 10 ** ((ratings[model_a_id_str] - ratings[model_b_id_str]) / 400))
+
+      ratings[model_a_id_str] += K_FACTOR * (score_a - exp_a)
+      ratings[model_b_id_str] += K_FACTOR * (score_b - exp_b)
+
+    for model in models:
+      if model._id is None:
+        continue
+      model_id_str = str(model._id)
+      new_rating = round(ratings.get(model_id_str, INITIAL_RATING))
+      entry = self.dao.find_one_leaderboard_entry(language, weight_class, model._id)
+      if entry:
+        entry.elo_score = new_rating
+        entry.last_updated = datetime.utcnow()
+        self.dao.update_leaderboard_entry(entry)
+      else:
+        new_entry = LeaderboardEntry(
+          model_id=model._id,
+          language=language,
+          weight_class=weight_class,
+          elo_score=new_rating,
+        )
+        self.dao.insert_leaderboard_entry(new_entry)
+    return True

indiebot_arena/service/bootstrap_service.py

@@ -0,0 +1,32 @@
+import logging
+
+from indiebot_arena.dao.mongo_dao import MongoDAO
+from indiebot_arena.service.arena_service import ArenaService
+
+
+class BootstrapService:
+  def __init__(self, dao: MongoDAO):
+    self.dao = dao
+    self.arena_service = ArenaService(dao);
+
+  def provision_database(self):
+    if self.dao.models_collection.count_documents({}) > 0:
+      logging.info("Database already provisioned. Skipping initial data insertion.")
+      return
+
+    try:
+      self.arena_service.register_model("ja", "U-5GB", "google/gemma-3-1b-it", "transformers", "none", "safetensors", 1.86)
+      self.arena_service.register_model("ja", "U-5GB", "google/gemma-2-2b-it", "transformers", "none", "safetensors", 4.87)
+      self.arena_service.register_model("ja", "U-5GB", "google/gemma-2-2b-jpn-it", "transformers", "none", "safetensors", 4.87)
+      self.arena_service.register_model("ja", "U-5GB", "indiebot-community/gemma-3-1b-it-bnb-4bit", "transformers", "bnb", "safetensors", 0.93)
+      self.arena_service.register_model("ja", "U-5GB", "indiebot-community/gemma-2-2b-it-bnb-4bit", "transformers", "bnb", "safetensors", 2.16)
+      self.arena_service.register_model("ja", "U-5GB", "indiebot-community/gemma-2-2b-jpn-it-bnb-4bit", "transformers", "bnb", "safetensors", 2.16)
+      self.arena_service.register_model("ja", "U-10GB", "google/gemma-3-4b-it", "transformers", "none", "safetensors", 8.01)
+      self.arena_service.register_model("ja", "U-10GB", "indiebot-community/gemma-3-4b-it-bnb-4bit", "transformers", "bnb", "safetensors", 2.93)
+      self.arena_service.register_model("ja", "U-10GB", "indiebot-community/gemma-3-12b-it-bnb-4bit", "transformers", "bnb", "safetensors", 7.51)
+      self.arena_service.register_model("ja", "U-10GB", "indiebot-community/gemma-2-9b-it-bnb-4bit", "transformers", "bnb", "safetensors", 6.07)
+
+      self.arena_service.update_leaderboard("ja", "U-5GB")
+      self.arena_service.update_leaderboard("ja", "U-10GB")
+    except Exception as e:
+      logging.error(f"Error register_model: {e}")

indiebot_arena/ui/battle.py

@@ -0,0 +1,234 @@
+import concurrent.futures
+import hashlib
+import random
+import threading
+
+import gradio as gr
+import spaces
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from indiebot_arena.config import LOCAL_TESTING, MODEL_SELECTION_MODE, MAX_INPUT_TOKEN_LENGTH, MAX_NEW_TOKENS
+from indiebot_arena.service.arena_service import ArenaService
+
+DESCRIPTION = "### 💬 チャットバトル"
+
+_model_cache = {}
+_model_lock = threading.Lock()
+
+
+# Avoid “cannot copy out of meta tensor” error
+def get_cached_model_and_tokenizer(model_id: str):
+  with _model_lock:
+    if model_id not in _model_cache:
+      tokenizer = AutoTokenizer.from_pretrained(model_id)
+      model = AutoModelForCausalLM.from_pretrained(
+        model_id,
+        device_map="auto",
+        torch_dtype=torch.bfloat16,
+        use_safetensors=True
+      )
+      model.eval()
+      _model_cache[model_id] = (model, tokenizer)
+    return _model_cache[model_id]
+
+
+@spaces.GPU(duration=30)
+def generate(message: str, chat_history: list, model_id: str, max_new_tokens: int = MAX_NEW_TOKENS,
+             temperature: float = 0.6, top_p: float = 0.9, top_k: int = 50, repetition_penalty: float = 1.2) -> str:
+  if LOCAL_TESTING:
+    model, tokenizer = get_cached_model_and_tokenizer(model_id)
+  else:
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    model = AutoModelForCausalLM.from_pretrained(
+      model_id,
+      device_map="auto",
+      torch_dtype=torch.bfloat16,
+      use_safetensors=True
+    )
+
+  conversation = chat_history.copy()
+  conversation.append({"role": "user", "content": message})
+  input_ids = tokenizer.apply_chat_template(conversation, add_generation_prompt=True, return_tensors="pt")
+  if input_ids.shape[1] > MAX_INPUT_TOKEN_LENGTH:
+    input_ids = input_ids[:, -MAX_INPUT_TOKEN_LENGTH:]
+    gr.Warning(f"Trimmed input as it exceeded {MAX_INPUT_TOKEN_LENGTH} tokens.")
+  input_ids = input_ids.to(model.device)
+  outputs = model.generate(
+    input_ids=input_ids,
+    max_new_tokens=max_new_tokens,
+    do_sample=True,
+    top_p=top_p,
+    top_k=top_k,
+    temperature=temperature,
+    repetition_penalty=repetition_penalty,
+  )
+  response = tokenizer.decode(outputs[0][input_ids.shape[1]:], skip_special_tokens=True)
+  return response
+
+
+def format_chat_history(history):
+  conversation = []
+  for user_msg, assistant_msg in history:
+    conversation.append({"role": "user", "content": user_msg})
+    if assistant_msg:
+      conversation.append({"role": "assistant", "content": assistant_msg})
+  return conversation
+
+
+def submit_message(message, history_a, history_b, model_a, model_b):
+  history_a.append((message, ""))
+  history_b.append((message, ""))
+  conv_history_a = format_chat_history(history_a[:-1])
+  conv_history_b = format_chat_history(history_b[:-1])
+  with concurrent.futures.ThreadPoolExecutor() as executor:
+    future_a = executor.submit(generate, message, conv_history_a, model_a)
+    future_b = executor.submit(generate, message, conv_history_b, model_b)
+    response_a = future_a.result()
+    response_b = future_b.result()
+  history_a[-1] = (message, response_a)
+  history_b[-1] = (message, response_b)
+  return history_a, history_b, "", gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=False)
+
+
+def get_random_values(model_labels):
+  if MODEL_SELECTION_MODE=="random":
+    return random.sample(model_labels, 2)
+  if MODEL_SELECTION_MODE=="manual":
+    return model_labels[0], model_labels[0]
+
+def battle_content(dao, language):
+  arena_service = ArenaService(dao)
+  default_weight = "U-5GB"
+  initial_models = arena_service.get_model_dropdown_list(language, default_weight)
+  initial_choices = [m["label"] for m in initial_models]
+  initial_value_a, initial_value_b = get_random_values(initial_choices)
+  dropdown_visible = False if MODEL_SELECTION_MODE=="random" else True
+
+  def fetch_model_dropdown(weight_class):
+    models = arena_service.get_model_dropdown_list(language, weight_class)
+    model_labels = [m["label"] for m in models]
+    value_a, value_b = get_random_values(model_labels)
+    update_obj_a = gr.update(choices=model_labels, value=value_a)
+    update_obj_b = gr.update(choices=model_labels, value=value_b)
+    return update_obj_a, update_obj_b, model_labels
+
+  def submit_vote(vote_choice, weight_class, model_a_name, model_b_name, request: gr.Request):
+    user_id = generate_anonymous_user_id(request)
+    model_a = arena_service.get_one_model(language, weight_class, model_a_name)
+    model_b = arena_service.get_one_model(language, weight_class, model_b_name)
+    winner = model_a if vote_choice=="Chatbot A" else model_b
+    try:
+      arena_service.record_battle(language, weight_class, model_a._id, model_b._id, winner._id, user_id)
+      arena_service.update_leaderboard(language, weight_class)
+      return "投票が完了しました"
+    except Exception as e:
+      return f"エラー: {e}"
+
+  def handle_vote(vote_choice, weight_class, model_a_name, model_b_name, request: gr.Request):
+    msg = submit_vote(vote_choice, weight_class, model_a_name, model_b_name, request)
+    return (
+      gr.update(value=msg, visible=True),
+      gr.update(interactive=False, value=model_a_name),
+      gr.update(interactive=False, value=model_b_name),
+      gr.update(visible=False),
+      gr.update(visible=True, interactive=True)
+    )
+
+  def generate_anonymous_user_id(request: gr.Request):
+    user_ip = request.headers.get('x-forwarded-for')
+    if user_ip:
+      user_id = "indiebot:" + user_ip
+      hashed_user_id = hashlib.sha256(user_id.encode("utf-8")).hexdigest()[:16]
+      return hashed_user_id
+    else:
+      return "anonymous"
+
+  def on_vote_a_click(weight, a, b, request: gr.Request):
+    return handle_vote("Chatbot A", weight, a, b, request)
+
+  def on_vote_b_click(weight, a, b, request: gr.Request):
+    return handle_vote("Chatbot B", weight, a, b, request)
+
+  def reset_battle(dropdown_options):
+    value_a, value_b = get_random_values(dropdown_options)
+    return (
+      [],  # chatbot_aのリセット
+      [],  # chatbot_bのリセット
+      gr.update(value="", visible=True),  # user_inputのクリア＆表示
+      gr.update(interactive=False, value="A is better"),  # vote_a_btnのリセット
+      gr.update(interactive=False, value="B is better"),  # vote_b_btnのリセット
+      gr.update(visible=False),  # vote_messageの非表示
+      gr.update(visible=False, interactive=False),  # next_battle_btnの非表示
+      gr.update(choices=dropdown_options, value=value_a),  # model_dropdown_a更新
+      gr.update(choices=dropdown_options, value=value_b),  # model_dropdown_b更新
+      gr.update(interactive=True)  # weight_class_radio を有効化
+    )
+
+  with gr.Blocks(css="style.css") as battle_ui:
+    gr.Markdown(DESCRIPTION)
+    weight_class_radio = gr.Radio(
+      choices=["U-5GB", "U-10GB"],
+      label="階級",
+      value=default_weight
+    )
+    dropdown_options_state = gr.State(initial_choices)
+    with gr.Row():
+      model_dropdown_a = gr.Dropdown(
+        choices=initial_choices,
+        label="モデルAを選択",
+        value=initial_value_a,
+        visible=dropdown_visible
+      )
+      model_dropdown_b = gr.Dropdown(
+        choices=initial_choices,
+        label="モデルBを選択",
+        value=initial_value_b,
+        visible=dropdown_visible
+      )
+    weight_class_radio.change(
+      fn=fetch_model_dropdown,
+      inputs=weight_class_radio,
+      outputs=[model_dropdown_a, model_dropdown_b, dropdown_options_state]
+    )
+    with gr.Row():
+      chatbot_a = gr.Chatbot(label="Chatbot A")
+      chatbot_b = gr.Chatbot(label="Chatbot B")
+    with gr.Row():
+      vote_a_btn = gr.Button("A is better", interactive=False)
+      vote_b_btn = gr.Button("B is better", interactive=False)
+    user_input = gr.Textbox(
+      placeholder="日本語でメッセージを入力...",
+      submit_btn=True,
+      show_label=False
+    )
+    with gr.Row():
+      with gr.Column(scale=3):
+        vote_message = gr.Textbox(show_label=False, interactive=False, visible=False)
+      with gr.Column(scale=1):
+        next_battle_btn = gr.Button("次のバトルへ", interactive=False, visible=False, elem_id="next_battle_btn")
+    user_input.submit(
+      fn=submit_message,
+      inputs=[user_input, chatbot_a, chatbot_b, model_dropdown_a, model_dropdown_b],
+      outputs=[chatbot_a, chatbot_b, user_input, vote_a_btn, vote_b_btn, weight_class_radio]
+    )
+    vote_a_btn.click(
+      fn=on_vote_a_click,
+      inputs=[weight_class_radio, model_dropdown_a, model_dropdown_b],
+      outputs=[vote_message, vote_a_btn, vote_b_btn, user_input, next_battle_btn]
+    )
+    vote_b_btn.click(
+      fn=on_vote_b_click,
+      inputs=[weight_class_radio, model_dropdown_a, model_dropdown_b],
+      outputs=[vote_message, vote_a_btn, vote_b_btn, user_input, next_battle_btn]
+    )
+    next_battle_btn.click(
+      fn=reset_battle,
+      inputs=[dropdown_options_state],
+      outputs=[
+        chatbot_a, chatbot_b, user_input, vote_a_btn,
+        vote_b_btn, vote_message, next_battle_btn,
+        model_dropdown_a, model_dropdown_b, weight_class_radio
+      ]
+    )
+  return battle_ui

indiebot_arena/ui/leaderboard.py

@@ -0,0 +1,47 @@
+import os
+
+import gradio as gr
+import pandas as pd
+
+from indiebot_arena.service.arena_service import ArenaService
+
+DESCRIPTION = "### 🏆️ リーダーボード"
+
+base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+docs_path = os.path.join(base_dir, "docs", "leaderboard_header.md")
+
+def leaderboard_content(dao, language):
+  arena_service = ArenaService(dao)
+
+  def fetch_leaderboard_data(weight_class):
+    entries = arena_service.get_leaderboard(language, weight_class)
+    data = []
+    for entry in entries:
+      model_obj = arena_service.dao.get_model(entry.model_id)
+      model_name = model_obj.model_name if model_obj else "Unknown"
+      file_size = model_obj.file_size_gb if model_obj else "N/A"
+      desc = model_obj.description if model_obj else ""
+      last_updated = entry.last_updated.strftime("%Y-%m-%d %H:%M:%S")
+      data.append([model_name, entry.elo_score, file_size, desc, last_updated])
+    if not data:
+      data = [["No data available", "", "", "", ""]]
+    df = pd.DataFrame(data, columns=["Model Name", "Elo Score", "File Size (GB)", "Description", "Last Updated"])
+    df.insert(0, "Rank", range(1, len(df) + 1))
+    return df
+
+  initial_weight_class = "U-5GB"
+  with gr.Blocks(css="style.css") as leaderboard_ui:
+    with open(docs_path, "r", encoding="utf-8") as f:
+      markdown_content = f.read()
+    gr.Markdown(markdown_content)
+    gr.Markdown(DESCRIPTION)
+    weight_class_radio = gr.Radio(choices=["U-5GB", "U-10GB"], label="階級", value=initial_weight_class)
+    leaderboard_table = gr.Dataframe(
+      headers=["Rank", "Model Name", "Elo Score", "File Size (GB)", "Description", "Last Updated"],
+      value=fetch_leaderboard_data(initial_weight_class),
+      interactive=False
+    )
+    refresh_btn = gr.Button("更新")
+    weight_class_radio.change(fn=fetch_leaderboard_data, inputs=weight_class_radio, outputs=leaderboard_table)
+    refresh_btn.click(fn=fetch_leaderboard_data, inputs=weight_class_radio, outputs=leaderboard_table)
+  return leaderboard_ui

indiebot_arena/ui/registration.py

@@ -0,0 +1,196 @@
+import os
+import re
+from dataclasses import dataclass
+
+import gradio as gr
+import spaces
+import torch
+from huggingface_hub import hf_hub_url, get_hf_file_metadata, model_info
+from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig
+
+from indiebot_arena.service.arena_service import ArenaService
+from indiebot_arena.ui.battle import generate
+
+DESCRIPTION = "### 📚️ 登録済みモデル"
+
+base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+docs_path = os.path.join(base_dir, "docs", "model_registration_guide.md")
+
+
+@dataclass
+class ModelMeta:
+  model_id: str
+  architecture: list
+  parameters: str
+  model_type: str
+  weights_file_size: float
+  weights_format: str
+  quantization: str
+
+
+def format_model_meta(meta: ModelMeta) -> str:
+  return (
+    f"Model ID: {meta.model_id}\n"
+    f"Architecture: {meta.architecture}\n"
+    f"Parameters: {meta.parameters}\n"
+    f"Model Type: {meta.model_type}\n"
+    f"Weights File Size: {meta.weights_file_size} GB\n"
+    f"Weights Format: {meta.weights_format}\n"
+    f"Quantization: {meta.quantization}"
+  )
+
+
+@spaces.GPU(duration=30)
+def get_model_meta(model_id: str):
+  try:
+    config = AutoConfig.from_pretrained(model_id)
+    model = AutoModelForCausalLM.from_pretrained(
+      model_id,
+      device_map="auto",
+      torch_dtype=torch.bfloat16,
+      use_safetensors=True
+    )
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    repo_info = model_info(model_id)
+    weights_files = [file.rfilename for file in repo_info.siblings if
+                     file.rfilename.endswith('.bin') or file.rfilename.endswith('.safetensors')]
+    total_size = 0
+    file_formats = set()
+    for file_name in weights_files:
+      file_formats.add(file_name.split('.')[-1])
+      file_url = hf_hub_url(model_id, filename=file_name)
+      metadata = get_hf_file_metadata(file_url)
+      total_size += metadata.size or 0
+    total_size_gb = round(total_size / (1024 ** 3), 2)
+    model_type = type(model).__name__
+    quant_config = getattr(config, 'quantization_config', {})
+    quant_method = quant_config.get('quant_method', 'none')
+    meta = ModelMeta(
+      model_id=model_id,
+      architecture=config.architectures if hasattr(config, 'architectures') else [],
+      parameters=f"{round(sum(p.numel() for p in model.parameters()) / 1e9, 2)} Billion",
+      model_type=model_type,
+      weights_file_size=total_size_gb,
+      weights_format=", ".join(file_formats),
+      quantization=quant_method,
+    )
+    return meta
+  except Exception as e:
+    return f"Error: {str(e)}"
+
+
+def registration_content(dao, language):
+  arena_service = ArenaService(dao)
+
+  def fetch_models(weight_class):
+    models = arena_service.dao.find_models(language, weight_class)
+    data = []
+    for m in models:
+      created_at_str = m.created_at.strftime("%Y-%m-%d %H:%M:%S") if m.created_at else ""
+      data.append([m.weight_class, m.model_name, m.runtime, m.quantization, m.file_format, m.file_size_gb,
+                   m.description or "", created_at_str])
+    return data
+
+  def load_test(model_id, weight_class, current_output):
+    if not re.match(r'^[a-zA-Z0-9._-]+/[a-zA-Z0-9._-]+$', model_id):
+      err = "Error: Invalid model_id format. It must be in the format 'owner/model'."
+      return (current_output + "\n" + err, gr.update(interactive=False), None)
+    meta = get_model_meta(model_id)
+    if isinstance(meta, str) and meta.startswith("Error:"):
+      return (current_output + "\n" + meta, gr.update(interactive=False), None)
+    if weight_class=="U-5GB" and meta.weights_file_size >= 5.0:
+      err = f"Error: File size exceeds U-5GB limit. {meta.weights_file_size} GB"
+      return (current_output + "\n" + err, gr.update(interactive=False), None)
+    if weight_class=="U-10GB" and meta.weights_file_size >= 10.0:
+      err = f"Error: File size exceeds U-10GB limit. {meta.weights_file_size} GB"
+      return (current_output + "\n" + err, gr.update(interactive=False), None)
+    if "safetensors" not in meta.weights_format.lower():
+      err = "Error: Weights Format must include safetensors."
+      return (current_output + "\n" + err, gr.update(interactive=False), None)
+    if meta.quantization.lower() not in ["bitsandbytes", "none"]:
+      err = "Error: Quantization must be bitsandbytes or none."
+      return (current_output + "\n" + err, gr.update(interactive=False), None)
+    display_str = format_model_meta(meta) + "\n\nロードテストが成功しました。\nチャットテストを実施して下さい。\n"
+    return (current_output + "\n" + display_str, gr.update(interactive=True), meta)
+
+  def chat_test(model_id, current_output):
+    question = "日本の首都は？"
+    expected_word = "東京"
+    try:
+      response = generate(question, [], model_id)
+    except Exception as e:
+      error_msg = f"エラー: {str(e)}"
+      return (current_output + "\n" + error_msg, gr.update(interactive=False))
+
+    result_text = f"質問: {question}\n応答: {response}\n"
+    if expected_word in response:
+      result_text += "成功: 応答に期待するワードが含まれています。\nモデル登録を実施して下さい。\n"
+      register_enabled = True
+    else:
+      result_text += "失敗: 応答に期待するワードが含まれていません。\n"
+      register_enabled = False
+    return (current_output + "\n" + result_text, gr.update(interactive=register_enabled))
+
+  def register_model(meta, weight_class, description, current_output):
+    try:
+      if meta is None:
+        raise ValueError("No meta info available.")
+      model_id_extracted = meta.model_id
+      file_size_gb = meta.weights_file_size
+      quantization = "bnb" if meta.quantization.lower()=="bitsandbytes" else "none"
+      weights_format = meta.weights_format
+      file_format = "safetensors" if "safetensors" in weights_format.lower() else weights_format
+      desc = description if description else ""
+      arena_service.register_model(language, weight_class, model_id_extracted, "transformers", quantization, file_format, file_size_gb, desc)
+      arena_service.update_leaderboard(language, weight_class)
+      result = "モデルの登録が完了しました。"
+      disable = True
+    except Exception as e:
+      result = f"エラー: {str(e)}"
+      disable = False
+    new_output = current_output + "\n" + result
+    if disable:
+      btn_update = gr.update(interactive=False)
+    else:
+      btn_update = gr.update()
+    return new_output, meta, btn_update, btn_update, btn_update
+
+  def clear_all():
+    initial_weight = "U-5GB"
+    return "", initial_weight, "", "", gr.update(interactive=True), gr.update(interactive=False), gr.update(interactive=False), None
+
+  with gr.Blocks(css="style.css") as ui:
+    gr.Markdown(DESCRIPTION)
+    weight_class_radio = gr.Radio(choices=["U-5GB", "U-10GB"], label="階級", value="U-5GB")
+    mdl_list = gr.Dataframe(
+      headers=["Weight Class", "Model Name", "Runtime", "Quantization", "Weights Format",
+               "Weights File Size", "Description", "Created At"],
+      value=fetch_models("U-5GB"),
+      interactive=False
+    )
+    weight_class_radio.change(fn=fetch_models, inputs=weight_class_radio, outputs=mdl_list)
+    with gr.Accordion("🔰 モデルの登録ガイド", open=False):
+      with open(docs_path, "r", encoding="utf-8") as f:
+        markdown_content = f.read()
+      gr.Markdown(markdown_content)
+    with gr.Accordion("🤖 モデルの新規登録", open=False):
+      model_id_input = gr.Textbox(label="モデルID", max_lines=1)
+      reg_weight_class_radio = gr.Radio(choices=["U-5GB", "U-10GB"], label="階級", value="U-5GB")
+      description_input = gr.Textbox(label="Description (オプション)", placeholder="任意の説明を入力", max_lines=1, visible=False)
+      output_box = gr.Textbox(label="結果出力", lines=10)
+      meta_state = gr.State(None)
+      with gr.Row():
+        test_btn = gr.Button("ロードテスト")
+        chat_test_btn = gr.Button("チャットテスト", interactive=False)
+        register_btn = gr.Button("モデル登録", interactive=False)
+        clear_btn = gr.Button("クリア")
+      test_btn.click(fn=load_test, inputs=[model_id_input, reg_weight_class_radio, output_box], outputs=[output_box,
+                                                                                                         chat_test_btn,
+                                                                                                         meta_state])
+      chat_test_btn.click(fn=chat_test, inputs=[model_id_input, output_box], outputs=[output_box, register_btn])
+      register_btn.click(fn=register_model, inputs=[meta_state, reg_weight_class_radio, description_input,
+                                                    output_box], outputs=[output_box, meta_state, test_btn,
+                                                                          chat_test_btn, register_btn])
+      clear_btn.click(fn=clear_all, inputs=[], outputs=[model_id_input, reg_weight_class_radio, description_input,
+                                                        output_box, test_btn, chat_test_btn, register_btn, meta_state])
+  return ui

requirements.txt

@@ -1 +1,11 @@
-huggingface_hub==0.25.2
+accelerate==1.2.1
+bitsandbytes==0.44.1
+gradio==5.12.0
+huggingface-hub==0.27.1
+pandas==2.2.3
+peft==0.13.2
+pydantic==2.10.6
+pymongo[srv]==4.11.3
+spaces==0.32.0
+torch==2.4.0
+transformers==4.50.0

style.css

@@ -0,0 +1,19 @@
+h1 {
+  font-size: 2.5rem;
+  font-weight: 800;
+  text-align: left;
+  margin-bottom: 1rem;
+  line-height: 1.2;
+}
+
+#duplicate-button {
+  margin: auto;
+  color: #fff;
+  background: #1565c0;
+  border-radius: 100vh;
+}
+
+#next_battle_btn {
+  margin-top: auto;
+  height: 4rem;
+}