Add evaluator

.gitignore

@@ -0,0 +1,173 @@
+cache/
+
+# 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/
+
+# PyPI configuration file
+.pypirc

evaluator/Evaluator.ipynb

@@ -0,0 +1,127 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import psutil\n",
+    "from pathlib import Path\n",
+    "from dotenv import load_dotenv\n",
+    "from IPython.display import display\n",
+    "from pandarallel import pandarallel\n",
+    "from rich import print\n",
+    "from tqdm.auto import tqdm\n",
+    "from constants import RESULTS_DIR\n",
+    "import re\n",
+    "import json\n",
+    "\n",
+    "load_dotenv()\n",
+    "\n",
+    "pandarallel.initialize(\n",
+    "    progress_bar=True,\n",
+    "    verbose=0,\n",
+    "    nb_workers=max(1, psutil.cpu_count(logical=False) - 5),\n",
+    ")\n",
+    "\n",
+    "tqdm.pandas()\n",
+    "pd.set_option(\"display.max_rows\", 80)\n",
+    "pd.set_option(\"display.min_rows\", 60)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 1: Pick a model to evaluate\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MODEL_ID = \"deepseek-r1-distill-qwen-1.5b\"\n",
+    "MODEL_NAME = \"deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B\"\n",
+    "MODEL_TEMP = 0.6\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 2: Run evaluations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from benchmarks import RobloxQAEvaluator\n",
+    "\n",
+    "\n",
+    "print(f\"Evaluating [green]{MODEL_NAME}[/green]\")\n",
+    "\n",
+    "evaluation = {\n",
+    "    \"Model\": MODEL_NAME,\n",
+    "    \"Results\": {\n",
+    "        \"RobloxQA\": RobloxQAEvaluator(\n",
+    "            MODEL_ID,\n",
+    "            temperature=MODEL_TEMP,\n",
+    "        ).run_evaluations(),\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "print(f\"Evaluation Result\\n[white]{json.dumps(evaluation, indent=2)}[/white]\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 3: Save evaluation results\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RESULT_PATH = RESULTS_DIR / (re.sub(r\"\\W+\", \"_\", MODEL_NAME) + \".json\")\n",
+    "Path(RESULT_PATH).parent.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "with open(RESULT_PATH, \"w\") as f:\n",
+    "    json.dump(evaluation, f, indent=2)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "roblox-llm-leaderboard-results-O7xMa1b9-py3.11",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

evaluator/benchmarks/__init__.py

@@ -0,0 +1,3 @@
+from .robloxqa import RobloxQAEvaluator
+
+__all__ = ["RobloxQAEvaluator"]

evaluator/benchmarks/base.py

@@ -0,0 +1,67 @@
+import pandas as pd
+from llm_utils import Message
+
+
+class Evaluator:
+    model_id: str
+    temperature: float
+    max_tokens: int
+    stop: list[str] | None = None
+
+    def __init__(
+        self,
+        model_id: str,
+        temperature: float = 0.8,
+        max_tokens: int = 3000,
+        stop: list[str] | None = None,
+    ):
+        self.model_id = model_id
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.stop = stop
+
+    def _fetch_dataset(self) -> pd.DataFrame:
+        raise NotImplementedError()
+
+    def _build_messages(self, row: pd.Series) -> list[Message]:
+        raise NotImplementedError()
+
+    def _score_response(self, row: pd.Series, response: str) -> float:
+        raise NotImplementedError()
+
+    def _process_response(self, response: str) -> str:
+        return response.strip()
+
+    def _evaluate(self, row: pd.Series) -> float:
+        """
+        Run the evaluation for the given row.
+        This function should be called by the parallelized version of df apply.
+        """
+        # To parallelize safely on Windows, the function must be self contained.
+        # This means we need to import the necessary modules inside the function.
+        from llm_utils import LLM
+
+        llm = LLM(self.model_id)
+        response = llm.generate(
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            stop=self.stop,
+            messages=self._build_messages(row),
+        )
+        response = self._process_response(response)
+        score = self._score_response(row, response)
+        return score
+
+    def run_evaluations(self) -> float:
+        """
+        Run the evaluations for the entire dataset.
+        """
+        dataset = self._fetch_dataset()
+
+        print(f"Running {self.__class__.__name__}")
+
+        scores = dataset.parallel_apply(self._evaluate, axis=1)
+        # scores = dataset.apply(self._evaluate, axis=1)
+        print("Score Counts:\n", scores.value_counts())
+
+        return float(scores.mean())

evaluator/benchmarks/robloxqa.py

@@ -0,0 +1,69 @@
+import re
+
+import pandas as pd
+from llm_utils import Message
+from load_dataset import load_dataset
+
+from .base import Evaluator
+
+USER_MESSAGE_TEMPLATE = """\
+Question:
+{prompt}
+
+Choices:
+{choices}
+
+
+Please choose the correct answer choice for the above question.
+Write the letter of your selected choice in this exact format:
+"Answer: letter_goes_here"
+"""
+
+DATASET_ID = "boatbomber/RobloxQA-v1.0"
+DATASET_SPLIT = "test"
+
+
+class RobloxQAEvaluator(Evaluator):
+    _answer_choices = ["a", "b", "c", "d", "e"]
+    _answer_pattern = re.compile(r"answer: ([a-e])")
+
+    def _fetch_dataset(self) -> pd.DataFrame:
+        dataset = load_dataset(
+            dataset_id=DATASET_ID,
+            split=DATASET_SPLIT,
+        )
+        return dataset
+
+    def _build_messages(self, row: pd.Series) -> list[Message]:
+        return [
+            {
+                "role": "user",
+                "content": USER_MESSAGE_TEMPLATE.format(
+                    prompt=row["prompt"],
+                    choices="\n".join(
+                        f"{choice.upper()}: {row['choices'][index]}"
+                        for index, choice in enumerate(self._answer_choices)
+                    ),
+                ),
+            },
+        ]
+
+    def _process_response(self, response: str) -> str:
+        return response.strip().lower()
+
+    def _score_response(self, row: pd.Series, response: str) -> float:
+        # Find the last occurrence of _answer_pattern in response
+        matches = self._answer_pattern.findall(response)
+        if not matches:
+            return 0.0
+
+        chosen_answer = matches[-1]
+        if chosen_answer not in self._answer_choices:
+            return 0.0
+
+        chosen_answer_index = self._answer_choices.index(chosen_answer)
+        correct_answer_index = row["answer"]
+        if chosen_answer_index == correct_answer_index:
+            return 100.0
+
+        return 0.0

evaluator/constants.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+INFERENCE_PROVIDER_URL = "http://localhost:8020/v1"  # "https://api.together.xyz/v1"  #
+
+ROOT_DIR = Path(__file__).resolve().parent.parent
+
+RESULTS_DIR = ROOT_DIR / "results"
+RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+
+CACHE_DIR = ROOT_DIR / "cache"
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+DATASET_CACHE_DIR = CACHE_DIR / "datasets"
+DATASET_CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+RESPONSE_CACHE_DIR = CACHE_DIR / "llm_responses"
+RESPONSE_CACHE_DIR.mkdir(parents=True, exist_ok=True)

evaluator/llm_utils/__init__.py

@@ -0,0 +1,4 @@
+from .llm import LLM
+from .message import Message
+
+__all__ = ["LLM", "Message"]

evaluator/llm_utils/llm.py

@@ -0,0 +1,92 @@
+import os
+import re
+import time
+import traceback
+from hashlib import md5
+
+from constants import INFERENCE_PROVIDER_URL, RESPONSE_CACHE_DIR
+from openai import OpenAI
+
+client = OpenAI(
+    base_url=INFERENCE_PROVIDER_URL,
+    api_key=os.getenv("API_KEY", ""),
+)
+
+
+class LLM:
+    model_id: str
+    model_id_sanitized: str
+
+    def __repr__(self) -> str:
+        return f"LLM(model_id='{self.model_id})"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __init__(self, model_id: str):
+        self.model_id = model_id
+        self.model_id_sanitized = re.sub(r"[^a-zA-Z0-9_-]", "_", self.model_id)
+
+    def _get_cache_key(self, *args, **kwargs) -> str:
+        return md5(
+            str(args).encode() + str(kwargs).encode(), usedforsecurity=False
+        ).hexdigest()
+
+    def _read_cache(self, cache_key: str) -> str | None:
+        path = RESPONSE_CACHE_DIR / self.model_id_sanitized / f"{cache_key}.txt"
+        if path.exists():
+            content = path.read_text(encoding="utf-8")
+            return content
+        return None
+
+    def _write_cache(self, cache_key: str, response: str) -> None:
+        path = RESPONSE_CACHE_DIR / self.model_id_sanitized / f"{cache_key}.txt"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(response, encoding="utf-8")
+
+    def _run_stream(self, cache_key: str, **kwargs) -> str:
+        stream = client.chat.completions.create(
+            model=self.model_id,
+            stream=True,
+            **kwargs,
+        )
+
+        response_builder = []
+        for chunk in stream:
+            content = chunk.choices[0].delta.content
+            if content is not None:
+                response_builder.append(content)
+
+        response = "".join(response_builder)
+        self._write_cache(cache_key, response)
+        return response
+
+    def generate(self, **kwargs) -> str:
+        cache_key = self._get_cache_key(
+            model=self.model_id,
+            **kwargs,
+        )
+
+        cached_response = self._read_cache(cache_key)
+        if cached_response is not None:
+            return cached_response
+
+        attempts = 0
+        max_attempts = 3
+        while attempts < max_attempts:
+            try:
+                return self._run_stream(cache_key, **kwargs)
+            except Exception as e:
+                print(f"\nError running stream for {self.model_id}:")
+                traceback.print_exc()
+                attempts += 1
+                if attempts >= max_attempts:
+                    raise e
+
+                print(f"\nRetrying after {2**attempts} seconds...")
+                time.sleep(2**attempts)  # Exponential backoff
+
+        print(
+            f"\nFailed to generate response from {self.model_id} after {max_attempts} attempts."
+        )
+        return None

evaluator/llm_utils/message.py

@@ -0,0 +1,6 @@
+from typing import TypedDict
+
+
+class Message(TypedDict):
+    role: str
+    content: str

evaluator/load_dataset.py

@@ -0,0 +1,51 @@
+import datasets
+import pandas as pd
+from constants import DATASET_CACHE_DIR
+from rich import print
+
+PD_CACHE_DIR = DATASET_CACHE_DIR / "pandas"
+
+
+def load_from_pd_cache(dataset_id: str, split: str) -> pd.DataFrame | None:
+    """
+    Load the dataset from the pandas cache if it exists.
+    """
+    cached_path = PD_CACHE_DIR / dataset_id / f"{split}.parquet"
+    if cached_path.exists() and cached_path.is_file():
+        print(
+            f"[bold white]Loading [red]{dataset_id}:{split}[/red] from cache[/bold white]"
+        )
+        return pd.read_parquet(cached_path)
+    return None
+
+
+def load_from_hf_dataset(dataset_id: str, split: str) -> pd.DataFrame:
+    """
+    Load the dataset from the Hugging Face dataset hub.
+    """
+    print(
+        f"[bold white]Loading [red]{dataset_id}:{split}[/red] from HuggingFace[/bold white]"
+    )
+
+    dataset = datasets.load_dataset(
+        dataset_id,
+        split=split,
+        cache_dir=DATASET_CACHE_DIR,
+        verification_mode=datasets.VerificationMode.NO_CHECKS,
+    ).to_pandas()
+
+    # Save the dataset to the pandas cache
+    print(f"[bold white]Writing [red]{dataset_id}:{split}[/red] to cache[/bold white]")
+    cached_path = PD_CACHE_DIR / dataset_id / f"{split}.parquet"
+    cached_path.parent.mkdir(parents=True, exist_ok=True)
+    dataset.to_parquet(cached_path)
+
+    return dataset
+
+
+def load_dataset(dataset_id: str, split: str) -> pd.DataFrame:
+    cached = load_from_pd_cache(dataset_id, split)
+    if cached is not None:
+        return cached
+
+    return load_from_hf_dataset(dataset_id, split)

pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "Roblox-LLM-Leaderboard-results"
+version = "1.0.0"
+description = "Dataset containing LLM leaderboard results"
+authors = [{ name = "boatbomber", email = "[email protected]" }]
+readme = "README.md"
+requires-python = "3.11.*"
+dependencies = [
+    "huggingface-hub (>=0.29.1,<0.30.0)",
+    "openai (>=1.63.2,<2.0.0)",
+    "datasets (>=3.3.2,<4.0.0)",
+    "pandas (>=2.2.3,<3.0.0)",
+    "tqdm (>=4.67.1,<5.0.0)",
+    "rich (>=13.9.4,<14.0.0)",
+    "pandarallel (>=1.6.5,<2.0.0)",
+    "python-dotenv (>=1.0.1,<2.0.0)",
+    "ipywidgets (>=8.1.5,<9.0.0)",
+    "ipykernel (>=6.29.5,<7.0.0)",
+    "scikit-learn (>=1.6.1,<2.0.0)",
+    "pyyaml (>=6.0.2,<7.0.0)",
+]
+
+[tool.poetry]
+package-mode = false
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"