---
language:
- en
license: apache-2.0
task_categories:
- text-retrieval
task_ids:
- document-retrieval
annotations_creators:
- algorithmic
multilinguality: monolingual
source_datasets:
- original
pretty_name: ParseEmbed
size_categories:
- n<1K
tags:
- benchmark
- evaluation
- text
- retrieval
- hard-negatives
- table-retrieval
configs:
- config_name: parse-embed
  data_files:
  - split: mean
    path: mean.jsonl
  - split: text_formatting
    path: text_formatting.jsonl
  - split: table
    path: table.jsonl
- config_name: corpus
  data_files:
  - split: test
    path: corpus.jsonl
- config_name: queries
  data_files:
  - split: test
    path: queries.jsonl
- config_name: default
  data_files:
  - split: test
    path: qrels.jsonl
dataset_info:
- config_name: parse-embed
  features:
  - name: id
    dtype: string
  - name: query
    dtype: string
  - name: positive_doc_id
    dtype: string
  - name: positive_text
    dtype: string
  - name: hard_negative_doc_ids
    sequence: string
  - name: hard_negative_texts
    sequence: string
  - name: answer
    dtype: string
  - name: style
    dtype: string
  - name: difficulty
    dtype: string
  splits:
  - name: mean
    num_examples: 240
  - name: text_formatting
    num_examples: 240
  - name: table
    num_examples: 240
- config_name: corpus
  features:
  - name: _id
    dtype: string
  - name: title
    dtype: string
  - name: text
    dtype: string
  - name: style
    dtype: string
  - name: difficulty
    dtype: string
  - name: trap
    dtype: string
  splits:
  - name: test
    num_examples: 2880
- config_name: queries
  features:
  - name: _id
    dtype: string
  - name: text
    dtype: string
  - name: style
    dtype: string
  - name: difficulty
    dtype: string
  - name: answer
    dtype: string
  splits:
  - name: test
    num_examples: 720
- config_name: default
  features:
  - name: query-id
    dtype: string
  - name: corpus-id
    dtype: string
  - name: score
    dtype: int64
  splits:
  - name: test
    num_examples: 720
---

# ParseEmbed

Hard, parse-sensitive retrieval evaluation for embedding models.

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

| Task ID | Split | What it measures |
|---------|-------|------------------|
| `mean` | `mean` | Semantic scope, negation, numeric values, temporal conditions, and exception handling |
| `text_formatting` | `text_formatting` | Meaning carried by Markdown-like formatting such as code spans, headings, quotes, and strike-through |
| `table` | `table` | Row/column grounding in compact Markdown tables |

## Files

- `eval.yaml`: Hugging Face Benchmark definition.
- `mean.jsonl`, `text_formatting.jsonl`, `table.jsonl`: benchmark splits.
- `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

Model repositories can report results with `.eval_results/parseembed.yaml`:

```yaml
- dataset:
    id: Convence/ParseEmbed
    task_id: mean
    revision: <dataset_commit_hash>
  value: <ndcg_at_10_score>
  notes: "metric=ndcg_at_10"
```

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
from datasets import load_dataset

mean = load_dataset("Convence/ParseEmbed", "parse-embed", split="mean")
corpus = load_dataset("Convence/ParseEmbed", "corpus", split="test")
queries = load_dataset("Convence/ParseEmbed", "queries", split="test")
qrels = load_dataset("Convence/ParseEmbed", split="test")
```

## Dataset Construction

The benchmark is generated deterministically from `generate_parseembed.py` with
seed `91247`. Each query has one positive document and three hard negatives.
The negatives are constructed by changing a decisive detail while preserving
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.

## Reproducibility

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

- Queries: 720
- Corpus documents: 2,880
- Queries per task: 240

## License

Apache 2.0