SoroushVahidi/consistency-aware-judgments

Consistency-Aware Judgments (v1)

Consistency-Aware Judgments is an original research dataset of 56,332 derived pairwise-preference records (across four configs) produced by asking multiple commercial Large Language Model (LLM) providers to judge which of two documents is more relevant to a query, for query/document pairs drawn from three existing public retrieval benchmarks (SciDocs, HotpotQA, BRIGHT). It supports research on LLM-as-judge reliability, cross-provider disagreement, and consistency-aware reranking — a method that repairs contradictions in a graph of pairwise preferences before using them to rerank documents. No benchmark text, queries, passages, or qrels are included — only benchmark ID references plus the judgments and derived graph-repair features computed over them. License: CC BY-SA 4.0.

1. Overview

This is the public v1 release of SoroushVahidi/consistency-aware-judgments, published 2026-08-13. It packages four related tables produced by the author's consistency-aware-llm-rankin research pipeline:

• pairwise_judgments (48,777 rows) — the core table: one row per LLM judgment of which of two benchmark documents is more relevant to a benchmark query.
• repeated_measurements (7,140 rows) — query/document-pair groups deliberately measured more than once (different orientation and/or provider), for stability/disagreement analysis.
• selector_training (139 rows) — derived preference-graph and repair features/labels used to train a "when to trust the graph repair" selector.
• provider_diagnostics (276 rows) — safe, coarsened acquisition metadata (latency, status, timestamp buckets) per provider call.

2. Why this dataset exists

Using an LLM as a relevance judge is increasingly common in IR research, but a single judgment is noisy: the same model can disagree with itself across orientations (A-vs-B vs B-vs-A) or across providers. This dataset was built to study that noise directly and to support consistency-aware reranking via preference-graph repair — treating the set of pairwise judgments for a query as a graph, detecting cyclic/inconsistent preferences, and repairing them before reranking. It exists so that this style of analysis can be reproduced and extended without needing to re-purchase the underlying paid API calls, and without redistributing any of the underlying benchmark text.

3. What is included

• Derived, ID-level pairwise preference judgments from four providers: OpenAI (gpt-4o-mini), Azure OpenAI (public model id gpt-4.1-mini; private deployment names/endpoints excluded), Google Gemini/Vertex (gemini-2.5-flash), and Fireworks (gpt-oss-120b).
• Benchmark ID references only into SciDocs, HotpotQA, and BRIGHT (query IDs, document IDs) — used to link a judgment back to a benchmark item, not to redistribute its content.
• Derived preference-graph / repair features and selector-training labels (selector_training).
• Safe acquisition metadata: latency, call status, coarsened timestamp buckets (provider_diagnostics).

4. What is not included

• No prompts, raw model completions, or raw API payloads.
• No benchmark query/document text, passages, answers, or qrels from SciDocs, HotpotQA, or BRIGHT.
• No Cohere-derived judgments (21,329 rows excluded pending clearer redistribution terms — a conservative, rights-driven exclusion, not a comment on model quality).
• No FiQA-derived rows (21,854 rows excluded post-filter — FiQA's own page restricts its data to non-commercial use, which conflicts with a more permissive BEIR-metadata label; the ambiguity is resolved conservatively by excluding it).
• No private provider infrastructure identifiers (deployment names, endpoints, account/project IDs, credentials).

5. Dataset size

Config	Rows	Columns
pairwise_judgments	48,777	26
repeated_measurements	7,140	11
selector_training	139	83
provider_diagnostics	276	9
Total	56,332	—

Row counts are measured from the published snapshot's own metadata/statistics.json and verified against the shipped Parquet files (SHA-256-checked in metadata/release_manifest.json).

6. What one row represents

• pairwise_judgments: one row = one provider/model's judgment of which of two benchmark document IDs is more relevant to one benchmark query ID, for one orientation (signed_preference = 1 → doc_a_id won; -1 → doc_b_id won; 0 → non-decisive/abstained).
• repeated_measurements: one row = one query/document-pair group that was intentionally measured more than once (across orientation and/or provider), summarizing agreement/conflict across those repeats.
• selector_training: one row = one query's preference graph, described by topology and consistency-repair features (e.g. cycle structure, inconsistency energy, repair gain), with a label for selector training.
• provider_diagnostics: one row = one safe, coarsened record of a single provider API call's operational metadata (status, latency, timestamp bucket) — no content.

7. Dataset structure / schema

pairwise_judgments (26 columns) — most important columns:

Column	Type	Meaning
benchmark	string	Source benchmark for the query/documents (scidocs, hotpotqa, or bright)
provider	string	API provider (openai, azure_openai, google, fireworks)
model	string	Public model identifier used for the judgment
query_id	string	Benchmark query ID (no query text)
doc_a_id / doc_b_id	string	Benchmark document IDs being compared (no document text)
doc_pair_key / canonical_key	string	Deduplication keys for the unordered pair / full judgment
orientation	string	Whether the call used A-vs-B, B-vs-A order, or a compact winner/loser export
judgment_status	string	Whether the parsed judgment was decisive, non-decisive, or abstained
signed_preference	int	1 = doc_a_id won, -1 = doc_b_id won, 0 = non-decisive
winner_doc_id / loser_doc_id	string	Populated only for decisive judgments
confidence_category, abstention_subtype, logprob_margin	categorical / float	Judgment-quality signals; marked unavailable where not safely present
source_run_id, source_record_index, repeat_index	string / int	Provenance back to the acquisition run (not to raw content)
acquisition_date, from_cache, latency_s, prompt_tokens, completion_tokens	date / bool / float / int	Acquisition metadata

The remaining three configs' full column lists (verified from metadata/schema_metadata.json):

• repeated_measurements (11 cols): benchmark, query_id, doc_pair_key, n_measurements, n_providers, n_decisive, n_parse_or_abstain, has_conflict, orientations, providers, winner_count_json.
• selector_training (83 cols): graph/repair topology and consistency features, e.g. n_nodes, n_edges, is_cyclic, largest_scc_frac, curl_norm, harmonic_norm, inconsistency_energy, fas_removed_weight, repair_applied, repair_gain_primary, plus copeland_*, balance_*, mov_* families — full list in the release's metadata/schema_metadata.json.
• provider_diagnostics (9 cols): benchmark, provider, model, query_id, source_run_id, status, from_cache, latency_s, timestamp_bucket_utc.

8. Quickstart

from datasets import load_dataset

# Each table is a separate config; there is no default config.
pairwise = load_dataset("SoroushVahidi/consistency-aware-judgments", "pairwise_judgments")
repeated = load_dataset("SoroushVahidi/consistency-aware-judgments", "repeated_measurements")
selector = load_dataset("SoroushVahidi/consistency-aware-judgments", "selector_training")
diagnostics = load_dataset("SoroushVahidi/consistency-aware-judgments", "provider_diagnostics")

print(pairwise)

The largest config (pairwise_judgments, 48,777 rows / 26 columns) is small enough to load fully in memory; streaming is not necessary at this size.

9. Research use cases

• Studying LLM-as-judge reliability: cross-provider disagreement, orientation (A/B order) effects, and abstention behavior.
• Reproducing or extending consistency-aware graph-repair reranking analysis.
• Training/evaluating a "when to trust the repaired graph" selector using selector_training.
• Reliability/variance analysis using repeated_measurements without needing to re-query paid APIs.
• Auditing provider-call operational characteristics (latency, cache hit rate) via provider_diagnostics.

Not intended for: replacing human qrels, reproducing benchmark text, or as evidence that model-generated preferences are objectively correct.

10. Generation methodology

Judgments were acquired by prompting each provider/model to compare two benchmark documents for a given query, across SciDocs, HotpotQA, and BRIGHT query/document ID pairs, with some pairs measured under both A-vs-B and B-vs-A orientation and/or by multiple providers. Rows are deduplicated using a canonical key over provider, model, benchmark, query ID, unordered document pair, orientation, and source run ID — intentional repeats (orientation or cross-provider) are preserved, not collapsed, and summarized separately in repeated_measurements. Preference graphs per query are then analyzed for cyclic/inconsistent structure and repaired; the resulting topology and repair features feed selector_training. Full methodology and results are in the associated paper (§14).

11. Provenance and ownership

• Generated by Soroush Vahidi: all four tables' rows — the judgments, disagreement summaries, and graph-repair features/labels — are original derived-analysis output from the author's consistency-aware-llm-rankin pipeline. This is not a repackaging of any third-party dataset.
• Derived from third-party benchmarks: query_id, doc_a_id, doc_b_id reference items in SciDocs, HotpotQA, and BRIGHT. Only the IDs are included — no third-party benchmark text is redistributed.
• Third-party method: none — the judging models (OpenAI/Azure/Google/Fireworks) are used as a measurement instrument via their public APIs, not redistributed.
• Not redistributed by design, and excluded from this release: Cohere-derived judgments and FiQA-derived rows (see §4) pending explicit redistribution-rights clearance; also raw prompts, raw completions, and provider infrastructure identifiers.
• Source integrity: the release's metadata/source_integrity.json records before/after SHA-256 hashes for the 10 exact local source files consumed by the v1 build, confirmed unchanged at build time.

12. Relationship to related datasets

• SoroushVahidi/scidocs — a third-party convenience mirror of the SciDocs corpus/queries itself (not this author's research contribution). This dataset references SciDocs IDs but contains no SciDocs text; the two are complementary, not overlapping.
• SoroushVahidi/lafc-evict — a cache-eviction supervision dataset for learning-augmented caching; unrelated research topic (caching vs. retrieval-judgment consistency).
• SoroushVahidi/lafc-evict-sample — a synthetic publication-workflow test artifact, not a research benchmark; unrelated to this dataset.
• SoroushVahidi/module-intervention-credit — credit assignment for LLM-serving scheduler modules; unrelated research topic.

13. Limitations

• Provider coverage is imbalanced (four providers included; Cohere excluded).
• Model identifiers are point-in-time public identifiers and do not fully describe private hosted deployment internals.
• FiQA exclusion reduces benchmark coverage in exchange for a conservative rights posture.
• The build scripts that produced metadata/dedup_report.json and metadata/security_scan_report.json are not currently co-located in a private_audit/ folder the way they are for some sibling datasets in this author's portfolio — the shipped outputs of that process are present and hash-verified, but the exact script is a documentation gap, not a data-quality issue.
• No DOI is assigned to the dataset artifact itself (only the associated paper has one).

14. Version history

• v1 (2026-08-13) — initial public release, 4 configs, 56,332 rows total. Scientific release revision f9317638ca1cc422661f704168335576d36ca995.
• A possible future v1.1 would only be additive (new Cohere and/or FiQA rows appended once redistribution rights are explicitly cleared) and would not alter or remove any v1 row or value.

15. Related resources

• Paper: Soroush Vahidi. "Consistency-Aware Reranking via Preference Graph Repair: Structural Gains and Conditional Retrieval Effects." Research Square preprint, posted June 17, 2026. DOI: 10.21203/rs.3.rs-9335700/v1.
• Code: github.com/SoroushVahidi/consistency-aware-llm-rankin (per the dataset's own shipped CITATION.cff).
• Related Hugging Face datasets: SoroushVahidi/scidocs (upstream ID source, third-party mirror), SoroushVahidi/lafc-evict, SoroushVahidi/lafc-evict-sample.

16. Citation

Cite the dataset when using these records directly; cite the paper when discussing the methodology or reported results; cite both when relying on both.

Dataset:

@dataset{vahidi2026consistencyawarejudgments,
  title = {Consistency-Aware Judgments},
  author = {Vahidi, Soroush},
  year = {2026},
  version = {v1},
  publisher = {Hugging Face},
  url = {https://huggingface.co/datasets/SoroushVahidi/consistency-aware-judgments},
  note = {Scientific release revision f9317638ca1cc422661f704168335576d36ca995; no DOI assigned}
}

Paper:

@article{vahidi2026consistencyawarereranking,
  title = {Consistency-Aware Reranking via Preference Graph Repair: Structural Gains and Conditional Retrieval Effects},
  author = {Vahidi, Soroush},
  year = {2026},
  journal = {Research Square (preprint)},
  doi = {10.21203/rs.3.rs-9335700/v1}
}

17. License

CC BY-SA 4.0. Chosen conservatively because v1 contains derived labels over SciDocs and HotpotQA IDs (both associated with CC BY-SA 4.0 upstream materials) and BRIGHT (CC BY 4.0); no benchmark text is redistributed.