Duplicate from Reja1/jee-neet-benchmark

Co-authored-by: Md Rejaullah <Reja1@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,3 @@
+images/** filter=lfs diff=lfs merge=lfs -text
+images/**/*.png filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,89 @@
+# Python virtual environment
+hf-env/
+venv/
+env/
+*.venv
+
+# Python cache files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# 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/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IDE / Editor specific files
+.idea/
+.vscode/
+*.sublime-project
+*.sublime-workspace
+
+# OS generated files
+.DS_Store
+Thumbs.db
+
+# Results (optional - uncomment if you don't want to track results in Git)
+# results/
+
+# Configuration files containing secrets (uncomment if you use these names)
+# configs/openrouter_config.yaml
+.env*
+.env
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+# Other
+*.swp
+*~

CLAUDE.md

@@ -0,0 +1,77 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+A benchmark for evaluating vision-capable LLMs on Indian competitive exam questions (JEE Main, JEE Advanced, NEET). Questions are images sent to models via the OpenRouter API; responses are parsed from `<answer>...</answer>` tags and scored using exam-specific marking schemes.
+
+## Running the Benchmark
+
+```bash
+# Setup
+uv sync
+echo "OPENROUTER_API_KEY=your_key" > .env
+
+# Must run from project root (paths are resolved relative to cwd)
+uv run python src/benchmark_runner.py --model "google/gemini-2.5-pro-preview-03-25" --exam_name JEE_ADVANCED --exam_year 2025
+
+# Filter by question IDs
+uv run python src/benchmark_runner.py --model "openai/o3" --question_ids "N24T3001,N24T3002"
+```
+
+CLI args: `--model` (required), `--exam_name` (all/NEET/JEE_ADVANCED/JEE_MAIN), `--exam_year` (all/2024/2025), `--question_ids`, `--output_dir`, `--config`, `--resume`.
+
+## Testing
+
+```bash
+# Run the full pytest suite (68 tests)
+uv run pytest tests/ -v
+
+# Run individual module self-tests
+uv run python src/utils.py        # answer parsing logic
+uv run python src/evaluation.py   # scoring logic
+uv run python src/llm_interface.py  # API calls (requires .env and network)
+```
+
+## Architecture
+
+```
+benchmark_runner.py  ─── orchestrator / entry point
+  ├── loads config from configs/benchmark_config.yaml
+  ├── loads dataset directly from metadata.jsonl (JSONL → HuggingFace Dataset)
+  │     ├── metadata.jsonl (question metadata, 578 questions)
+  │     └── images/ (question PNGs, stored in Git LFS)
+  ├── calls llm_interface.py for each question
+  │     ├── prompts.py (prompt templates)
+  │     └── utils.py (parse_llm_answer extracts from <answer> tags)
+  ├── scores via evaluation.py (exam-specific marking schemes)
+  └── writes results incrementally to results/{model}_{exam}_{year}_{timestamp}/
+        ├── predictions.jsonl  (raw API responses)
+        ├── summary.jsonl      (scored per-question results)
+        └── summary.md         (human-readable report)
+```
+
+### Key data flow
+
+1. Dataset loaded directly from `metadata.jsonl` into a HuggingFace `Dataset` object, filtered by exam/year
+2. Each question image is base64-encoded and sent to OpenRouter with a structured prompt
+3. If the response can't be parsed, a re-prompt is sent (text-only, with the bad response)
+4. If the API call fails, the question is queued for retry (up to 3 attempts, exponential backoff via `tenacity`)
+5. Answers are parsed from `<answer>...</answer>` tags by `utils.parse_llm_answer()`
+6. `evaluation.py` scores using JEE/NEET marking schemes (partial credit for MCQ_MULTIPLE_CORRECT in JEE Advanced)
+
+## Answer Format Conventions
+
+- `MCQ_SINGLE_CORRECT`: `<answer>A</answer>` → `["A"]`
+- `MCQ_MULTIPLE_CORRECT`: `<answer>A,C</answer>` → `["A", "C"]` (sorted, deduplicated)
+- `INTEGER`: `<answer>42</answer>` → `["42"]`
+- `SKIP`: `<answer>SKIP</answer>` → no penalty
+
+## Important Notes
+
+- **Git LFS**: Images and `metadata.jsonl` are in LFS. Run `git lfs pull` after cloning.
+- **Working directory**: Scripts must be run from project root — config, data, and image paths are resolved relative to cwd.
+- **Python 3.10+**: Uses union type syntax (`list[str] | str | None`).
+- **Models**: Configured in `configs/benchmark_config.yaml` under `openrouter_models`. All must support vision input.
+- **Result directory naming**: `results/{provider}_{model}_{exam}_{year}_{YYYYMMDD_HHMMSS}/` (slashes in model IDs replaced with underscores).

README.md

@@ -0,0 +1,348 @@
+---
+license: mit
+language:
+  - en
+task_categories:
+  - visual-question-answering
+  - image-text-to-text
+  - question-answering
+pretty_name: Indian Competitive Exams (JEE/NEET) LLM Benchmark
+size_categories:
+  - n<1K
+tags:
+  - education
+  - science
+  - india
+  - competitive-exams
+  - llm-benchmark
+configs:
+  - config_name: default
+    data_files:
+      - split: test
+        path: "images/**"
+    drop_labels: true
+dataset_info:
+  features:
+    - name: image
+      dtype: image
+    - name: question_id
+      dtype: string
+    - name: exam_name
+      dtype: string
+    - name: exam_year
+      dtype: int32
+    - name: subject
+      dtype: string
+    - name: question_type
+      dtype: string
+    - name: correct_answer
+      dtype: string
+    - name: paper_id
+      dtype: int64
+  splits:
+    - name: test
+      num_examples: 578
+---
+# JEE/NEET LLM Benchmark Dataset
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Dataset Description
+
+This repository contains a benchmark dataset designed for evaluating the capabilities of Large Language Models (LLMs) on questions from major Indian competitive examinations:
+*   **JEE (Main & Advanced):** Joint Entrance Examination for engineering.
+*   **NEET:** National Eligibility cum Entrance Test for medical fields.
+
+The questions are presented in image format (`.png`) as they appear in the original papers. The dataset includes metadata linking each image to its corresponding exam details (name, year, subject, question type), and correct answer(s). The benchmark framework supports various question types including Single Correct MCQs, Multiple Correct MCQs (with partial marking for JEE Advanced), and Integer type questions.
+
+**Current Data:**
+*   **NEET 2024** (Code T3): 200 questions across Physics, Chemistry, Botany, and Zoology
+*   **NEET 2025** (Code 45): 180 questions across Physics, Chemistry, Botany, and Zoology  
+*   **JEE Advanced 2024** (Paper 1 & 2): 102 questions across Physics, Chemistry, and Mathematics
+*   **JEE Advanced 2025** (Paper 1 & 2): 96 questions across Physics, Chemistry, and Mathematics
+*   **Total:** 578 questions with comprehensive metadata
+
+## Key Features
+
+*   **🖼️ Multimodal Reasoning:** Uses images of questions directly, testing the multimodal reasoning capability of models
+*   **📊 Exam-Specific Scoring:** Implements authentic scoring rules for different exams and question types, including partial marking for JEE Advanced
+*   **🔄 Robust API Handling:** Built-in retry mechanism and re-prompting for failed API calls or parsing errors
+*   **🎯 Flexible Filtering:** Filter by exam name, year, or specific question IDs for targeted evaluation
+*   **📈 Comprehensive Results:** Generates detailed JSON and human-readable Markdown summaries with section-wise breakdowns
+*   **🔧 Easy Configuration:** Simple YAML-based configuration for models and parameters
+
+## How to Use
+
+### Using `datasets` Library
+
+The dataset is hosted on the Hugging Face Hub and can be loaded directly:
+
+```python
+from datasets import load_dataset
+import json
+
+# Load the evaluation split
+dataset = load_dataset("Reja1/jee-neet-benchmark", split='test')
+
+# Example: Access the first question
+example = dataset[0]
+image = example["image"]
+question_id = example["question_id"]
+subject = example["subject"]
+correct_answers = json.loads(example["correct_answer"])  # Parse JSON string
+
+print(f"Question ID: {question_id}")
+print(f"Subject: {subject}")
+print(f"Correct Answer(s): {correct_answers}")
+# Display the image (requires Pillow)
+# image.show()
+```
+
+### Manual Usage (Benchmark Scripts)
+
+This repository contains scripts to run the benchmark evaluation directly:
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://huggingface.co/datasets/Reja1/jee-neet-benchmark
+    cd jee-neet-benchmark
+    # Ensure Git LFS is installed and pull large files
+    git lfs pull
+    ```
+
+2.  **Install dependencies:**
+    ```bash
+    uv sync
+    ```
+
+3.  **Configure API Key:**
+    *   Create a file named `.env` in the root directory of the project.
+    *   Add your OpenRouter API key to this file:
+        ```dotenv
+        OPENROUTER_API_KEY=your_actual_openrouter_api_key_here
+        ```
+    *   **Important:** The `.gitignore` file is already configured to prevent committing the `.env` file. Never commit your API keys directly.
+
+4.  **Configure Models:**
+    *   Edit the `configs/benchmark_config.yaml` file.
+    *   Modify the `openrouter_models` list to include the specific model identifiers you want to evaluate:
+        ```yaml
+        openrouter_models:
+          - "google/gemini-2.5-pro-preview-03-25"
+          - "anthropic/claude-sonnet-4"
+          - "openai/o3"
+        ```
+    *   Ensure these models support vision input on OpenRouter.
+    *   You can also adjust other parameters like `max_tokens` and `request_timeout` if needed.
+
+5.  **Run the benchmark:**
+
+    **Basic usage (run all available models on all questions):**
+    ```bash
+    uv run python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "google/gemini-2.5-pro-preview-03-25"
+    ```
+
+    **Filter by exam and year:**
+    ```bash
+    # Run only NEET 2024 questions
+    uv run python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "openai/o3" --exam_name NEET --exam_year 2024
+
+    # Run only JEE Advanced 2025 questions
+    uv run python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "anthropic/claude-sonnet-4" --exam_name JEE_ADVANCED --exam_year 2025
+    ```
+
+    **Run specific questions:**
+    ```bash
+    # Run specific question IDs
+    uv run python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "google/gemini-2.5-pro-preview-03-25" --question_ids "N24T3001,N24T3002,JA24P1M01"
+    ```
+
+    **Resume an interrupted run:**
+    ```bash
+    # Resume from an existing results directory (skips already-completed questions)
+    uv run python src/benchmark_runner.py --model "google/gemini-2.5-pro-preview-03-25" --resume results/google_gemini-2.5-pro-preview-03-25_NEET_2024_20250524_141230
+    ```
+
+    **Custom output directory:**
+    ```bash
+    uv run python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "openai/gpt-4o" --output_dir my_custom_results
+    ```
+
+    **Available options:**
+    - `--exam_name`: Choose from `NEET`, `JEE_MAIN`, `JEE_ADVANCED`, or `all` (default)
+    - `--exam_year`: Choose from available years (`2024`, `2025`, etc.) or `all` (default)
+    - `--question_ids`: Comma-separated list of specific question IDs to evaluate (e.g., "N24T3001,JA24P1M01")
+    - `--resume`: Path to an existing results directory to resume an interrupted run
+
+6.  **Check Results:**
+    *   Results for each model run will be saved in timestamped subdirectories within the `results/` folder.
+    *   Each run's folder (e.g., `results/google_gemini-2.5-pro-preview-03-25_NEET_2024_20250524_141230/`) contains:
+        *   **`predictions.jsonl`**: Raw API responses for each question including:
+            - Raw LLM responses
+            - API call success/failure information
+            - Parse success status and errors
+        *   **`summary.jsonl`**: Per-question scored results including:
+            - Predicted answers and ground truth
+            - Evaluation status and marks awarded
+        *   **`summary.md`**: Human-readable Markdown summary with:
+            - Overall exam scores
+            - Question type breakdown
+            - Section-wise breakdown (by subject)
+            - Detailed statistics on correct/incorrect/skipped questions
+
+## Scoring System
+
+The benchmark implements authentic scoring systems for each exam type:
+
+### NEET Scoring
+- **Single Correct MCQ**: +4 for correct, -1 for incorrect, 0 for skipped/API failure
+
+### JEE Main Scoring
+- **Single Correct MCQ**: +4 for correct, -1 for incorrect, 0 for skipped/API failure
+- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped/API failure
+
+### JEE Advanced Scoring
+- **Single Correct MCQ**: +3 for correct, -1 for incorrect, 0 for skipped/API failure
+- **Multiple Correct MCQ**: Partial marking system:
+  - +4 for all correct options selected
+  - +3 for 3 out of 4 correct options (when 4 are correct)
+  - +2 for 2 out of 3+ correct options
+  - +1 for 1 out of 2+ correct options
+  - -2 for any incorrect option selected
+  - 0 for skipped/API failure
+- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped/API failure
+
+> **Note:** API failures and parse failures are scored as 0 (no penalty) since they do not represent a deliberate wrong choice.
+
+## Advanced Features
+
+### Retry Mechanism
+- Automatic retry for failed API calls (up to 3 attempts with exponential backoff)
+- Retries on HTTP 429 (rate limit), 500, 502, 503, 504 status codes
+- Separate retry pass for questions that failed initially
+- Comprehensive error tracking and reporting
+
+### Resume Capability
+- Resume interrupted benchmark runs with `--resume <results_dir>`
+- Reads existing `summary.jsonl` to identify completed questions and skips them
+- Appends new results to the same output files
+
+### Re-prompting System
+- If initial response parsing fails, the system automatically re-prompts the model
+- Uses the previous response to ask for properly formatted answers
+- Shows only relevant format examples based on question type (MCQ single, MCQ multiple, or integer)
+
+### Comprehensive Evaluation
+- Tracks multiple metrics: correct answers, partial credit, skipped questions, API failures
+- Section-wise breakdown by subject
+- Color-coded progress indicators in terminal output
+
+## Dataset Structure
+
+*   **`metadata.jsonl`**: Contains metadata for each question image with fields:
+    - `file_name`: Path to the question image (relative to repo root)
+    - `question_id`: Unique identifier (e.g., "N24T3001")
+    - `exam_name`: Exam type ("NEET", "JEE_MAIN", "JEE_ADVANCED")
+    - `exam_year`: Year of the exam (integer)
+    - `subject`: Subject name (e.g., "Physics", "Chemistry", "Mathematics")
+    - `question_type`: Question format ("MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER")
+    - `correct_answer`: JSON-serialized string of correct answers (e.g., `'["A"]'`, `'["B", "C"]'`, `'["42"]'`)
+
+*   **`images/`**: Contains subdirectories for each exam set:
+    - `images/NEET_2024_T3/`: NEET 2024 question images
+    - `images/NEET_2025_45/`: NEET 2025 question images
+    - `images/JEE_ADVANCED_2024/`: JEE Advanced 2024 question images
+    - `images/JEE_ADVANCED_2025/`: JEE Advanced 2025 question images
+
+
+*   **`src/`**: Python source code for the benchmark system:
+    - `benchmark_runner.py`: Main benchmark execution script
+    - `llm_interface.py`: OpenRouter API interface with retry logic
+    - `evaluation.py`: Scoring and evaluation functions
+    - `prompts.py`: LLM prompts for different question types
+    - `utils.py`: Utility functions for parsing and configuration
+
+*   **`configs/`**: Configuration files:
+    - `benchmark_config.yaml`: Model selection and API parameters
+
+*   **`results/`**: Directory where benchmark results are stored (timestamped subdirectories)
+
+## Data Fields
+
+The dataset contains the following fields (accessible via `datasets`):
+
+*   `image`: The question image (`datasets.Image`)
+*   `question_id`: Unique identifier for the question (string)
+*   `exam_name`: Name of the exam (e.g., "NEET", "JEE_ADVANCED") (string)
+*   `exam_year`: Year of the exam (int)
+*   `subject`: Subject (e.g., "Physics", "Chemistry", "Mathematics") (string)
+*   `question_type`: Type of question (e.g., "MCQ_SINGLE_CORRECT", "INTEGER") (string)
+*   `correct_answer`: JSON-serialized string containing the correct answer(s). Use `json.loads()` to parse.
+    - For MCQs, these are option identifiers (e.g., `'["1"]'`, `'["A"]'`, `'["B", "C"]'`). The LLM should output the identifier as it appears in the question.
+    - For INTEGER type, this is the numerical answer as a string (e.g., `'["42"]'`, `'["12.75"]'`). The LLM should output the number.
+    - For some `MCQ_SINGLE_CORRECT` questions, multiple answers in the list are considered correct if the LLM prediction matches any one of them.
+
+## LLM Answer Format
+
+The LLM is expected to return its answer enclosed in `<answer>` tags. For example:
+- MCQ Single Correct (Option A): `<answer>A</answer>`
+- MCQ Single Correct (Option 2): `<answer>2</answer>`
+- MCQ Multiple Correct (Options B and D): `<answer>B,D</answer>`
+- Integer Answer: `<answer>42</answer>`
+- Decimal Answer: `<answer>12.75</answer>`
+- Skipped Question: `<answer>SKIP</answer>
+
+The system parses these formats. Prompts are designed to guide the LLM accordingly.
+
+## Troubleshooting
+
+### Common Issues
+
+**API Key Issues:**
+- Ensure your `.env` file is in the root directory
+- Verify your OpenRouter API key is valid and has sufficient credits
+- Check that the key has access to vision-capable models
+
+**Model Not Found:**
+- Verify the model identifier exists on OpenRouter
+- Ensure the model supports vision input
+- Check your OpenRouter account has access to the specific model
+
+**Memory Issues:**
+- Reduce `max_tokens` in the config file
+- Process smaller subsets using `--question_ids` filter
+- Use models with smaller context windows
+
+**Parsing Failures:**
+- The system automatically attempts re-prompting for parsing failures
+- Check the raw responses in `predictions.jsonl` to debug prompt issues
+- Consider adjusting prompts in `src/prompts.py` for specific models
+
+## Current Limitations
+
+*   **Dataset Size:** While comprehensive, the dataset could benefit from more JEE Main questions and additional years
+*   **Language Support:** Currently only supports English questions
+*   **Model Dependencies:** Requires models with vision capabilities available through OpenRouter
+
+## Citation
+
+If you use this dataset or benchmark code, please cite:
+
+```bibtex
+@misc{rejaullah_2025_jeeneetbenchmark,
+  title={JEE/NEET LLM Benchmark},
+  author={Md Rejaullah},
+  year={2025},
+  howpublished={\url{https://huggingface.co/datasets/Reja1/jee-neet-benchmark}},
+}
+```
+
+## Contact
+
+For questions, suggestions, or collaboration, feel free to reach out:
+
+*   **X (Twitter):** [https://x.com/RejaullahmdMd](https://x.com/RejaullahmdMd)
+
+## License
+
+This dataset and associated code are licensed under the [MIT License](https://opensource.org/licenses/MIT).

configs/benchmark_config.yaml

@@ -0,0 +1,29 @@
+# List of OpenRouter model identifiers to evaluate.
+# Find identifiers at: https://openrouter.ai/docs#models
+# Ensure the models support vision input.
+openrouter_models:
+  - "google/gemini-2.5-pro-preview-03-25"
+  - "anthropic/claude-sonnet-4"
+  - "google/gemini-2.5-flash-preview-05-20:thinking"
+  - "openai/o3"
+  - "openai/gpt-5"
+  - "x-ai/grok-4-fast:free"
+  - "google/gemini-3-pro-preview"
+  # - "google/gemini-pro-vision" # Example - uncomment or add others
+  # - "anthropic/claude-3-opus" # Example - check vision support and access
+  # - "anthropic/claude-3-sonnet"
+  # - "anthropic/claude-3-haiku"
+
+# Path to the metadata JSONL file and base directory for image paths.
+metadata_path: "images/metadata.jsonl"
+images_base_dir: "images"
+
+# Base directory where results for each model will be saved.
+results_base_dir: "results"
+
+# Optional: API request parameters
+# Maximum tokens to generate in the response. Keep it low as we expect only numbers.
+max_tokens: 10000
+# Timeout for each API request in seconds.
+# Set high enough for thinking models (o3, Gemini Flash Thinking) which can take longer.
+request_timeout: 200

images.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f969da1a44ca3e7fa3f1b165794196bea5e513a5ff4d7bac8fc5330e6e3415e8
+size 27916417