Upload Benchmark

README.md

@@ -15,7 +15,8 @@ pretty_name: ParseEmbed
 size_categories:
 - n<1K
 tags:
-- mteb
+- benchmark
+- evaluation
 - text
 - retrieval
 - hard-negatives
@@ -116,27 +117,11 @@ dataset_info:
 
 # ParseEmbed
 
-ParseEmbed is a compact retrieval benchmark for testing whether embedding
-models actually preserve parse-sensitive meaning, not just broad topic
-similarity.
+Hard, parse-sensitive retrieval evaluation for embedding models.
 
-Many embedding benchmarks reward models for finding text that is generally
-about the same subject. ParseEmbed is designed to be harder: every query has
-one correct document and several hard negatives that reuse almost the same
-words, entities, numbers, and structure. A model only scores well if it notices
-the detail that changes the answer.
-
-The benchmark focuses on three common failure modes:
-
-- `mean`: semantic details such as negation, numeric values, scope, conditions,
-  and exceptions.
-- `text_formatting`: meaning carried by Markdown-like formatting, including
-  code spans, headings, quotes, emphasis, and strike-through.
-- `table`: row and column grounding in compact Markdown tables.
-
-The purpose of ParseEmbed is diagnostic. It helps model builders see whether an
-embedding model is robust enough for retrieval over structured or semi-structured
-documents, where a tiny parsing mistake can retrieve the wrong answer.
+ParseEmbed is a compact benchmark for embedding models. It tests whether a
+model can retrieve the exact correct document when hard negatives share nearly
+all surface tokens with the answer.
 
 ## Tasks
 
@@ -153,6 +138,47 @@ documents, where a tiny parsing mistake can retrieve the wrong answer.
 - `corpus.jsonl`: retrieval corpus.
 - `queries.jsonl`: retrieval queries.
 - `qrels.jsonl`: relevance judgments.
+- `evaluate_parseembed.py`: reference evaluator for embedding models.
+- `requirements.txt`: evaluator dependencies.
+
+## Quick Start
+
+Install the evaluator dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+Run a local evaluation:
+
+```bash
+python evaluate_parseembed.py   --model sentence-transformers/all-MiniLM-L6-v2   --task all   --k 10   --output results.json
+```
+
+The evaluator reports `ndcg_at_10`, `recall_at_10`, and `mrr_at_10` for each
+task and an average across tasks.
+
+## Evaluation Protocol
+
+ParseEmbed is evaluated as dense retrieval:
+
+1. Embed every document in `corpus.jsonl`.
+2. Embed the queries from one benchmark split.
+3. Rank corpus documents by cosine similarity.
+4. Score the rank of each query's `positive_doc_id`.
+
+The official leaderboard metric should be `ndcg_at_10`. `recall_at_10` and
+`mrr_at_10` are included as secondary diagnostics.
+
+## Data Format
+
+Each benchmark split contains one JSON object per query with these fields:
+`id`, `query`, `positive_doc_id`, `positive_text`, `hard_negative_doc_ids`,
+`hard_negative_texts`, `answer`, `style`, and `difficulty`.
+
+The corpus is stored separately in `corpus.jsonl`, and `qrels.jsonl` provides
+standard retrieval relevance judgments with `query-id`, `corpus-id`, and
+`score`.
 
 ## Eval Results
 
@@ -169,6 +195,19 @@ Model repositories can report results with `.eval_results/parseembed.yaml`:
 
 Use task IDs `mean`, `text_formatting`, and `table`.
 
+## Benchmark Registration
+
+This repository is prepared for Hugging Face's beta Benchmark system:
+
+- It contains a root `eval.yaml`.
+- `evaluation_framework` is set to `parseembed`.
+- The benchmark has three task leaderboards: `mean`, `text_formatting`, and
+  `table`.
+- A working reference evaluator is included in `evaluate_parseembed.py`.
+
+Because Hugging Face's Benchmark feature is allow-listed, `parseembed` must be
+added by the Hugging Face team before the official Benchmark tag appears.
+
 ## Usage
 
 ```python
@@ -190,16 +229,11 @@ most of the vocabulary.
 No private or external source text is used. The benchmark is synthetic and is
 intended as a diagnostic stress test alongside natural retrieval benchmarks.
 
-## Interpreting Scores
-
-High scores mean the model can separate near-identical documents using the
-specific detail requested by the query. Low scores usually mean the model is
-overweighting topical similarity or lexical overlap.
+## Reproducibility
 
-ParseEmbed should not be treated as a replacement for broad retrieval
-benchmarks. It is best used as a focused stress test for document parsing,
-enterprise search, RAG systems, table retrieval, and formatting-sensitive text
-retrieval.
+ParseEmbed is fully deterministic. Regenerating from `generate_parseembed.py`
+with the same seed produces the same queries, corpus IDs, hard negatives, and
+relevance judgments.
 
 ## Size
 

dataset_info.json

@@ -32,7 +32,8 @@
     "n<1K"
   ],
   "tags": [
-    "mteb",
+    "benchmark",
+    "evaluation",
     "text",
     "retrieval",
     "hard-negatives",
@@ -69,4 +70,4 @@
     ],
     "corpus_documents": 2880
   }
-}
+}

eval.yaml

@@ -3,7 +3,7 @@ description: >
   ParseEmbed is a hard retrieval benchmark for embedding models. It measures
   semantic scope, formatting-sensitive meaning, and table cell grounding under
   near-duplicate hard negatives.
-evaluation_framework: mteb
+evaluation_framework: parseembed
 
 tasks:
   - id: mean