Gholamali/Arena_Human_Preference_90K_features_verified

Arena Human Preference 90K: Engineered Features and Correctness Annotations

A derived release built on lmarena-ai/arena-human-preference-140k, restricted to one evaluation per conversation (evaluation_order == 1), which leaves approximately 90,000 battles.

It provides two things the source corpus does not: a table of interpretable structural and linguistic features computed over every battle, and a subset in which response correctness was reviewed by a human annotator independently of the recorded preference label.

Motivation Pairwise preference corpora ship raw conversation text and a preference label, but not the structural signals known to correlate with and confound that label: response length, formatting density, refusal and truncation failures, language mismatch, instruction-following compliance. Studying those confounds currently requires either an expensive transformer pass or accepting them as unmeasured noise. This release computes them once, deterministically, and makes them auditable.

All features are computed without reading the winner column. No feature in this release is a function of the label it is intended to predict.

Dataset summary

Source corpus	lmarena-ai/arena-human-preference-140k
Filter	evaluation_order == 1
Rows	~90,000 battles
Feature columns	~165, in two families (see Feature schema)
Reviewed subset	218 battles with independent correctness annotation
Languages	64 detected, predominantly English
Time span	April–July 2025 (inherited from source)
Format	Parquet

Loading

from datasets import load_dataset

# Full feature table
battles = load_dataset("<ORG>/<DATASET>", "default", split="train")

# Correctness-annotated subset
validated = load_dataset("<ORG>/<DATASET>", "manual_validation", split="train")

The two configs join on id, which is also the join key back to the upstream source dataset.

Supported tasks

• Pairwise preference modeling. The per-side a_* / b_* features are designed as inputs to a reward model or preference classifier, usable alongside or in place of text embeddings.
• Confound analysis in human preference. Whether length, formatting richness, or interaction cues predict winner independently of response quality. This is the primary use we built the release for.
• Failure-mode analysis at scale. Refusal, truncation, and near-empty detection across ~90K battles without per-row review.
• Format and length compliance auditing. Whether a response delivered the output format and length the prompt explicitly requested, by cross-tabulating the prompt_requests_* columns against the corresponding a_* / b_* detectors.
• Multilingual and code-switching analysis of prompts and responses.

Dataset structure

Configs

default

Battles from the source corpus filtered to evaluation_order == 1, joined with all engineered feature columns. The filter retains one evaluation per conversation; without it, repeated evaluations of the same conversation appear as separate rows and are not statistically independent.

Original columns (id, user_prompt, response_a, response_b, winner, conv_metadata, category_tag, and others inherited from the source) are preserved unmodified alongside the derived columns.

manual_validation

218 battles with independent per-response correctness annotation, restricted to prompts where correctness is a well-defined property (math, code, factual recall, translation, logic) rather than open-ended or creative prompts.

Column	Type	Description
id	str	Joins to default and to the upstream source dataset
user_prompt	str	The user's prompt
model_a_response	str	Response A text
model_b_response	str	Response B text
winner	str	Recorded outcome: model_a, model_b, tie, both_bad
is_correctness_applicable	bool	Whether correctness is well-defined for this prompt. true for all rows in this file, since it was the inclusion criterion
is_response_a_correct	bool	Whether response A was judged correct
is_response_b_correct	bool	Whether response B was judged correct
is_winner_label_correct	bool	Whether the recorded winner matches the response judged correct
response_a_incorrect_reason	str	Free-text note on why A was judged incorrect, where applicable
response_b_incorrect_reason	str	Free-text note on why B was judged incorrect, where applicable
winner_label_incorrect_reason	str	Free-text note on why the winner label was judged incorrect, where applicable

All four is_* columns are boolean, not correct/incorrect string labels.

Headline result. Of the 218 battles, 71 (32.6%) carry a winner label that does not align with objective correctness: either the more correct response lost, or both responses were wrong and a winner or tie was nonetheless recorded. On prompts where correctness is well-defined, roughly one preference label in three does not track it.

Annotation protocol

Candidate battles were drawn at random from the corpus, then screened for whether correctness was applicable and manually checkable, yielding the 218 released here. None were selected to illustrate a particular failure mode.

The 218 battles were manually reviewed by a single annotator. For each battle, the annotator first determined whether objective correctness was applicable. When applicable, responses A and B were evaluated independently for correctness. LLMs were used as auxiliary tools to help assess some specialized questions, particularly when the annotator lacked sufficient domain knowledge. In cases where LLM outputs differed, the annotator further reviewed the question and responses and made the final correctness determination. Final correctness labels were assigned by the human annotator.

Responses were assessed independently rather than against one another: no winner was selected and no ranking was produced. This is deliberately not a pairwise judging protocol. The point is a correctness signal decoupled from preference, so that the two can be cross-tabulated; a pairwise protocol would largely reproduce the preference label it is meant to check.

Feature schema

Features are derived from the prompt, responses, and source metadata using deterministic text- and metadata-based heuristics. They divide into two families by source. Prefixes encode provenance, so the origin of any column is recoverable from its name.

Prefix	Family	Meaning
prompt_	Text	Property of user_prompt
a_ / b_	Text	Same property computed independently for each response
dataset_a_ / dataset_b_	Metadata	Source-native fields from conv_metadata, mirrored as-is
cat_	Metadata	Flattened labels from category_tag
(unprefixed)	Metadata	Conversation-level scalar not tied to one side (turns, is_multi_turn, turn_density)

Every feature describes one side, the prompt, or the conversation as a whole. Contrasts between response A and response B are not included; they are deterministic functions of the per-side columns and can be computed downstream.

Metadata features (~48 columns)

Derived from the source dataset's own conv_metadata and category_tag fields. No text is parsed at this stage.

Feature	Type	Definition
bold_total	int	Bold spans across both responses (** and __)
bold_style_preference	str	"**", "__", "equal", or "none"
emphasis_intensity	float	log(1 + bold_total)
total_headers	int	Heading occurrences across both responses
header_depth_score	int	Σ (level × count) over H1–H6
total_list_items	int	Ordered + unordered items across both responses
ordered_ratio / unordered_ratio	float	Proportion of list items by type, [0, 1]
assistant_tokens_total	int	Assistant A + B tokens
user_tokens	int	User-provided tokens
context_tokens_total	int	Context tokens, both sides
assistant_token_ratio	float	assistant_total / max(user_tokens, 1)
turns	int	Conversational turns
is_multi_turn	bool	turns > 1
turn_density	float	assistant_tokens / turns
dataset_a_* / dataset_b_*	int	Source-native bold, list (ordered/unordered), header H1–H6, token, and context-token counts, mirrored per side
cat_complexity, cat_creativity, cat_domain_knowledge, cat_problem_solving, cat_real_world, cat_specificity, cat_technical_accuracy, cat_creative_writing, cat_math, cat_if	bool	Source-provided interaction-type labels
cat_if_score	int	Instruction-following complexity, [0, 4]

dataset_* columns exist for validation against the independently computed text features; note that source-native bold counts track ** only, while bold_total also captures __. cat_* extraction strips version suffixes (criteria matches criteria_v0.1, criteria_v0.2, …), so column names are stable across source schema bumps.

Text features (117 columns)

The same ~25 extractors run independently over user_prompt (prefix prompt_), response_a (a_), and response_b (b_): 43 prompt columns and 37 per response. The six requests_* columns are prompt-only, since they characterize what was asked for rather than a property of the text itself.

Language and script

Feature	Type	Definition
primary_language	str	ISO 639-1 code, or "unknown"
is_multilingual	bool	Two or more languages each covering ≥5% of chunks
script	str	Dominant Unicode script: arabic, cjk, cyrillic, latin, other

Structure

Feature	Type	Definition
paragraph_count	int	Blank-line-delimited paragraphs
paragraph_length_mean / paragraph_length_std	float	Words per paragraph, mean and population SD
sentence_count	int	Split on terminal punctuation and newlines
sentence_length_std	float	Population SD of sentence word counts
sentence_per_paragraph_std	float	Population SD of sentences per paragraph
long_sentence_count	int	Sentences of ≥30 words
short_sentence_count	int	Sentences of ≤10 words

Code and technical content

Feature	Type	Definition
code_delimiters	int	Fences (```, ~~~), inline backticks, and <code>/<pre>/<script>/<style> tags
is_code_block	bool	Fenced, inline, tagged, or heuristically detected code
is_natural_text	bool	Prose vs. code/markup, from fence prevalence, code-line ratio, alphabetic proportion, delimiter count
has_latex	bool	Inline $…$, display $$…$$, environments, or known math macros
has_json	bool	Fenced or raw JSON that parses to a dict or list (bare scalars excluded)
has_table / table_count	bool / int	Markdown or HTML tables
has_list / list_item_count	bool / int	Markdown list item lines

Lexical and stylistic

Feature	Type	Definition
token_count	int	Script-calibrated estimate: 3.8 chars/token Latin, 2.4 Persian/Arabic, 1.2 Chinese, 4.0 fallback
repetition_density	float	(total_words − unique_words) / total_words, case-insensitive
punctuation_count	int	Frequency of common punctuation marks
word_count	int	Whitespace-delimited
avg_words_per_sentence	float	Mean
is_detailed	bool	avg_words_per_sentence > 15 and word_count > 50
has_step_by_step	bool	Enumerations, transitions, procedural patterns
has_emoji / emoji_count	bool / int	Unicode 15.1 coverage

Interaction cues

Feature	Type	Definition
has_question_at_end	bool	Ends on a question mark
has_conclusion	bool	Conclusive phrasing
has_next_steps	bool	Forward-looking phrasing
has_interaction_prompt	bool	Engagement phrasing
interaction_score	int	Sum of the four above, [0, 4]

Quality and failure signals

Feature	Type	Definition
has_refusal	bool	Refusal phrasing, gated on refusal-object context to suppress hedging false positives
is_near_empty	bool	Empty, whitespace-only, no alphanumerics, or ≤3 words and ≤10 characters
is_truncated	bool	Unclosed code fence (odd delimiter count), or final line ending mid-word

is_near_empty requires both thresholds so that short-but-complete answers (a single numeral, one long word) are not flagged. is_truncated is deliberately conservative and will not flag responses ending on code fences, list items, table rows, or headings. The two are distinct signals: a long, substantive response can be truncated, and empty input is not counted as truncated.

Requested format and length (prompt only)

Feature	Type	Definition
prompt_requests_list / _table / _json / _code	bool	Prompt explicitly asks for that output format
prompt_requests_brief / _detailed	bool	Prompt explicitly asks for brevity or depth

requests_brief and requests_detailed are independent, not mutually exclusive, since real prompts contain contradictory phrasing.

Dataset creation

Source data

All conversations, preference labels, and metadata originate from lmarena-ai/arena-human-preference-140k, which contains votes collected in LMArena's text-only category between April and July 2025. Each source row is one vote judging two anonymized models on a user conversation. We did not collect, generate, or modify any conversation text or preference label.

Filtering

The source corpus contains multiple evaluations per conversation session, indexed by evaluation_order. We retain only evaluation_order == 1, leaving approximately 90,000 battles. Later evaluations in a session reuse conversation context and re-sample the responding models, so treating them as independent observations would overweight long sessions and introduce within-session correlation.

Every retained battle is single-turn (turns == 1), so user_prompt, response_a, and response_b each hold exactly one message and require no flattening. The conversation-level columns are consequently degenerate on this release: is_multi_turn is uniformly false and turn_density equals assistant_tokens_total. They are retained for schema compatibility with the unfiltered corpus.

Feature extraction

The extractors are regex and arithmetic heuristics over Python's standard library plus pandas. No transformer model, embedding API, or GPU inference is involved. The single exception is language identification, which uses Google MediaPipe's on-device LanguageDetector (TFLite). Every extractor is a pure function; None, NaN, empty strings, malformed metadata, and unexpected types return a neutral zero, False, or "unknown" default rather than raising. No row is dropped for a malformed field.

Language identification

Before inference, text is stripped of fenced and unfenced code, LaTeX, binary runs, and URLs, since LLM output mixes these with prose and they are otherwise misdetected as language content. A guard preserves the original text when stripping would reduce a short snippet below three characters.

Multi-language detection splits text into chunks, discards low-signal chunks (under 8 characters, matching code patterns, or below 0.5 alphabetic density), runs detection per chunk, and takes a ratio-weighted vote. Chunking is CJK-aware: Han, Hiragana, and Katakana runs are chunked by character count at twice the word budget, reflecting higher per-character information density, while space-delimited scripts including Hangul are chunked by word count. Text is marked multilingual when two or more languages each cover at least 5% of chunks.

Defaults (chunk_size=20, min_lang_ratio=0.05) were selected by grid search against a hand-labeled set of 40 dataset prompts (9 multi-language, 31 single-language), achieving F1 = 0.76 at precision 0.67 and recall 0.89.

Obsolete ISO 639-1 codes are normalized: iw→he, in→id, ji→yi.

Considerations for using the data

Treat winner as preference, not correctness

This is the central claim of the release. On the 218 battles where correctness is well-defined, 32.6% of preference labels do not track it. Training a reward model on winner without accounting for this trains on a signal that is substantially stylistic. That is a legitimate object of study; it is a problem only when the label is treated as a proxy for response quality.

Limitations

• Features are heuristic proxies. Segmentation, refusal and truncation detection, and token counts are regex- and arithmetic-based approximations, not linguistic parses or tokenizer output.
• Language detection has limited validation: F1 = 0.76 on 40 hand-labeled prompts, with only 9 positive examples of the multi-language class. primary_language and is_multilingual should be treated as noisy.
• winner is inherited from the upstream dataset. It is a preference label, not a correctness label, and nothing in this pipeline re-derives or corrects it.
• Correctness annotations cover 218 battles, all of them prompts where correctness is well-defined. The 32.6% figure carries the sampling error of that size and does not generalize to the corpus as a whole.
• The source dataset carries its own sampling, model-coverage, and rater biases, inherited here unchanged. English predominates.

Personal and sensitive information

Prompts are user-submitted and were not written with publication in mind. The upstream release performs no PII redaction, and neither does this one. Incidental personal information may appear in prompt text. Handle accordingly under your institution's requirements.

Licensing

Prompts are CC-BY-4.0, following the upstream dataset. Response text remains subject to the terms of use of whichever model produced it, since the corpus spans outputs from many providers. This is the same distinction the upstream lmarena-ai/arena-human-preference-140k makes. Engineered feature columns and correctness annotations contributed by this release are CC-BY-4.0.

Citation

@misc{arena_90k_features,
  title  = {Arena Human Preference 90K: Engineered Features and Correctness Annotations},
  author = {Mirzaei, Nazanin and
            Naderi, Parsa and
            Niknam, Mohammad Hadi and
            Azhand, Arash and
            Kiabakht, Hatef and
            Zohrab, Hamed and
            Khodam Mohammadi, Farin and
            Latifi, Fatemeh and
            Kakaei, Samin and
            Salmani, Faezeh and
            Namjoomanesh, Hamidreza and
            Daraee, Mohammad and
            Tavakoli, Seyedreza and
            Aminian, Gholamali},
  year   = {2026},
}
}

Please also cite the upstream corpus:

@misc{arena_human_preference_140k,
  title  = {Arena Human Preference 140K},
  author = {LMArena},
  year   = {2025},
  url    = {https://huggingface.co/datasets/lmarena-ai/arena-human-preference-140k}
}

Contact

Questions about the feature pipeline or the correctness annotations: Gholamali Aminian, gaminian@turing.ac.uk.