diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml new file mode 100644 index 0000000..b3a4733 --- /dev/null +++ b/.github/workflows/python-publish.yml @@ -0,0 +1,39 @@ +name: Publish Python Package + +on: + push: + tags: + - "v*" + +jobs: + build-and-publish: + name: Build and Publish + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: "3.10" + + - name: Install Poetry + run: | + curl -sSL https://install.python-poetry.org | python3 - + echo "export PATH=\"$HOME/.local/bin:$PATH\"" >> $GITHUB_ENV + + - name: Install dependencies + run: poetry install --no-interaction --no-ansi + + - name: Build the package + run: poetry build + + - name: Configure Poetry for PyPI + run: | + poetry config pypi-token.pypi ${{ secrets.TWINE_API_TOKEN }} + + - name: Publish to PyPI + run: | + poetry publish --no-interaction --no-ansi \ No newline at end of file diff --git a/.github/workflows/test-package.yml b/.github/workflows/test-package.yml new file mode 100644 index 0000000..bebadf9 --- /dev/null +++ b/.github/workflows/test-package.yml @@ -0,0 +1,38 @@ +name: Test YESciEval Package + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + build-and-test: + runs-on: ubuntu-latest + + strategy: + matrix: + python-version: [3.10.x, 3.11.x, 3.12.x, 3.13.x] + + steps: + - name: Checkout repository + uses: actions/checkout@v3 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + + - name: Install Poetry + run: | + curl -sSL https://install.python-poetry.org | python3 - + echo "$HOME/.local/bin" >> $GITHUB_PATH + + - name: Configure Poetry and install dependencies + run: | + poetry config virtualenvs.create false + poetry install --no-interaction --with dev + + - name: Run tests + run: | + poetry run pytest diff --git a/.gitignore b/.gitignore index 8fe170b..80419c2 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,8 @@ __pycache__/ *.py[cod] *$py.class .idea/ +assets/models +trash/ # C extensions *.so trashdir/ diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..25a33f4 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,11 @@ +## Changelog + +### v0.2.0 (May 30, 2025) +- Add custom judge module. +- Add documentation. +- Bug fixing. +- Add readme. +- Add test CI/CD + +### v0.1.0 (May 30, 2025) +- First version of YESciEval \ No newline at end of file diff --git a/LICENSE b/LICENSE index af627d5..2234a2f 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2025 XXX +Copyright (c) 2025 SciKnowOrg Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. +SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md index 3736310..5dcf9a2 100644 --- a/README.md +++ b/README.md @@ -1,28 +1,116 @@
- + OntoLearner Logo
+ PyPI version + YESciEval HF + License: MIT + Documentation Status -[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit) -[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) -[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/) -[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) +
+Large Language Models (LLMs) have become pivotal in powering scientific question-answering across modern search engines, yet their evaluation robustness remains largely underexplored. To address this gap, we introduce **YESciEval** โ€” an open-source framework that leverages fine-grained rubric-based assessments combined with reinforcement learning to reduce optimism bias in LLM evaluators. - +YESciEval provides a comprehensive library for evaluating the quality of synthesized scientific answers using predefined rubrics and sophisticated LLM-based judgment models. This framework enables you to assess answers on key criteria by utilizing pretrained judges and parsing LLM outputs into structured JSON formats for detailed analysis. + + +## ๐Ÿงช Installation +You can install ``YESciEval`` from PyPI using pip: + +```bash +pip install yescieval +``` +Next, verify the installation: +```python +import yescieval + +print(yescieval.__version__) +``` + +## ๐Ÿ”— Essential Resources + +Specialized Judges within YESciEval are: + +| Judge | Domain | Dataset Used | ๐Ÿค— Hugging Face | +|----------------|------------------------------------|-------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------| +| **Ask Judge** | Multidisciplinary (33 disciplines) | [ORKGSyn (Open Research Knowledge Graph)](https://data.uni-hannover.de/dataset/yescieval-corpus) | [SciKnowOrg/YESciEval-ASK-Llama-3.1-8B](https://huggingface.co/SciKnowOrg/YESciEval-ASK-Llama-3.1-8B) | +| **BioASQ Judge**| Biomedical | [BioASQ](https://data.uni-hannover.de/dataset/yescieval-corpus) | [SciKnowOrg/YESciEval-BioASQ-Llama-3.1-8B](https://huggingface.co/SciKnowOrg/YESciEval-BioASQ-Llama-3.1-8B) | + + +For further information dive into YESciEval's extensive documentation to explore its models and usage at **[๐Ÿ“š YESciEval Documentation](https://yescieval.readthedocs.io/)**. +## ๐Ÿš€ Quick Tour + +Get started with YESciEval in just a few lines of code. This guide demonstrates how to initialize inputs, load judge, and initiate rubric for evaluation of the answer. + + +```python +from yescieval import Readability, AutoJudge + +# Sample papers +papers = { + "A Study on AI": "This paper discusses recent advances in artificial intelligence, including deep learning.", + "Machine Learning Basics": "An overview of supervised learning methods such as decision trees and SVMs.", + "Neural Networks Explained": "Explains backpropagation and gradient descent for training networks.", + "Ethics in AI": "Explores ethical concerns in automated decision-making systems.", + "Applications of AI in Healthcare": "Details how AI improves diagnostics and personalized medicine." +} + +# Question and synthesized answer +question = "How is AI used in modern healthcare systems?" +answer = ( + "AI is being used in healthcare for diagnosing diseases, predicting patient outcomes, " + "and assisting in treatment planning. It also supports personalized medicine and medical imaging." +) + +# Step 1: Create a rubric +rubric = Readability(papers=papers, question=question, answer=answer) + +# Step 2: Load a judge model (Ask Judge by default) +judge = AutoJudge() +judge.from_pretrained( + model_id="SciKnowOrg/YESciEval-ASK-Llama-3.1-8B", + token="your_huggingface_token", +) + +# Step 3: Evaluate the answer +result = judge.evaluate(rubric=rubric) +print("Raw Evaluation Output:") +print(result) +``` + +Judges within YESciEval are defined as follows: +| Class Name | Description | +| ---------------- |----------------------------------------------------------------------------------------------| +| `AutoJudge` | Base class for loading and running evaluation models with PEFT adapters. | +| `AskAutoJudge` | Multidisciplinary judge tuned on the ORKGSyn dataset from the Open Research Knowledge Graph. | +| `BioASQAutoJudge` | Biomedical domain judge tuned on the BioASQ dataset from the BioASQ challenge. | +| `CustomAutoJudge`| Custom LLM that can be used as a judge within YESciEval rubrics | -## ๐Ÿ“‹ What is the YESciEval? +A total of nine evaluation rubrics were defined as part of the YESciEval test framework and can be used via ``yescieval``. Following simple example shows how to import rubrics in your code: +```python +from yescieval import Informativeness, Correctness, Completeness, + Coherence, Relevancy, Integration, + Cohesion, Readability, Conciseness +``` -Large Language Models (LLMs) drive scientific question-answering on modern search engines, yet their evaluation robustness remains underexplored. We introduce **YESciEval**, an open-source framework that combines fine-grained rubric-based assessment with reinforcement learning to mitigate optimism bias in LLM evaluators. The framework is presented as f ollows: +A complete list of rubrics are available at YESciEval [๐Ÿ“š Rubrics](https://yescieval.readthedocs.io/rubrics.html) page. +## ๐Ÿ’ก Acknowledgements -We release multidisciplinary scienceQ&A datasets, including adversarial variants, with evaluation scores from multiple LLMs. Independent of proprietary models and human feedback, our approach enables scalable, cost-free evaluation. By advancing reliable LLM-as-a-judge models, this work supports AI alignment and fosters robust, transparent evaluation essential for scientific inquiry and artificial general intelligence. +If you use YESciEval in your research, please cite: -## ๐Ÿ“ƒ License +```bibtex +@article{d2025yescieval, + title={YESciEval: Robust LLM-as-a-Judge for Scientific Question Answering}, + author={D'Souza, Jennifer and Giglou, Hamed Babaei and M{\"u}nch, Quentin}, + journal={arXiv preprint arXiv:2505.14279}, + year={2025} + } +``` This work is licensed under a [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT). diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..d0c3cbf --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..9534b01 --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=source +set BUILDDIR=build + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..d02db8b --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,13 @@ +sphinx +sphinx-rtd-theme +sphinx_autodoc_typehints +myst-parser +sphinx_markdown_tables +sphinx-copybutton +sphinxcontrib-mermaid +sphinx-panels +sphinx-design +sphinx-tabs +sphinx-inline-tabs +snowballstemmer +sphinx_toolbox diff --git a/docs/source/_static/custom.css b/docs/source/_static/custom.css new file mode 100644 index 0000000..e69de29 diff --git a/docs/source/_static/custom.js b/docs/source/_static/custom.js new file mode 100644 index 0000000..e69de29 diff --git a/docs/source/_templates/layout.html b/docs/source/_templates/layout.html new file mode 100644 index 0000000..72abf2e --- /dev/null +++ b/docs/source/_templates/layout.html @@ -0,0 +1,9 @@ +{% extends "!layout.html" %} +{% block extrahead %} + +{% endblock %} + +{# Override breadcrumbs with our custom template #} +{% block breadcrumbs %} + {% include "breadcrumbs.html" %} +{% endblock %} diff --git a/docs/source/conf.py b/docs/source/conf.py new file mode 100644 index 0000000..259b318 --- /dev/null +++ b/docs/source/conf.py @@ -0,0 +1,153 @@ +# Configuration file for the Sphinx documentation builder. +# import pathlib +# import sys +import datetime +import importlib +import inspect +import os + + +from sphinx.application import Sphinx +from sphinx.writers.html5 import HTML5Translator +import posixpath + +year = str(datetime.datetime.now().year) +project = 'YESciEval' +copyright = year + ' SciKnowOrg' +release = '0.1.0' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + "sphinx.ext.napoleon", + "sphinx.ext.autodoc", + "myst_parser", + "sphinx_markdown_tables", + "sphinx_copybutton", + "sphinx.ext.intersphinx", + "sphinx.ext.linkcode", + "sphinx_inline_tabs", + "sphinxcontrib.mermaid", + "sphinx_toolbox.collapse", +] + +# autosummary_generate = True # Turn on sphinx.ext.autosummary + +# Add any paths that contain templates here, relative to this directory. +templates_path = ["_templates"] + +# List of patterns, relative to source directory, that match files and +# directories to include when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +include_patterns = [ + "**", + "../../yescieval/", + "index.rst", +] +# Ensure exclude_patterns doesn't exclude your master document accidentally +exclude_patterns = [] + +# -- Options for HTML output ------------------------------------------------- + +source_suffix = '.rst' + +# specify the master doc, otherwise the build at read the docs fails +master_doc = "index" + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +html_theme = "sphinx_rtd_theme" + +html_theme_options = { + "external_links": [ + ("Github", "https://github.com/sciknoworg/YESciEval"), + ], + "navigation_depth": 4, + "collapse_navigation": True +} + +html_static_path = ["_static"] + +html_js_files = [ + 'https://cdnjs.cloudflare.com/ajax/libs/jquery/3.5.1/jquery.min.js', + 'custom.js' +] + +html_css_files = [ + # 'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css', + 'custom.css', +] + +html_show_sourcelink = True +html_context = { + "display_github": True, + "github_user": "sciknoworg", + "github_repo": "YESciEval", + "github_version": "main/", +} + +html_logo = 'images/logo.png' +html_favicon = "images/logo.ico" +autoclass_content = "both" + +# Required to get rid of some myst.xref_missing warnings +myst_heading_anchors = 3 + +html_copy_source = True +def linkcode_resolve(domain, info): + """ + Resolve a GitHub link for the given domain and info dictionary. + """ + if domain != "py" or not info["module"]: + return None + + # Define the GitHub repository URL + repo_url = "https://github.com/sciknoworg/YESciEval/blob/main" + branch = "main" # Update if using a different branch + + # Retrieve the module and object + try: + module = importlib.import_module(info["module"]) + except ImportError: + return None + + # Try to get the source file and line numbers + try: + file_path = inspect.getsourcefile(module) + source_lines, start_line = inspect.getsourcelines(getattr(module, info["fullname"])) + except (TypeError, AttributeError, OSError): + return None + + # Generate the relative file path and GitHub link + relative_path = os.path.relpath(file_path, start=os.path.dirname(__file__)) + end_line = start_line + len(source_lines) - 1 + return f"{repo_url}/blob/{branch}/{relative_path}#L{start_line}-L{end_line}" + +def visit_download_reference(self, node): + root = "https://github.com/sciknoworg/YESciEval/tree/main" + atts = {"class": "reference download", "download": ""} + + if not self.builder.download_support: + self.context.append("") + elif "refuri" in node: + atts["class"] += " external" + atts["href"] = node["refuri"] + self.body.append(self.starttag(node, "a", "", **atts)) + self.context.append("") + elif "reftarget" in node and "refdoc" in node: + atts["class"] += " external" + atts["href"] = posixpath.join(root, os.path.dirname(node["refdoc"]), node["reftarget"]) + self.body.append(self.starttag(node, "a", "", **atts)) + self.context.append("") + else: + self.context.append("") + + +HTML5Translator.visit_download_reference = visit_download_reference + +def setup(app: Sphinx): + pass diff --git a/docs/source/images/logo.ico b/docs/source/images/logo.ico new file mode 100644 index 0000000..314efa1 Binary files /dev/null and b/docs/source/images/logo.ico differ diff --git a/docs/source/images/logo.png b/docs/source/images/logo.png new file mode 100644 index 0000000..d2aba61 Binary files /dev/null and b/docs/source/images/logo.png differ diff --git a/docs/source/index.rst b/docs/source/index.rst new file mode 100644 index 0000000..b2204df --- /dev/null +++ b/docs/source/index.rst @@ -0,0 +1,70 @@ + + +.. raw:: html + +
+ OntoLearner Logo +
+ +.. raw:: html + +
+ PyPI version + YESciEval HF + License: MIT + Documentation Status + +
+ +
+
+ +YESciEval provides a comprehensive library for evaluating the quality of synthesized scientific answers using predefined rubrics and sophisticated LLM-based judgment models. This framework enables you to assess answers on key criteria by utilizing pretrained judges and parsing LLM outputs into structured JSON formats for detailed analysis. + +YESciEval was created by `Scientific Knowledge Organization (SciKnowOrg group) `_ at `Technische Informationsbibliothek (TIB) `_. Don't hesitate to open an issue on the `YESciEval repository `_ if something is broken or if you have further questions. + +.. seealso:: + + See the `Quickstart `_ for more quick information on how to use OntoLearner. + + + +If you find this repository helpful, feel free to cite our publication `YESciEval: Robust LLM-as-a-Judge for Scientific Question Answering `_: + + .. code-block:: bibtex + + @article{d2025yescieval, + title={YESciEval: Robust LLM-as-a-Judge for Scientific Question Answering}, + author={D'Souza, Jennifer and Giglou, Hamed Babaei and M{\"u}nch, Quentin}, + journal={arXiv preprint arXiv:2505.14279}, + year={2025} + } + + + +.. toctree:: + :maxdepth: 1 + :caption: Getting Started + :hidden: + + installation + quickstart + +.. toctree:: + :maxdepth: 1 + :caption: Evaluator + :hidden: + + rubrics + judges + +.. toctree:: + :maxdepth: 1 + :caption: Package Reference + :glob: + :hidden: + + package_reference/base + package_reference/judge + package_reference/rubric + package_reference/ diff --git a/docs/source/installation.rst b/docs/source/installation.rst new file mode 100644 index 0000000..14c91d4 --- /dev/null +++ b/docs/source/installation.rst @@ -0,0 +1,63 @@ +Installation +============= + +We recommend **Python 3.10+**,`PyTorch 1.4.0+ `_, and `transformers v4.41.0+ `_. + + +Install with pip +----------------------- + +.. sidebar:: Verify the installation + + Once the isntallation is done, verify the installation by: + + .. code-block:: python + + import yescieval + + print(yescieval.__version__) + + +.. tab:: From PyPI + + YESciEval is available on the Python Package Index at `pypi.org `_ for installation. + :: + + pip install -U yescieval + +.. tab:: From GitHub + + The following pip install will installs the latest version of OntoLearner from the `main` branch of the YESciEval at GitHub using `pip`. + + :: + + pip install git+https://github.com/sciknoworg/YESciEval.git + + +Install from Source +---------------------- +You can install YESciEval directly from source to take advantage of the bleeding edge main branch for development. + + +1. Clone the repository: + +.. code-block:: bash + + git clone https://github.com/sciknoworg/YESciEval.git + cd YESciEval + +2. (Optional but recommended) Create and activate a virtual environment: + +.. code-block:: bash + + python -m venv venv + source venv/bin/activate # On Windows: venv\Scripts\activate + +3. Install dependencies and the library + +.. code-block:: bash + + pip install -e . + +.. hint:: The -e flag installs the package in editable mode, which is ideal for developmentโ€”changes in the code reflect immediately. + diff --git a/docs/source/judges.rst b/docs/source/judges.rst new file mode 100644 index 0000000..0eb37af --- /dev/null +++ b/docs/source/judges.rst @@ -0,0 +1,91 @@ +Judges +================ + +YESciEval provides two pre-trained judge models designed to evaluate scientific text syntheses based on different domains and datasets: + +- **Ask Judge**: A multidisciplinary YESciEval judge fine-tuned on the ORKGSyn dataset from the Open Research Knowledge Graph. + +- **BioASQ Judge**: A biomedical YESciEval judge fine-tuned on the BioASQ dataset from the BioASQ challenge. + +.. hint:: Available YESciEval judge ๐Ÿค— Hugging Face: + + - `Ask Judge on Hugging Face `_ + - `BioASQ Judge on Hugging Face `_ + + +Using YESciEval Judges +------------------------ + +The following example demonstrates how to create an evaluation rubric, load a judge model, and evaluate an answer. + +.. code-block:: python + + from yescieval import Readability, AutoJudge + + papers = { + "A Study on AI": "This paper discusses recent advances in artificial intelligence, including deep learning.", + "Machine Learning Basics": "An overview of supervised learning methods such as decision trees and SVMs.", + "Neural Networks Explained": "Explains backpropagation and gradient descent for training networks.", + "Ethics in AI": "Explores ethical concerns in automated decision-making systems.", + "Applications of AI in Healthcare": "Details how AI improves diagnostics and personalized medicine." + } + + # Input question and synthesized answer + question = "How is AI used in modern healthcare systems?" + answer = ( + "AI is being used in healthcare for diagnosing diseases, predicting patient outcomes, " + "and assisting in treatment planning. It also supports personalized medicine and medical imaging." + ) + + # Step 1: Create a rubric + rubric = Readability(papers=papers, question=question, answer=answer) + instruction_prompt = rubric.instruct() + + # Step 2: Load the evaluation model (judge) + judge = AutoJudge() + judge.from_pretrained(model_id="SciKnowOrg/YESciEval-ASK-Llama-3.1-8B", + token="your_huggingface_token", + device="cpu") + + # Step 3: Evaluate the answer + result = judge.evaluate(rubric=rubric) + + print("Raw Evaluation Output:") + print(result) + +Specialized Judges vs. Custom Models +-------------------------------------- + +.. list-table:: Judge Class Overview + :header-rows: 1 + + * - Class Name + - Description + * - AutoJudge + - Base class for loading and running evaluation models (judges) with PEFT adapters. + * - AskAutoJudge + - Multidisciplinary judge tuned on the ORKGSyn dataset from the Open Research Knowledge Graph. + * - BioASQAutoJudge + - Biomedical domain judge tuned on the BioASQ dataset from the BioASQ challenge. + +The difference between **AskAutoJudge** and **BioASQAutoJudge** compared to **AutoJudge** is that these specialized judges have their own predefined model paths on Hugging Face, making it easier to load the respective domain-specific models. + +Custom Judge +-------------------- + +The `CustomAutoJudge` class provides flexibility to load any compatible LLM model from Hugging Face by specifying the model ID. This allows you to use any pre-trained or fine-tuned model beyond the default specialized judges using YESciEval. + +For example, you can load a model and evaluate a rubric like this: + +.. code-block:: python + + # Initialize and load a custom model by specifying its Hugging Face model ID + judge = CustomAutoJudge() + judge.from_pretrained(model_id="Qwen/Qwen3-8B", device="cpu", token="your_huggingface_token") + + # Evaluate the rubric using the loaded model + result = judge.evaluate(rubric=rubric) + + print(result) + +This approach allows full control over which model is used for evaluation, supporting any LLM.. diff --git a/docs/source/quickstart.rst b/docs/source/quickstart.rst new file mode 100644 index 0000000..f266e6d --- /dev/null +++ b/docs/source/quickstart.rst @@ -0,0 +1,87 @@ +Quickstart +================= + +YESciEval is a library designed to evaluate the quality of synthesized scientific answers using predefined rubrics and advanced LLM-based judgment models. This guide walks you through how to evaluate answers based on **informativeness** using a pretrained judge and parse LLM output into structured JSON. + + +**Example: Evaluating an Answer Using Informativeness + AskAutoJudge** + +.. code-block:: python + + from yescieval import Informativeness, AskAutoJudge, GPTParser + + # Sample papers used in form of {"title": "abstract", ... } + papers = { + "A Study on AI": "This paper discusses recent advances in artificial intelligence, including deep learning.", + "Machine Learning Basics": "An overview of supervised learning methods such as decision trees and SVMs.", + "Neural Networks Explained": "Explains backpropagation and gradient descent for training networks.", + "Ethics in AI": "Explores ethical concerns in automated decision-making systems.", + "Applications of AI in Healthcare": "Details how AI improves diagnostics and personalized medicine." + } + + # Input question and synthesized answer + question = "How is AI used in modern healthcare systems?" + answer = ( + "AI is being used in healthcare for diagnosing diseases, predicting patient outcomes, " + "and assisting in treatment planning. It also supports personalized medicine and medical imaging." + ) + + # Step 1: Create a rubric + rubric = Informativeness(papers=papers, question=question, answer=answer) + instruction_prompt = rubric.instruct() + + # Step 2: Load the evaluation model (judge) + judge = AskAutoJudge() + judge.from_pretrained(token="your_huggingface_token", device="cpu") + + # Step 3: Evaluate the answer + result = judge.evaluate(rubric=rubric) + + print("Raw Evaluation Output:") + print(result) + +.. tip:: + + - Ensure your Hugging Face model token has access to the model (e.g., ``YESciEval-ASK-Llama-3.1-8B``). + - Use the ``device="cuda"`` if running on GPU for better performance. + - Add more rubrics such as ``Informativeness``, ``Relevancy``, etc for multi-criteria evaluation. + +**Parsing Raw Output with GPTParser** + +If the model outputs unstructured or loosely structured text, you can use GPTParser to parse it into valid JSON. + +.. code-block:: python + + from yescieval import GPTParser + + raw_output = "` {rating: `4`, rational: The answer covers key aspects of how AI is applied in healthcare, such as diagnostics and personalized medicine.} `" + + parser = GPTParser(openai_key="your_openai_key") + + parsed = parser.parse(raw_output=raw_output) + + print("Parsed Output:") + print(parsed) + +**Expected Output Format** + +.. code-block:: json + + { + "rating": 4, + "rationale": "The answer covers key aspects of how AI is applied in healthcare, such as diagnostics and personalized medicine." + } + +.. hint:: Key Components + + +------------------+-------------------------------------------------------+ + | Component | Purpose | + +==================+=======================================================+ + | Informativeness | Defines rubric to evaluate relevance to source papers | + +------------------+-------------------------------------------------------+ + | AskAutoJudge | Loads and uses a judgment model to evaluate answers | + +------------------+-------------------------------------------------------+ + | GPTParser | Parses loosely formatted text from LLMs into JSON | + +------------------+-------------------------------------------------------+ + + diff --git a/docs/source/rubrics.rst b/docs/source/rubrics.rst new file mode 100644 index 0000000..3e78f14 --- /dev/null +++ b/docs/source/rubrics.rst @@ -0,0 +1,94 @@ + +Rubrics +=================== + +A total of nine evaluation rubrics were defined as part of the YESciEval test framework. + +Linguistic & Stylistic Quality +--------------------------------- + +Following ``Linguistic & Stylistic Quality`` concerns grammar, clarity, and adherence to academic writing conventions. + + +.. list-table:: + :header-rows: 1 + :widths: 20 80 + + * - Evaluation Rubric + - Description + * - **1. Cohesion:** + - Are the sentences connected appropriately to make the resulting synthesis cohesive? + * - **2. Conciseness:** + - Is the answer short and clear, without redundant statements? + * - **3. Readability:** + - Does the answer follow appropriate style and structure conventions for academic writing, particularly for readability? + +Logical & Structural Integrity +--------------------------------- +Following ``Logical & Structural Integrity`` focuses on the reasoning and organization of information. + +.. list-table:: + :header-rows: 1 + :widths: 20 80 + + * - Evaluation Rubric + - Description + * - **4. Coherence:** + - Are the ideas connected soundly and logically? + * - **5. Integration:** + - Are the sources structurally and linguistically well-integrated, using appropriate markers of provenance/quotation and logical connectors for each reference? + * - **6. Relevancy:** + - Is the information in the answer relevant to the problem? + +Content Accuracy & Informativeness +--------------------------------- + +Following ``Content Accuracy & Informativeness`` ensures that the response is both correct and useful. + + +.. list-table:: + :header-rows: 1 + :widths: 20 80 + + * - Evaluation Rubric + - Description + * - **7. Correctness:** + - Is the information in the answer a correct representation of the content of the provided abstracts? + * - **8. Completeness:** + - Is the answer a comprehensive encapsulation of the relevant information in the provided abstracts? + * - **9. Informativeness:** + - Is the answer a useful and informative reply to the problem? + + + +Usage Example +-------------------------- + +Here is a simple example of how to import rubrics in your code: + +.. code-block:: python + + from yescieval import Informativeness, Correctness, Completeness, + Coherence, Relevancy, Integration, + Cohesion, Readability, Conciseness + +And to use rubrics: + +.. code-block:: python + + # Example inputs + papers = { + "Paper 1 title": "abstract of paper 1 ...", + "Paper 2 title": "abstract of paper 2 ...", + "Paper 3 title": "abstract of paper 3 ...", + "Paper 4 title": "abstract of paper 4 ...", + "Paper 5 title": "abstract of paper 5 ..." + } + question = "What are the key findings on AI in these papers?" + answer = "The synthesis answer summarizing the papers." + + # Instantiate a rubric, e.g. Coherence + rubric = Coherence(papers=papers, question=question, answer=answer) + instruction = rubric.instruct() + + print(instruction) diff --git a/experiments/images/confusion_matrix_vanilla_v2.pdf b/experiments/images/confusion_matrix_vanilla_v2.pdf index 494fcbb..71220ca 100644 Binary files a/experiments/images/confusion_matrix_vanilla_v2.pdf and b/experiments/images/confusion_matrix_vanilla_v2.pdf differ diff --git a/experiments/images/confusion_matrix_vanilla_v2.png b/experiments/images/confusion_matrix_vanilla_v2.png index ad24d79..0ea7431 100644 Binary files a/experiments/images/confusion_matrix_vanilla_v2.png and b/experiments/images/confusion_matrix_vanilla_v2.png differ diff --git a/experiments/notebooks/confusion-plots.ipynb b/experiments/notebooks/confusion-plots.ipynb deleted file mode 100644 index c1d0670..0000000 --- a/experiments/notebooks/confusion-plots.ipynb +++ /dev/null @@ -1,107 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 89, - "id": "ea140555-bcc6-46ab-842c-9a77af2e7cfb", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Data from the tables\n", - "orkgsyn_data = np.array([\n", - " [4.85, 4.71, 4.69, 4.80],\n", - " [4.92, 4.89, 4.87, 4.88],\n", - " [4.81, 4.77, 4.75, 4.78],\n", - " [4.84, 4.75, 4.72, 4.81]\n", - "])\n", - "\n", - "bioasq_data = np.array([\n", - " [4.82, 3.39, 4.82, 4.82],\n", - " [4.85, 4.48, 4.80, 4.84],\n", - " [4.83, 4.72, 4.80, 4.78],\n", - " [4.82, 3.54, 4.65, 4.78]\n", - "])\n", - "\n", - "# Labels for the heatmaps\n", - "models = [\"Qwen2.5-72B\", \"LLaMA-3.1-72B\", \"LLaMA-3.1-8B\", \"Mistral-Large\"]\n", - "\n", - "# Create subplots\n", - "fig, axes = plt.subplots(2, 1, figsize=(4, 6))\n", - "\n", - "# ORKGSyn Confusion Matrix\n", - "sns.heatmap(orkgsyn_data, annot=True, fmt=\".2f\", cmap=\"Blues\", xticklabels=models, yticklabels=models, ax=axes[0], annot_kws={\"size\": 7}, cbar=False)\n", - "axes[0].set_title(\"ORKG-Synthesis\", fontsize=9)\n", - "# axes[0].set_xlabel(\"Synthesizer\", fontsize=8)\n", - "# axes[0].set_ylabel(\"Evaluator\", fontsize=8)\n", - "axes[0].tick_params(axis='both', which='major', labelsize=6)\n", - "axes[0].tick_params(axis='x', rotation=0)\n", - "\n", - "# BioASQ Confusion Matrix\n", - "sns.heatmap(bioasq_data, annot=True, fmt=\".2f\", cmap=\"Blues\", xticklabels=models, yticklabels=models, ax=axes[1], annot_kws={\"size\": 7}, cbar=False)\n", - "axes[1].set_title(\"BioASQ\", fontsize=9)\n", - "# axes[1].set_xlabel(\"Synthesizer\", fontsize=8)\n", - "# axes[1].set_ylabel(\"Evaluator\", fontsize=8)\n", - "axes[1].tick_params(axis='both', which='major', labelsize=6)\n", - "axes[1].tick_params(axis='x', rotation=0)\n", - "\n", - "# Adjust layout and show the plots\n", - "plt.tight_layout()\n", - "plt.savefig(\"images/confusion_matrix_vanilla_v2.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", - "plt.savefig(\"images/confusion_matrix_vanilla_v2.png\", format=\"png\", dpi=300, bbox_inches=\"tight\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c33d8b53-0bc3-4d45-9ee0-729c9071f61b", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "456bcc74-21db-467b-8901-57bdae1a784f", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/experiments/notebooks/plot-line-chart.ipynb b/experiments/notebooks/plot-line-chart.ipynb deleted file mode 100644 index db62db3..0000000 --- a/experiments/notebooks/plot-line-chart.ipynb +++ /dev/null @@ -1,209 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 6, - "id": "1cc0b872-8de2-45d6-86a9-28e2bc784d8d", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import json\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "from sciqaeval import config\n", - "import math\n", - "\n", - "def load_data(file_path):\n", - " with open(file_path, 'r') as f:\n", - " return json.load(f)\n", - "\n", - "def compute_averages(data, criteria):\n", - " averages = {eval_type: {criterion: [] for criterion in criteria} for eval_type in [\"original\", \"extreme\", \"subtle\"]}\n", - " for entry in data:\n", - " eval_type = entry[\"eval_type\"]\n", - " quality = entry[\"quality\"]\n", - " rating = entry[\"synthesis_evaluation_rating\"]\n", - " if quality in averages[eval_type]:\n", - " if not math.isnan(rating):\n", - " averages[eval_type][quality].append(float(rating))\n", - " for eval_type in averages:\n", - " for quality in averages[eval_type]:\n", - " if averages[eval_type][quality]:\n", - " averages[eval_type][quality] = sum(averages[eval_type][quality])/len(averages[eval_type][quality])\n", - " else:\n", - " averages[eval_type][quality] = 0\n", - " return averages" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "83aefc6d-2e78-4b34-9f05-5e4a5a9537a1", - "metadata": {}, - "outputs": [], - "source": [ - "criteria = config.criteria\n", - "\n", - "dataset1 = load_data(\"dataset/BioASQ/BioASQ_test_meta-llama-3.1-70b-instruct_refactored_dataset.json\")\n", - "dataset2 = load_data(\"dataset/ORKG-Synthesis/llm4syn_test_meta-llama-3.1-70b-instruct_refactored_dataset.json\")\n", - "averages1 = compute_averages(dataset1, criteria)\n", - "averages2 = compute_averages(dataset2, criteria)\n", - "averages = [[averages1, averages2, 'Vanilla LLaMA-3.1-70B', 'gainsboro']]\n", - "\n", - "dataset1 = load_data(\"dataset/BioASQ/BioASQ_test_mistral-large-instruct_refactored_dataset.json\")\n", - "dataset2 = load_data(\"dataset/ORKG-Synthesis/llm4syn_test_mistral-large-instruct_refactored_dataset.json\")\n", - "averages1 = compute_averages(dataset1, criteria)\n", - "averages2 = compute_averages(dataset2, criteria)\n", - "averages += [[averages1, averages2, 'Vanilla Mistral-Large', 'gainsboro']]\n", - "\n", - "dataset1 = load_data(\"dataset/BioASQ/BioASQ_test_qwen2.5-72b-instruct_refactored_dataset.json\")\n", - "dataset2 = load_data(\"dataset/ORKG-Synthesis/llm4syn_test_qwen2.5-72b-instruct_refactored_dataset.json\")\n", - "averages1 = compute_averages(dataset1, criteria)\n", - "averages2 = compute_averages(dataset2, criteria)\n", - "averages += [[averages1, averages2, 'Vanilla Qwen2.5-72B', 'gainsboro']]\n", - "\n", - "dataset1 = load_data(\"dataset/BioASQ/BioASQ-test-refactored-dataset.json\")\n", - "dataset2 = load_data(\"dataset/ORKG-Synthesis/llm4syn-test-refactored-dataset.json\")\n", - "averages1 = compute_averages(dataset1, criteria)\n", - "averages2 = compute_averages(dataset2, criteria)\n", - "averages += [[averages1, averages2, 'Vanilla LLaMA-3.1-8B', 'teal']]\n", - "\n", - "dataset1 = load_data(\"assets/sft-bioasq-org-test.json\")\n", - "dataset2 = load_data(\"assets/sft-orkg-synthesis-org-test.json\")\n", - "averages1 = compute_averages(dataset1, criteria)\n", - "averages2 = compute_averages(dataset2, criteria)\n", - "averages += [[averages1, averages2, 'SFT (benign)', 'orange']]\n", - "\n", - "dataset1 = load_data(\"assets/rlhf-bioasq-adv-test.json\")\n", - "dataset2 = load_data(\"assets/rlhf-orkg-synthesis-adv-test.json\")\n", - "averages1 = compute_averages(dataset1, criteria)\n", - "averages2 = compute_averages(dataset2, criteria)\n", - "averages += [[averages1, averages2, 'SFT (benign) + RL (adversarial)', 'tomato']]\n", - "\n", - "dataset1 = load_data(\"assets/rlhf-bioasq-adv-org-test.json\")\n", - "dataset2 = load_data(\"assets/rlhf-orkg-synthesis-adv-org-test.json\")\n", - "averages1 = compute_averages(dataset1, criteria)\n", - "averages2 = compute_averages(dataset2, criteria)\n", - "averages += [[averages1, averages2, 'SFT (benign) + RL (benign + adversarial)', 'yellowgreen']]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "4240a124-7f9c-47a3-a832-10252ba0e02b", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_results(averages, criteria, dataset_name1, dataset_name2, font_size=12):\n", - " criteria_abbreviations = {\n", - " \"Coherence\": \"Cohr\",\n", - " \"Cohesion\": \"Cohs\",\n", - " \"Completeness\": \"Comp\",\n", - " \"Conciseness\": \"Conc\",\n", - " \"Correctness\": \"Corr\",\n", - " \"Informativeness\": \"Info\",\n", - " \"Integration\": \"Integ\",\n", - " \"Readability\": \"Read\",\n", - " \"Relevancy\": \"Relv\"\n", - " }\n", - " fig, axes = plt.subplots(2, 3, figsize=(10, 5), sharey=True) \n", - " eval_types = [\"original\", \"extreme\", \"subtle\"]\n", - " dataset_names = [dataset_name1, dataset_name2]\n", - " legend_handles = [] \n", - " legend_labels = [] \n", - " for average in averages:\n", - " avg = [average[0], average[1]] \n", - " title = average[2]\n", - " color = average[3]\n", - " \n", - " markers = {'Vanilla LLaMA-3.1-70B':'*', 'Vanilla Mistral-Large':'+', 'Vanilla Qwen2.5-72B':'^'}\n", - "\n", - " marker= markers.get(title, 'o')\n", - " for i, dataset in enumerate(avg):\n", - " for j, eval_type in enumerate(eval_types):\n", - " ax = axes[i, j] \n", - " line, = ax.plot(criteria, \n", - " [dataset[eval_type][c] for c in criteria], \n", - " marker=marker, \n", - " linestyle='-', \n", - " linewidth=0.9,\n", - " color=color,\n", - " markersize=font_size-5)\n", - " ax.set_title(f\"{dataset_names[i]} - {eval_type.capitalize() if eval_type!='original' else 'Benign'}\", \n", - " fontsize=font_size)\n", - " ax.tick_params(axis='both', labelsize=font_size - 3)\n", - " ax.grid(True, linestyle=\"--\", alpha=0.15)\n", - " # ax.set_yticks([1, 2, 3, 4, 5])\n", - " ax.set_xticklabels([criteria_abbreviations[crit] for crit in criteria], rotation=0)\n", - " legend_handles.append(line)\n", - " legend_labels.append(title)\n", - " \n", - " fig.legend(legend_handles, legend_labels, loc=\"upper center\", ncol=7, fontsize=font_size-3, bbox_to_anchor=(0.5, 0.97))\n", - " plt.tight_layout(rect=[0, 0, 1, 0.95])\n", - " plt.savefig(\"images/results_plot.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", - " plt.savefig(\"images/results_plot.png\", format=\"png\", dpi=300, bbox_inches=\"tight\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "8ac306d9-1c34-4cd6-94ab-b26499b1e45e", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_803013/3035001349.py:41: UserWarning: FixedFormatter should only be used together with FixedLocator\n", - " ax.set_xticklabels([criteria_abbreviations[crit] for crit in criteria], rotation=0)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_results(averages, criteria, \"BioASQ\", \"ORKGSynthesis\", font_size=8)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a052a3da-e40b-49be-bcc7-980ef375eb92", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/experiments/plots.ipynb b/experiments/plots.ipynb new file mode 100644 index 0000000..472aa8d --- /dev/null +++ b/experiments/plots.ipynb @@ -0,0 +1,258 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 38, + "id": "1be657cc-56bd-4d67-a55e-dc79f0cdeced", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Data from the tables\n", + "orkgsyn_data = np.array([\n", + " [4.85, 4.71, 4.69, 4.80],\n", + " [4.92, 4.89, 4.87, 4.88],\n", + " [4.81, 4.77, 4.75, 4.78],\n", + " [4.84, 4.75, 4.72, 4.81]\n", + "])\n", + "\n", + "bioasq_data = np.array([\n", + " [4.82, 3.39, 4.82, 4.82],\n", + " [4.85, 4.48, 4.80, 4.84],\n", + " [4.83, 4.72, 4.80, 4.78],\n", + " [4.82, 3.54, 4.65, 4.78]\n", + "])\n", + "\n", + "# Labels for the heatmaps\n", + "models = [\"Qwen2.5-72B\", \"LLaMA-3.1-72B\", \"LLaMA-3.1-8B\", \"Mistral-Large\"]\n", + "# models = [\"Q\", \"L72B\", \"L8B\", \"M\"]\n", + "# Create subplots\n", + "fig, axes = plt.subplots(2, 1, figsize=(6, 8))\n", + "\n", + "# ORKGSyn Confusion Matrix\n", + "sns.heatmap(orkgsyn_data, annot=True, fmt=\".2f\", cmap=\"Blues\", xticklabels=models, yticklabels=models, ax=axes[0], annot_kws={\"size\": 12}, cbar=False)\n", + "axes[0].set_title(\"ORKG-Synthesis\", fontsize=16)\n", + "# axes[0].set_xlabel(\"Synthesizer\", fontsize=8)\n", + "# axes[0].set_ylabel(\"Evaluator\", fontsize=8)\n", + "axes[0].tick_params(axis='both', which='major', labelsize=10)\n", + "axes[0].tick_params(axis='x', rotation=0)\n", + "\n", + "# BioASQ Confusion Matrix\n", + "sns.heatmap(bioasq_data, annot=True, fmt=\".2f\", cmap=\"Blues\", xticklabels=models, yticklabels=models, ax=axes[1], annot_kws={\"size\": 12}, cbar=False)\n", + "axes[1].set_title(\"BioASQ\", fontsize=16)\n", + "# axes[1].set_xlabel(\"Synthesizer\", fontsize=8)\n", + "# axes[1].set_ylabel(\"Evaluator\", fontsize=8)\n", + "axes[1].tick_params(axis='both', which='major', labelsize=10)\n", + "axes[1].tick_params(axis='x', rotation=0)\n", + "\n", + "# Adjust layout and show the plots\n", + "plt.tight_layout()\n", + "plt.savefig(\"images/confusion_matrix_vanilla_v2.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", + "plt.savefig(\"images/confusion_matrix_vanilla_v2.png\", format=\"png\", dpi=300, bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1cc0b872-8de2-45d6-86a9-28e2bc784d8d", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sciqaeval import config\n", + "import math\n", + "\n", + "def load_data(file_path):\n", + " with open(file_path, 'r') as f:\n", + " return json.load(f)\n", + "\n", + "def compute_averages(data, criteria):\n", + " averages = {eval_type: {criterion: [] for criterion in criteria} for eval_type in [\"original\", \"extreme\", \"subtle\"]}\n", + " for entry in data:\n", + " eval_type = entry[\"eval_type\"]\n", + " quality = entry[\"quality\"]\n", + " rating = entry[\"synthesis_evaluation_rating\"]\n", + " if quality in averages[eval_type]:\n", + " if not math.isnan(rating):\n", + " averages[eval_type][quality].append(float(rating))\n", + " for eval_type in averages:\n", + " for quality in averages[eval_type]:\n", + " if averages[eval_type][quality]:\n", + " averages[eval_type][quality] = sum(averages[eval_type][quality])/len(averages[eval_type][quality])\n", + " else:\n", + " averages[eval_type][quality] = 0\n", + " return averages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83aefc6d-2e78-4b34-9f05-5e4a5a9537a1", + "metadata": {}, + "outputs": [], + "source": [ + "criteria = config.criteria\n", + "\n", + "dataset1 = load_data(\"dataset/BioASQ/BioASQ_test_meta-llama-3.1-70b-instruct_refactored_dataset.json\")\n", + "dataset2 = load_data(\"dataset/ORKG-Synthesis/llm4syn_test_meta-llama-3.1-70b-instruct_refactored_dataset.json\")\n", + "averages1 = compute_averages(dataset1, criteria)\n", + "averages2 = compute_averages(dataset2, criteria)\n", + "averages = [[averages1, averages2, 'Vanilla LLaMA-3.1-70B', 'gainsboro']]\n", + "\n", + "dataset1 = load_data(\"dataset/BioASQ/BioASQ_test_mistral-large-instruct_refactored_dataset.json\")\n", + "dataset2 = load_data(\"dataset/ORKG-Synthesis/llm4syn_test_mistral-large-instruct_refactored_dataset.json\")\n", + "averages1 = compute_averages(dataset1, criteria)\n", + "averages2 = compute_averages(dataset2, criteria)\n", + "averages += [[averages1, averages2, 'Vanilla Mistral-Large', 'gainsboro']]\n", + "\n", + "dataset1 = load_data(\"dataset/BioASQ/BioASQ_test_qwen2.5-72b-instruct_refactored_dataset.json\")\n", + "dataset2 = load_data(\"dataset/ORKG-Synthesis/llm4syn_test_qwen2.5-72b-instruct_refactored_dataset.json\")\n", + "averages1 = compute_averages(dataset1, criteria)\n", + "averages2 = compute_averages(dataset2, criteria)\n", + "averages += [[averages1, averages2, 'Vanilla Qwen2.5-72B', 'gainsboro']]\n", + "\n", + "dataset1 = load_data(\"dataset/BioASQ/BioASQ-test-refactored-dataset.json\")\n", + "dataset2 = load_data(\"dataset/ORKG-Synthesis/llm4syn-test-refactored-dataset.json\")\n", + "averages1 = compute_averages(dataset1, criteria)\n", + "averages2 = compute_averages(dataset2, criteria)\n", + "averages += [[averages1, averages2, 'Vanilla LLaMA-3.1-8B', 'teal']]\n", + "\n", + "dataset1 = load_data(\"assets/sft-bioasq-org-test.json\")\n", + "dataset2 = load_data(\"assets/sft-orkg-synthesis-org-test.json\")\n", + "averages1 = compute_averages(dataset1, criteria)\n", + "averages2 = compute_averages(dataset2, criteria)\n", + "averages += [[averages1, averages2, 'SFT (benign)', 'orange']]\n", + "\n", + "dataset1 = load_data(\"assets/rlhf-bioasq-adv-test.json\")\n", + "dataset2 = load_data(\"assets/rlhf-orkg-synthesis-adv-test.json\")\n", + "averages1 = compute_averages(dataset1, criteria)\n", + "averages2 = compute_averages(dataset2, criteria)\n", + "averages += [[averages1, averages2, 'SFT (benign) + RL (adversarial)', 'tomato']]\n", + "\n", + "dataset1 = load_data(\"assets/rlhf-bioasq-adv-org-test.json\")\n", + "dataset2 = load_data(\"assets/rlhf-orkg-synthesis-adv-org-test.json\")\n", + "averages1 = compute_averages(dataset1, criteria)\n", + "averages2 = compute_averages(dataset2, criteria)\n", + "averages += [[averages1, averages2, 'SFT (benign) + RL (benign + adversarial)', 'yellowgreen']]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4240a124-7f9c-47a3-a832-10252ba0e02b", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_results(averages, criteria, dataset_name1, dataset_name2, font_size=12):\n", + " criteria_abbreviations = {\n", + " \"Coherence\": \"Cohr\",\n", + " \"Cohesion\": \"Cohs\",\n", + " \"Completeness\": \"Comp\",\n", + " \"Conciseness\": \"Conc\",\n", + " \"Correctness\": \"Corr\",\n", + " \"Informativeness\": \"Info\",\n", + " \"Integration\": \"Integ\",\n", + " \"Readability\": \"Read\",\n", + " \"Relevancy\": \"Relv\"\n", + " }\n", + " fig, axes = plt.subplots(2, 3, figsize=(10, 5), sharey=True) \n", + " eval_types = [\"original\", \"extreme\", \"subtle\"]\n", + " dataset_names = [dataset_name1, dataset_name2]\n", + " legend_handles = [] \n", + " legend_labels = [] \n", + " for average in averages:\n", + " avg = [average[0], average[1]] \n", + " title = average[2]\n", + " color = average[3]\n", + " \n", + " markers = {'Vanilla LLaMA-3.1-70B':'*', 'Vanilla Mistral-Large':'+', 'Vanilla Qwen2.5-72B':'^'}\n", + "\n", + " marker= markers.get(title, 'o')\n", + " for i, dataset in enumerate(avg):\n", + " for j, eval_type in enumerate(eval_types):\n", + " ax = axes[i, j] \n", + " line, = ax.plot(criteria, \n", + " [dataset[eval_type][c] for c in criteria], \n", + " marker=marker, \n", + " linestyle='-', \n", + " linewidth=0.9,\n", + " color=color,\n", + " markersize=font_size-5)\n", + " ax.set_title(f\"{dataset_names[i]} - {eval_type.capitalize() if eval_type!='original' else 'Benign'}\", \n", + " fontsize=font_size)\n", + " ax.tick_params(axis='both', labelsize=font_size - 3)\n", + " ax.grid(True, linestyle=\"--\", alpha=0.15)\n", + " # ax.set_yticks([1, 2, 3, 4, 5])\n", + " ax.set_xticklabels([criteria_abbreviations[crit] for crit in criteria], rotation=0)\n", + " legend_handles.append(line)\n", + " legend_labels.append(title)\n", + " \n", + " fig.legend(legend_handles, legend_labels, loc=\"upper center\", ncol=7, fontsize=font_size-3, bbox_to_anchor=(0.5, 0.97))\n", + " plt.tight_layout(rect=[0, 0, 1, 0.95])\n", + " plt.savefig(\"images/results_plot.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", + " plt.savefig(\"images/results_plot.png\", format=\"png\", dpi=300, bbox_inches=\"tight\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ac306d9-1c34-4cd6-94ab-b26499b1e45e", + "metadata": {}, + "outputs": [], + "source": [ + "plot_results(averages, criteria, \"BioASQ\", \"ORKGSynthesis\", font_size=8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a052a3da-e40b-49be-bcc7-980ef375eb92", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..f92d965 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,35 @@ +[tool.poetry] +name = "YESciEval" + +version = "0.2.0" + +description = "YESciEval: Robust LLM-as-a-Judge for Scientific Question Answering." +authors = ["Hamed Babaei Giglou "] +license = "MIT License" +readme = "README.md" +homepage = "https://yescieval.readthedocs.io/" +repository = "https://github.com/sciknoworg/YESciEval/" +include = ["images/logo.png"] + +[tool.poetry.dependencies] +python = ">=3.10,<4.0.0" +pre-commit="*" +transformers="*" +torch="*" +peft="*" +openai="*" +pandas="*" +numpy="*" +pydantic="*" + +[tool.poetry.dev-dependencies] +ruff = "*" +pre-commit = "*" +setuptools = "*" +wheel = "*" +twine = "*" +pytest = "*" + +[build-system] +requires = ["poetry-core>=1.0.0"] +build-backend = "poetry.core.masonry.api" diff --git a/readthedocs.yml b/readthedocs.yml new file mode 100644 index 0000000..ea88004 --- /dev/null +++ b/readthedocs.yml @@ -0,0 +1,23 @@ +version: "2" + + +build: + + os: "ubuntu-22.04" + tools: + python: "3.10" + +python: + install: + - method: pip + path: . + - requirements: docs/requirements.txt + - requirements: requirements.txt + +sphinx: + builder: html + configuration: docs/source/conf.py + +submodules: + include: all + recursive: true diff --git a/requirements.txt b/requirements.txt index 778f31c..0478557 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,12 +1,9 @@ pre-commit -scikit-learn -python-dotenv transformers torch peft -tqdm openai pandas +numpy pydantic -trl -datasets \ No newline at end of file +pytest \ No newline at end of file diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..e74ca6c --- /dev/null +++ b/setup.py @@ -0,0 +1,41 @@ +from setuptools import setup, find_packages + +with open("README.md", encoding="utf-8") as f: + long_description = f.read() + +setup( + name="YESciEval", + version="0.2.0", + author="Hamed Babaei Giglou", + author_email="hamedbabaeigiglou@gmail.com", + description="YESciEval: Robust LLM-as-a-Judge for Scientific Question Answering.", + long_description=long_description, + long_description_content_type="text/markdown", + url="https://github.com/sciknoworg/YESciEval", + packages=find_packages(), + install_requires=[ + "pre-commit", + "transformers," + "torch", + "peft", + "openai", + "pandas", + "numpy", + "pydantic", + "pytest" + ], + classifiers=[ + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Developers", + "Topic :: Software Development :: Libraries :: Python Modules", + "Programming Language :: Python :: 3", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + ], + python_requires=">=3.10,<4.0.0", + project_urls={ + "Documentation": "https://yescieval.readthedocs.io/", + "Source": "https://github.com/sciknoworg/YESciEval", + "Tracker": "https://github.com/sciknoworg/YESciEval/issues", + }, +) diff --git a/test.py b/test.py deleted file mode 100644 index 3f0f509..0000000 --- a/test.py +++ /dev/null @@ -1,11 +0,0 @@ -from yescieval.rubric import Informativeness - - -papers = { - "A Study on AI": "This paper discusses recent advances in AI.", - "Machine Learning Basics": "An overview of supervised learning methods." -} -question = "this is a dume question" -synthesis="synthesis answer" -rubric = Informativeness(papers=papers, question=question, synthesis=synthesis) -print(rubric.instruct()) diff --git a/test/test_rubrics.py b/test/test_rubrics.py new file mode 100644 index 0000000..c903fba --- /dev/null +++ b/test/test_rubrics.py @@ -0,0 +1,21 @@ +import unittest +from yescieval import Informativeness + +class TestRubric(unittest.TestCase): + + def setUp(self): + self.papers = { + "A Study on AI": "This paper discusses recent advances in AI.", + "Machine Learning Basics": "An overview of supervised learning methods." + } + self.question = "this is a dume question" + self.answer = "synthesis answer" + + def test_informativeness(self): + rubric = Informativeness(papers=self.papers, question=self.question, answer=self.answer) + output = rubric.instruct() + self.assertIsInstance(output, list) + self.assertTrue(len(output) > 0) + +if __name__ == '__main__': + unittest.main() diff --git a/yescieval/__init__.py b/yescieval/__init__.py index 2e60550..9e161b4 100644 --- a/yescieval/__init__.py +++ b/yescieval/__init__.py @@ -1,23 +1,9 @@ -__version__ = "0.1.0" +__version__ = "0.2.0" from .base import Rubric, Parser from .rubric import (Informativeness, Correctness, Completeness, Coherence, Relevancy, Integration, Cohesion, Readability, Conciseness) - - -__all__ = [ - "Rubric", - "Informativeness", - "Correctness", - "Completeness", - "Coherence", - "Relevancy", - "Integration", - "Cohesion", - "Readability", - "Conciseness", - "Parser" -] - +from .judge import AutoJudge, AskAutoJudge, BioASQAutoJudge, CustomAutoJudge +from .parser import GPTParser diff --git a/yescieval/base/__init__.py b/yescieval/base/__init__.py index 7313318..7c07516 100644 --- a/yescieval/base/__init__.py +++ b/yescieval/base/__init__.py @@ -1,9 +1,10 @@ from .rubric import Rubric -from .parser import Parser +from .parser import Parser, RubricLikertScale from .judge import Judge __all__ = [ "Rubric", "Parser", + "RubricLikertScale", "Judge" ] \ No newline at end of file diff --git a/yescieval/base/judge.py b/yescieval/base/judge.py index ed6a6aa..5ef75ed 100644 --- a/yescieval/base/judge.py +++ b/yescieval/base/judge.py @@ -1,11 +1,16 @@ from abc import ABC -from typing import Dict +from typing import Dict, Any from . import Parser, Rubric class Judge(ABC): - def from_pretrained(self, model_id:str, device: str="auto"): + + def from_pretrained(self, model_id:str, device: str="auto", token:str =""): + self.model, self.tokenizer = self._from_pretrained(model_id=model_id, device=device, token=token) + + def judge(self, rubric: Rubric, max_new_tokens: int=150) -> Dict[str, Dict[str, str]]: pass - def judge(self, rubric: Rubric, parser: Parser = Parser) -> Dict[str, Dict[str, str]]: + def _from_pretrained(self, model_id: str, device: str = "auto", token: str = "") -> [Any, Any]: pass + diff --git a/yescieval/base/rubric.py b/yescieval/base/rubric.py index ec20d16..64c37e7 100644 --- a/yescieval/base/rubric.py +++ b/yescieval/base/rubric.py @@ -12,10 +12,10 @@ class Rubric(BaseModel, ABC): system_prompt_template: str papers: Dict[str, str] question: str - synthesis: str + answer: str user_prompt_template: str = ("Evaluate and rate the quality of the following scientific synthesis " "according to the characteristics given in the system prompt.\n" - "\n{synthesis}\n" + "\n{answer}\n" "\n{question}\n" "\n\n{content}\n\n###") @@ -26,7 +26,7 @@ def render_papers(self) -> str: return paper_content def verbalize(self): - return self.user_prompt_template.format(synthesis=self.synthesis, + return self.user_prompt_template.format(answer=self.answer, question=self.question, content=self.render_papers()) diff --git a/yescieval/judge/__init__.py b/yescieval/judge/__init__.py index e69de29..a3fe787 100644 --- a/yescieval/judge/__init__.py +++ b/yescieval/judge/__init__.py @@ -0,0 +1,8 @@ +from .judges import AutoJudge, AskAutoJudge, BioASQAutoJudge, CustomAutoJudge + +__all__ = [ + "AutoJudge", + "AskAutoJudge", + "BioASQAutoJudge", + "CustomAutoJudge" +] \ No newline at end of file diff --git a/yescieval/judge/judges.py b/yescieval/judge/judges.py index 4a061cf..2c436f0 100644 --- a/yescieval/judge/judges.py +++ b/yescieval/judge/judges.py @@ -1,10 +1,68 @@ -from ..base import Judge, Parser, Rubric +from ..base import Judge, Rubric from typing import Dict +from transformers import AutoTokenizer, AutoModelForCausalLM +from peft import PeftModel, PeftConfig +import torch + + + class AutoJudge(Judge): - def from_pretrained(self, model_id:str, device:str="auto"): - pass + def _from_pretrained(self, model_id:str, device:str="auto", token:str =""): + config = PeftConfig.from_pretrained(model_id) + base_model_name = config.base_model_name_or_path + tokenizer = AutoTokenizer.from_pretrained(base_model_name, + padding_side="left", + token=token) + tokenizer.pad_token = tokenizer.eos_token + base_model = AutoModelForCausalLM.from_pretrained( + base_model_name, + torch_dtype=torch.float32, + device_map=device, + token=token + ) + model = PeftModel.from_pretrained(base_model, model_id) + return model, tokenizer + + def evaluate(self, rubric: Rubric, max_new_tokens: int=150) -> Dict[str, Dict[str, str]]: + inputs = self.tokenizer.apply_chat_template(rubric.instruct(), + add_generation_prompt=True, + return_dict=True, + return_tensors="pt") + inputs.to(self.model.device) + outputs = self.model.generate(**inputs, + max_new_tokens=max_new_tokens, + pad_token_id=self.tokenizer.eos_token_id) + evaluation = self.tokenizer.decode(outputs[0][len(inputs["input_ids"][0]):], skip_special_tokens=True) + return evaluation + + +class AskAutoJudge(AutoJudge): + def from_pretrained(self, model_id:str="SciKnowOrg/YESciEval-ASK-Llama-3.1-8B", + device:str="auto", + token:str =""): + return super()._from_pretrained(model_id=model_id, device=device, token=token) + +class BioASQAutoJudge(AutoJudge): + def from_pretrained(self, model_id: str = "SciKnowOrg/YESciEval-BioASQ-Llama-3.1-8B", + device: str = "auto", + token: str = ""): + return super()._from_pretrained(model_id=model_id, device=device, token=token) + + + +class CustomAutoJudge(AutoJudge): - def judge(self, rubric: Rubric, parser: Parser=Parser) -> Dict[str, Dict[str, str]]: - pass + def _from_pretrained(self, model_id:str, device:str="auto", token:str =""): + tokenizer = AutoTokenizer.from_pretrained(model_id, + padding_side="left", + token=token) + tokenizer.pad_token = tokenizer.eos_token + model = AutoModelForCausalLM.from_pretrained( + model_id, + torch_dtype=torch.float32, + device_map=device, + token=token + ) + return model, tokenizer diff --git a/yescieval/parser/__init__.py b/yescieval/parser/__init__.py index e69de29..40ec79e 100644 --- a/yescieval/parser/__init__.py +++ b/yescieval/parser/__init__.py @@ -0,0 +1,3 @@ +from .parsers import GPTParser + +__all__ = ["GPTParser"] \ No newline at end of file diff --git a/yescieval/parser/parsers.py b/yescieval/parser/parsers.py new file mode 100644 index 0000000..7873375 --- /dev/null +++ b/yescieval/parser/parsers.py @@ -0,0 +1,61 @@ + +from ..base import Parser, RubricLikertScale +import time +from openai import OpenAI + +class GPTParser(Parser): + """ + Abstract base class for parsing model outputs into structured characteristic evaluations. + + Each characteristic maps to a CharacteristicScore with a rating and rationale. + """ + def __init__(self, openai_key:str, parser_model:str="gpt-4o-mini"): + self.client = OpenAI(api_key=openai_key) + self.parser_model = parser_model + + def parse(self, raw_output: str) -> RubricLikertScale: + """ + Parse the raw model output into structured characteristic evaluations. + + Args: + raw_output (str): The text generated by the model. + + Returns: + Dict[str, CharacteristicScore]: Mapping from characteristic name to its score and rationale. + """ + functions = [ + { + "name": "evaluate_characteristic", + "description": "Extracting the exact `rating` and `rationale` from the given text.", + "parameters": { + "type": "object", + "properties": { + "rating": { + "type": "number", + "description": "A numerical rating assigned to the characteristic in the text.", + "minimum": 1, + "maximum": 5 + }, + "rationale": { + "type": "string", + "description": "The explanation for the assigned rating." + } + }, + "required": ["rating", "rationale"] + } + } + ] + while True: + try: + completion = self.client.chat.completions.create( + model=self.parser_model, + messages=[{"role": "user", "content": raw_output}], + functions=functions + ) + parsed_output = eval(completion.choices[0].message.function_call.arguments) + break + except Exception as e: + print(f"Error {e}") + time.sleep(3) + + return RubricLikertScale(rating=parsed_output['rating'], rationale=parsed_output['rationale'])