Datasets:

Reja1
/

jee-neet-benchmark

Condense the dataset card to the essentials: description, composition
table, quick-start (load + run + leaderboard), scoring tables, merged
fields/answer-format section, contamination notes, citation, license.

Remove duplicated/generic content already covered in CLAUDE.md: the
6-step manual-usage walkthrough, Advanced Features prose, repo-layout
section, duplicate field list, and the generic troubleshooting section.
No dataset-specific information lost.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Files changed (1) hide show

README.md +50 -325

README.md CHANGED Viewed

@@ -47,15 +47,11 @@ dataset_info:
 [![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), Matching List MCQs, and Integer type questions.
-**Current Data:**
 | Exam | Year | Set | Subjects | Questions |
 |------|------|-----|----------|----------:|
@@ -67,340 +63,75 @@ The questions are presented in image format (`.png`) as they appear in the origi
 | JEE Advanced | 2026 | Paper 1 & 2 | Physics, Chemistry, Mathematics | 102 |
 | **Total** | | | | **860** |
-Each question carries full metadata (exam, year, subject, question type, paper, and verified correct answer[s]). Subjects are evenly balanced within each set — NEET 2024 has 50 questions per subject; NEET 2025/2026 have 45 Physics, 45 Chemistry, and 90 Biology; every JEE Advanced set has an equal split across the three subjects.
-## 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
-## Leaderboard
-Generate an up-to-date leaderboard from your local results:
-```bash
-uv run python scripts/generate_leaderboard.py
 ```
-See `scripts/generate_leaderboard.py --help` for options including `--min-questions` and `--output`.
-## 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-3.1-pro-preview"
-          - "anthropic/claude-opus-4.7"
-          - "openai/gpt-5.5"
-          - "openai/o3"
-        ```
-    *   Ensure these models support vision input on OpenRouter.
-    *   You can also adjust other parameters like `max_tokens`, `request_timeout`, and `max_concurrent_requests` if needed.
-5.  **Run the benchmark:**
-    **Basic usage:**
-    ```bash
-    uv run python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "google/gemini-3.1-pro-preview"
-    ```
-    **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-opus-4.7" --exam_name JEE_ADVANCED --exam_year 2025
-    ```
-    **Run specific questions:**
-    ```bash
-    uv run python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "google/gemini-3.1-pro-preview" --question_ids "N24T3001,N24T3002,JA24P1M01"
-    ```
-    **Resume an interrupted run:**
-    ```bash
-    uv run python src/benchmark_runner.py --model "google/gemini-3.1-pro-preview" --resume results/google_gemini-3.1-pro-preview_NEET_2024_20260503_141230
-    ```
-    **Re-score with an updated answer key (no API calls):**
-    ```bash
-    # After updating correct_answer fields in metadata.jsonl, re-score existing predictions
-    uv run python src/benchmark_runner.py --score-only results/google_gemini-3.1-pro-preview_NEET_2026_20260503_141230
-    ```
-    **Custom output directory:**
-    ```bash
-    uv run python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "openai/gpt-5.5" --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
-    - `--score-only`: Path to an existing results directory to re-score with updated answers (no API calls)
-    - `--num_runs`: Number of independent runs for variance analysis (default: 1)
-    - `--temperature`: Override sampling temperature from config
-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-3.1-pro-preview_NEET_2024_20260503_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
-            - Exam name and year
-            - Token counts, cost (USD), and response latency per question
-        *   **`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
-  - -1 in all other cases, including any incorrect option selected
-  - 0 for skipped/API failure
-- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped/API failure
-- **Matching List MCQ**: +4 for correct, -1 for incorrect, 0 for skipped/API failure
-- **Stem-Based Integer Type (`INTEGER_2`)**: +2 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
-- Final `summary.md` covers the complete run across all sessions, not just the resumed portion
-### Score-Only Mode
-- Re-score existing predictions after the answer key is updated: `--score-only <results_dir>`
-- Reads `predicted_answer` from the existing `summary.jsonl`
-- Loads updated `correct_answer` values from the current `metadata.jsonl`
-- Overwrites `summary.jsonl` and `summary.md` in-place with new scores
-- No API calls made — completes in under a second
-- Useful when evaluating new exams before the official answer key is released: collect predictions immediately, re-score once the key drops
-#### Workflow for newly-released exams
-```bash
-# 1. Add questions to metadata.jsonl with placeholder answers, collect predictions immediately
-uv run python src/benchmark_runner.py --model "google/gemini-3.1-pro-preview" \
-  --exam_name NEET --exam_year 2026
-# 2. When the official answer key is released, update correct_answer in metadata.jsonl, then:
-uv run python src/benchmark_runner.py \
-  --score-only results/google_gemini-3.1-pro-preview_NEET_2026_<timestamp>
-```
-### Concurrent API Calls
-- Questions are evaluated in parallel using `ThreadPoolExecutor` (default: 4 workers)
-- Configurable via `max_concurrent_requests` in `configs/benchmark_config.yaml`
-- Significantly faster for thinking models (o3, Gemini Flash) with high per-question latency
-- File writes are thread-safe via a shared lock
-### 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, matching, 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 (green ✓ correct, yellow ~ partial, red ✗ incorrect)
-## 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", "MCQ_MATCHING", "INTEGER", "INTEGER_2")
-    - `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/NEET_2026/`: NEET 2026 question images
-    - `images/JEE_ADVANCED_2024/`: JEE Advanced 2024 question images
-    - `images/JEE_ADVANCED_2025/`: JEE Advanced 2025 question images
-    - `images/JEE_ADVANCED_2026/`: JEE Advanced 2026 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", "MCQ_MATCHING", "INTEGER_2") (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 and INTEGER_2 types, 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 Matching (Option C): `<answer>C</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
-## Limitations & Data Contamination
-### Contamination Risk
-This benchmark uses questions from publicly administered exams (JEE Advanced and NEET). These questions are widely published online after each exam and may appear in the training data of evaluated models, particularly for older exam years (e.g., 2024). High scores on this benchmark may therefore partially reflect memorization rather than genuine reasoning ability.
-To help assess contamination effects:
-- **Compare across years**: Models may score higher on older exams (2024) whose questions had more time to enter training data, compared to newer exams (2025).
-- **Cross-reference with novel benchmarks**: Compare performance on this benchmark with contamination-resistant benchmarks like GPQA or Humanity's Last Exam.
-This benchmark is best understood as an evaluation on **publicly available exam questions** rather than a contamination-free assessment of reasoning capability.
-### JEE Main Support
-The benchmark framework fully supports JEE Main scoring rules in code, but the current dataset does not include JEE Main questions. JEE Main support is available for users who wish to add their own JEE Main question sets.
-### Other Limitations
-- **Single prompt template**: Results may vary with different prompt formulations. The benchmark currently uses one prompt template per question type.
-- **No multi-run variance**: Each model is evaluated once per exam. Results may vary slightly across runs due to non-deterministic model behavior.
-- **Image quality dependence**: Performance may be affected by image resolution, scan quality, or the presence of artifacts in question images.
-- **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},
@@ -410,12 +141,6 @@ If you use this dataset or benchmark code, please cite:
 }
 ```
-## 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).

 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+A benchmark for evaluating vision-capable LLMs on Indian competitive exam questions (JEE Advanced & NEET). Each question is the original exam image; models answer via the OpenRouter API and are scored with authentic, exam-specific marking schemes — including partial credit for JEE Advanced multiple-correct questions.
+Supported question types: Single Correct MCQ, Multiple Correct MCQ, Matching List MCQ, Integer, and stem-based Integer (`INTEGER_2`). Every image carries metadata: exam, year, subject, question type, paper, and verified correct answer(s).
+## Dataset Composition
 | Exam | Year | Set | Subjects | Questions |
 |------|------|-----|----------|----------:|
 | JEE Advanced | 2026 | Paper 1 & 2 | Physics, Chemistry, Mathematics | 102 |
 | **Total** | | | | **860** |
+Subjects are evenly balanced within each set — NEET 2024 has 50 per subject; NEET 2025/2026 have 45 Physics, 45 Chemistry, 90 Biology; every JEE Advanced set splits equally across the three subjects.
+## Quick Start
+### Load the dataset
+```python
+from datasets import load_dataset
+import json
+dataset = load_dataset("Reja1/jee-neet-benchmark", split="test")
+example = dataset[0]
+image = example["image"]                                  # PIL image
+correct = json.loads(example["correct_answer"])           # e.g. ["A"], ["B", "C"], ["42"]
 ```
+### Run the benchmark
+```bash
+git clone https://huggingface.co/datasets/Reja1/jee-neet-benchmark
+cd jee-neet-benchmark
+git lfs pull                       # fetch images + metadata (stored in Git LFS)
+uv sync
+echo "OPENROUTER_API_KEY=your_key" > .env
+# Evaluate a vision-capable model on the full dataset
+uv run python src/benchmark_runner.py --model "google/gemini-3.1-pro-preview"
+# Filter by exam / year, resume a run, or re-score after an answer-key update
+uv run python src/benchmark_runner.py --model "openai/o3" --exam_name NEET --exam_year 2024
+uv run python src/benchmark_runner.py --model "openai/o3" --resume results/<run_dir>
+uv run python src/benchmark_runner.py --score-only results/<run_dir>     # no API calls
+```
+Configure the model list and parameters in `configs/benchmark_config.yaml`; run with `--help` for all options (`--question_ids`, `--num_runs`, `--temperature`, …). Each run writes a timestamped folder under `results/` containing `predictions.jsonl` (raw responses), `summary.jsonl` (per-question scores, tokens, cost, latency), and `summary.md` (human-readable report). Build a cross-model leaderboard with `uv run python scripts/generate_leaderboard.py`.
+## Scoring
+API/parse failures and skipped questions score **0** (no penalty), since they are not a deliberate wrong choice.
+**NEET** — Single Correct MCQ: **+4** correct, **−1** incorrect.
+**JEE Main** *(supported in code; no questions in the current dataset)* — Single Correct MCQ: +4 / −1. Integer: +4 / 0.
+**JEE Advanced**
+| Question type | Marking |
+|---------------|---------|
+| Single Correct MCQ | +3 correct, −1 incorrect |
+| Multiple Correct MCQ | Partial: +4 all correct · +3 for 3/4 · +2 for 2/3+ · +1 for 1/2+ · −1 if any wrong option chosen |
+| Integer | +4 correct, 0 incorrect |
+| Matching List MCQ | +4 correct, −1 incorrect |
+| Stem-based Integer (`INTEGER_2`) | +2 correct, 0 incorrect |
+## Data Fields & Answer Format
+Each record exposes: `image`, `question_id`, `exam_name`, `exam_year` (int), `subject`, `question_type` (`MCQ_SINGLE_CORRECT`, `MCQ_MULTIPLE_CORRECT`, `MCQ_MATCHING`, `INTEGER`, `INTEGER_2`), `paper_id`, and `correct_answer` — a JSON-serialized string parsed with `json.loads()`. MCQ answers are option identifiers (`["A"]`, `["B", "C"]`); Integer answers are numbers as strings (`["42"]`, `["12.75"]`). A few single-correct questions list multiple acceptable options; a prediction matching any one is correct.
+Models return answers in `<answer>...</answer>` tags: `<answer>A</answer>`, `<answer>B,D</answer>` (multiple correct), `<answer>42</answer>` / `<answer>12.75</answer>` (numeric), or `<answer>SKIP</answer>`.
+## Limitations & Data Contamination
+These are publicly administered exams, widely published online after each sitting, so questions may appear in models' training data — especially for older years. High scores may partly reflect memorization rather than reasoning. Treat this as an evaluation on **publicly available exam questions**, not a contamination-free reasoning test; compare across years (older = higher contamination risk) and cross-reference with contamination-resistant benchmarks (e.g. GPQA, Humanity's Last Exam).
+Other caveats: a single prompt template per question type (results vary with phrasing); one run per model by default (non-deterministic outputs vary slightly); performance is sensitive to image quality; English only; requires vision models on OpenRouter.
 ## Citation
 ```bibtex
 @misc{rejaullah_2025_jeeneetbenchmark,
   title={JEE/NEET LLM Benchmark},
 }
 ```
+## Contact & License
+Questions or collaboration: [@RejaullahmdMd](https://x.com/RejaullahmdMd) on X. Released under the [MIT License](https://opensource.org/licenses/MIT).