Skip to content
intermediatepreference

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 browser

Get This Design

View on GitHub(opens in a new tab)

Clone or download from the repository

Quick start:

bash
git clone https://github.com/davidjurgens/potato-showcase.git
cd potato-showcase/preference-learning/helpsteer2-preference-reward-model
potato start config.yaml

About 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.

yaml
# 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

json
[
  {
    "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 items

Dataset & paper

Wang et al., arXiv 2024

Paper DOI
10.48550/arXiv.2410.01257

Citation (BibTeX)

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

pairwiseradiotext

Domain

NLPAI Alignment

Use Cases

Reward ModelingRLHFPreference Learning

Tags

helpsteer2helpsteer2-preferencereward modelbradley-terrypreference strengthrlhfpairwise

Found an issue or want to improve this design?

Open an Issue(opens in a new tab)