HelpSteer2-Preference Seven-Point Preference Strength
Judge which of two real HelpSteer2 responses is better on a -3 to 3 preference scale, flag pairs where neither response is valid, and write a justification.
Try it live — no install
Boot the real Potato server in your browser (WebAssembly) and annotate with this exact config. Nothing leaves your machine.
Run live in your browserGet This Design
Clone or download from the repository
Quick start:
git clone https://github.com/davidjurgens/potato-showcase.git
cd potato-showcase/preference-learning/helpsteer2-preference-reward-model
potato start config.yamlAbout this dataset
HelpSteer2-Preference is the preference subset of NVIDIA's HelpSteer2, a CC BY 4.0 dataset of prompts with pairs of model responses, annotated through Scale AI. Wang et al. released the subset to compare Bradley-Terry reward models, trained on which response was preferred, with regression reward models, trained on rating scores. The paper reports 7,118 preference pairs after filtering, with 6,766 in the training split and 352 in the validation split.
Each annotator saw a prompt and two responses and chose among seven options. The options run from -3 (Response 1 is much better) to 3 (Response 2 is much better), with no 0 and a separate -100 for pairs where neither response is valid. The paper forced a choice on purpose, to discourage sitting on the fence and to make annotators look closer at small differences. The vendor was asked to give each task to 3 to 5 annotators, and each also wrote a justification. The design reproduces the scale with a pairwise scheme in scale mode from -3 to 3, a radio for the invalid flag, and a multiline justification box. The five Likert ratings per response that annotators gave first are omitted. Potato's slider rests on 0 and cannot exclude 0, so the no-tie rule appears in the instructions and is not enforced. The ten items are real rows from the released preference file, with the paper's aggregate strength stored beside each item for comparison. The pairwise-preference-rationale design in the gallery uses a five-option radio with confidence and factor checkboxes. The design here follows the paper's seven-point wording and includes the training loop.
Training uses the reward-model trainer, which fits a scalar reward model with the Bradley-Terry loss, the objective used to train reward models for RLHF. For a scale answer, the response on the side the slider leans toward wins, weighted by how far the slider leans, so -3 and 3 count fully and answers of 0 are skipped. Each reward is computed for a response given the item's prompt. After a run on /admin/training, predictions on unlabeled items are written back as pre-labels on the scale. The trainer learns from the labels collected in the study and does not reproduce the paper's reward model.
- Preference pairs after filtering
- 7,118 (6,766 train, 352 validation)
- Preference options
- 7 (-3 to -1, 1 to 3, and -100 for neither valid)
- Annotators per task
- 3 to 5
- Agreement on raw preferences (quadratic-weighted kappa)
- 0.489, rising to 0.843 after filtering
- Licence
- CC BY 4.0
Configuration File
This Potato config reproduces the annotation task. Save it as config.yaml and run potato start config.yaml to try it.
# HelpSteer2-Preference: seven-point preference strength for reward-model training
#
# Dataset: HelpSteer2 (preference subset), NVIDIA, annotated through Scale AI
# Paper: Wang et al., "HelpSteer2-Preference: Complementing Ratings with
# Preferences", arXiv 2410.01257 (2024); also an ICLR 2025 poster
# BibTeX (from the registry response, reformatted):
# @misc{wang2024helpsteer2preference,
# author = {Wang, Zhilin and Bukharin, Alexander and Delalleau, Olivier and Egert, Daniel and Shen, Gerald and Zeng, Jiaqi and Kuchaiev, Oleksii and Dong, Yi},
# title = {HelpSteer2-Preference: Complementing Ratings with Preferences},
# publisher = {arXiv},
# year = {2024},
# doi = {10.48550/ARXIV.2410.01257},
# url = {https://arxiv.org/abs/2410.01257}
# }
# DOI: 10.48550/arXiv.2410.01257
# Dataset URL: https://huggingface.co/datasets/nvidia/HelpSteer2
# Licence: CC BY 4.0. The ten sample items are real rows from
# preference/preference.jsonl.gz (train split), with their released
# preference strength kept in `released_preference_strength`.
#
# Preference scale, quoted from the paper (Section 2, Data Collection):
# -3. Response 1 is much better than Response 2
# -2. Response 1 is better than Response 2
# -1. Response 1 is slightly better than Response 2
# 1. Response 2 is slightly better than Response 1
# 2. Response 2 is better than Response 1
# 3. Response 2 is much better than Response 1
# -100. Neither response is valid
# "we force the annotator to make a preference choice between the two
# responses (i.e. no option for Both responses are equally good), except for
# 'Neither response is valid'".
#
# Adaptations:
# - The paper's annotators first rate each response on five Likert-5
# dimensions (helpfulness, correctness, coherence, complexity, verbosity).
# This design keeps only the preference, the "neither valid" flag and the
# written justification.
# - "Neither response is valid" (-100) is a separate radio scheme, because a
# pairwise scale stores one number on the -3 to 3 range.
# - Potato's scale slider starts on 0 and cannot exclude it, so the paper's
# rule that 0 is not an answer is stated in the instructions and is not
# enforced by the interface.
# - The paper's justification asks for a preference statement and an
# elaboration. This design offers one free-text box.
# - Sample items are single-turn rows only, and `released_preference_strength`
# (the paper's aggregate over the three most similar annotators) is stored
# beside each item for comparison and is not shown to annotators.
#
# Model training: the `reward-model` trainer (Bradley-Terry loss,
# -log sigmoid(r_winner - r_loser)) fits a scalar reward model on the
# pairwise scale answers. The side the slider leans toward wins, weighted by
# |value| / 3, and answers at 0 are skipped. Each reward is of the response
# given the item's `prompt`. Open /admin/training with the admin key below,
# pick `reward-model` and the `preference_strength` scheme, and install
# `pip install 'potato-annotation[train-text]'` first. The default encoder is
# distilbert/distilroberta-base. The trainer learns from the labels collected
# here. It does not reproduce the paper's reward model, which was trained on
# the full released dataset with a much larger base model, and it does not
# serve or deploy a model. Predictions come back as a prelabel on the scale.
annotation_task_name: "HelpSteer2-Preference: preference strength between two responses"
task_dir: "."
data_files:
- sample-data.json
item_properties:
id_key: id
text_key: prompt
output_annotation_dir: "annotation_output/"
export_annotation_format: jsonl
# Admin key for /admin/training (the reward-model run).
admin_api_key: "demo-admin-key"
# The paper asked the vendor for 3-5 independent annotators per task.
num_annotators_per_item: 3
annotation_schemes:
- annotation_type: pairwise
name: preference_strength
description: "Which response is better, and by how much? Choose a side even when the difference is small."
mode: scale
items_key: responses
show_labels: true
labels:
- "Response 1"
- "Response 2"
scale:
min: -3
max: 3
step: 1
default: 0
labels:
min: "much better"
max: "much better"
center: "0 is not an allowed answer"
label_requirement:
required: true
- annotation_type: radio
name: validity
description: "Is at least one response valid? Choose the second option only when both are so bad that picking a winner is pointless."
labels:
- "At least one response is valid"
- "Neither response is valid"
- annotation_type: text
name: justification
description: "Explain your preference. Say which response is better and why, with reference to the prompt."
multiline: true
rows: 4
cols: 60
min_chars: 20
placeholder: "Response 2 is better than Response 1 because ..."
model_training:
enabled: true
writeback:
schemas: ["preference_strength"]
include_unlabeled: true
min_confidence: 0.6
user_config:
allow_all_users: true
annotation_instructions: |
## Compare two responses to one prompt
Read the prompt, then both responses. Use the slider to say which response
is better and by how much.
| Value | Meaning |
|---|---|
| -3 | Response 1 is much better than Response 2 |
| -2 | Response 1 is better than Response 2 |
| -1 | Response 1 is slightly better than Response 2 |
| 1 | Response 2 is slightly better than Response 1 |
| 2 | Response 2 is better than Response 1 |
| 3 | Response 2 is much better than Response 1 |
There is no "equal" answer. Leave the slider off 0 and look closer at the
differences, even when they seem minor. If both responses are so bad that
picking a winner is pointless, choose "Neither response is valid".
Write a short justification that names the better response and the reason.
Sample Data
[
{
"id": "hs2p_001",
"prompt": "In less than 100 words, tell when Nikola Tesla invented the Special Theory of Relativity.",
"responses": [
"The special theory of relativity was not invented by Nikola Tesla. The special theory of relativity was invented by Albert Einstein in 1905. Einstein published the theory in a paper titled \"On the Electrodynamics of Moving Bodies,\" which was presented in the Annalen der Physik Journal in 1905.",
"The Special Theory of Relativity was invented by Nikola Tesla in 1905. This theory states that the laws of physics are the same for all observers, regardless of their relative motion. It also introduced the concept of a universal speed limit, which is the speed of light. This theory has been proven accurate through numerous experiments and is a fundamental principle of modern physics."
],
"released_preference_strength": -3
},
{
"id": "hs2p_002",
"prompt": "Write a brief about what function the method LinearRegression().fit() performs.",
"responses": [
"So you want me to explain what the LinearRegression().fit() function does, huh? Well, it fits a straight line to your data, that's what it does! It takes your data points and finds the best possible line that fits them all. It's like fitting a square peg into a round hole, except with data and lines. So if you've got some data that you want to analyze, you better make sure you use LinearRegression().fit() or else you'll be up a creek without a paddle!",
"The `LinearRegression().fit()` function in machine learning libraries like scikit-learn is used to train a linear regression model. This function takes in the training data (features and target variable) and calculates the best-fitting linear relationship between them. It does this by finding the values of the coefficients (weights) that minimize the mean squared error (MSE) between the predicted and actual target values. The `fit()` function adjusts these coefficients iteratively until it finds the optimal values, at which point the model is considered trained and ready to make predictions on new data."
],
"released_preference_strength": 3
}
]
// ... and 8 more itemsTry it live — no install
Boot the real Potato server in your browser (WebAssembly) and annotate with this exact config. Nothing leaves your machine.
Run live in your browserGet This Design
Clone or download from the repository
Quick start:
git clone https://github.com/davidjurgens/potato-showcase.git
cd potato-showcase/preference-learning/helpsteer2-preference-reward-model
potato start config.yamlDataset & paper
Wang et al., arXiv 2024
- Paper DOI
- 10.48550/arXiv.2410.01257
Citation (BibTeX)
@misc{wang2024helpsteer2preference,
author = {Wang, Zhilin and Bukharin, Alexander and Delalleau, Olivier and Egert, Daniel and Shen, Gerald and Zeng, Jiaqi and Kuchaiev, Oleksii and Dong, Yi},
title = {HelpSteer2-Preference: Complementing Ratings with Preferences},
publisher = {arXiv},
year = {2024},
doi = {10.48550/ARXIV.2410.01257},
url = {https://arxiv.org/abs/2410.01257}
}Details
Annotation Types
Domain
Use Cases
Tags
Found an issue or want to improve this design?
Open an Issue(opens in a new tab)Related Designs
DPO Preference Data Collection
Pairwise preference annotation for Direct Preference Optimization, based on Rafailov et al., NeurIPS 2023. Annotators compare two model responses to a prompt, select a preference, rate alignment dimensions, and provide reasoning.
Pairwise Preference with Rationale
Compare two AI responses and select the better one while providing a written justification. Used for reward model training with interpretable preference signals.
SPIN Self-Play Preference Annotation
Human vs. AI response discrimination for Self-Play Fine-Tuning, based on Chen et al., ICML 2024. Annotators identify which of two responses was written by a human versus an AI model, and rate the fluency of both responses.