Seeing Eye to AI: Human Alignment via Gaze-Based Response Rewards for Large Language Models

## Abstract

Abstract Advancements in Natural Language Processing (NLP), have led to the emergence of Large Language Models (LLMs) such as GPT, Llama, Claude, and Gemini, which excel across a range of tasks but require extensive fine-tuning to align their outputs with human expectations. A widely used method for achieving this alignment is Reinforcement Learning from Human Feedback (RLHF), which, despite its success, faces challenges in accurately modelling human preferences. In this paper, we introduce GazeReward, a novel framework that integrates implicit feedback – and specifically eye-tracking (ET) data – into the Reward Model (RM). In addition, we explore how ET-based features can provide insights into user preferences. Through ablation studies we test our framework with different integration methods, LLMs, and ET generator models, demonstrating that our approach significantly improves the accuracy of the RM on established human preference datasets. This work advances the ongoing discussion on optimizing AI alignment with human values, exploring the potential of cognitive data for shaping future NLP research.

## 1 Introduction

Recent advancements in Natural Language Processing (NLP)have led to the emergence of Large Language Models (LLMs)like GPT (OpenAI, ), Llama (Dubey et al., ), Claude (Anthropic, ), and Gemini (Team et al., ), which excel across a range of tasks.
These models, often consisting of billions of parameters, are trained on massive datasets and typically require extensive fine-tuning to align their outputs with human expectations (^1^11LLMs that are trained only on extensive datasets for language modeling are referred to as “pre-trained” LLMs. Subsequent approaches, such as human alignment, are categorized as “post-training”.). Several works have focused on refining the way LLMs interpret and respond to user intent (Wang et al., ), which has led to the development of novel alignment techniques.
A common approach to achieving human alignment involves leveraging explicit human feedback as preference information. Currently, the most widely adopted method is Reinforcement Learning from Human Feedback (RLHF)(Ouyang et al., ). RLHF has been implemented in many state-of-the-art LLMs (Cui et al., ; OpenAI, ; Bai et al., ), and has been shown to help align models to human instructions and mitigate the generation of toxic or harmful content (Kiegeland et al., ). However, a persistent challenge with this approach is the difficulty of acquiring sufficient high-quality training data (Casper et al., ).

To be able to capture the complexities of real-world user instructions, there is a need for meticulously handcrafted data (Wang et al., ), which are resource-expensive and difficult to scale (Yang et al., ). Obtaining high-quality feedback from human annotators, usually provided after examining a model response, suffers from several caveats (Casper et al., ). For instance, low inter-annotator agreement can result in inconsistent evaluations of the same model output due to varying interpretations, domain expertise, or biases. Moreover, “scalable oversight” – the ability to supervise models effectively with limited resources (Amodei et al., ) – remains an open problem. Inconsistent data quality is another issue, as cost-quality tradeoffs often arise when collecting human feedback.

To address these challenges, researchers have
increasingly turned to LLMs as a form of AI-driven feedback, referred to as Reinforcement Learning from AI Feedback (RLAIF)Bai et al. (). This method offers improved scalability, easier data collection, and cost-efficiency compared to traditional human-driven approaches (Bai et al., ; Wang et al., ; Madaan et al., ). However, it remains unclear what type of feedback signals, or a combination of feedback mechanisms, is optimal to align LLM with human goals (Casper et al., ). More research is needed to explore the underlying beliefs and expectations of human users (Casper et al., ), and how these can be incorporated into human alignment techniques. Furthermore, the alignment success of a language model is dependent on the quality of the underlying RM (Pace et al., ). Various alignment methods, such as RLHF, RLAIF, and Direct Preference Optimization (DPO)(Rafailov et al., ),
rely on RM to incorporate feedback. Reward modelling is also essential for generating synthetic data for preference alignment and is often used in LLM inference to evaluate model outputs in techniques such as best-of-N sampling (Cui et al., ).

In this work, we propose a novel approach that incorporates Eye-tracking (ET)as an additional signal to address the challenge of human alignment. ET measures oculomotor behavior i.e. the movements and fixations of the eyes, which offers insight into visual attention and information processing (Kleinke, ; Land and Furneaux, ). This allows researchers to correlate observable eye movement patterns with underlying cognitive and perceptual processes during reading and language comprehension tasks (Kleinke, ; Krasich et al., ). Moreover, ET– unlike other (explicit) forms of feedback (e.g., questionnaire data, data annotation) – does not suffer from human biases, and offers a better temporal and spatial resolution (Zhang and Hollenstein, ).
Several studies have shown a strong correlation between human eye movements and attention patterns in transformer-based models (Wang et al., ; Bensemann et al., ; Sood et al., ). Incorporating ET data into NLP tasks has also proven valuable, as demonstrated by numerous works (Huang et al., ; Khurana et al., ; Hollenstein et al., ; Yang and Hollenstein, ; Kiegeland et al., ; Deng et al., ; Mathias et al., ; McGuire and Tomuro, ). Recently, Kiegeland et al. () proposed the integration of ET in controlled sentiment generation to create a dataset that can be used in human alignment methods.

Figure: Figure 1: GazeReward Framework for using eye-tracking data for reward modelling. We use a generator model to compute ET features on a preference dataset $D$ and we train the human preference by combining both text and ET embeddings (See section 3 for details.)
Refer to caption: x1.png

Human alignment continues to be one of the biggest challenges in the development of LLM, with RM playing an important role in addressing this issue. This paper investigates how behavioural signals, particularly ET, can be operationalised as implicit feedback to improve human alignment (the proposed approach is shown in Figure 1). Furthermore, we explore the use of ET prediction models that can generate – automatically and with little effort – ET features in response to text input, which makes our solution not only cost-effective but also highly scalable.
The main contributions of our work can be summarized as follows:

- •
We propose GazeReward, a novel and scalable framework that integrates implicit feedback in the form of ET data into the RM, a key component in modeling human preferences.
- •
We perform for the first time an ablation study that examines several state-of-the-art LLMs, various ET prediction models, and different methods for incorporating ET features into the RM.
- •
We demonstrate experimentally substantial performance improvements with the GazeReward framework, showing accuracy gains of over 20% in RM predictions across diverse human preference datasets.

## 2 Preliminaries

### 2.1 Large Language Models -Human Alignment

LLMs-Human Alignment typically involves training LLMs (^2^22Before the process of human alignment, these models are referred to as “pre-trained” LLMs.) on datasets curated by humans (learning from human feedback data) (Ouyang et al., ). This can be achieved through Supervised Fine-Tuning (SFT), where the model is trained on pairs of prompts ($x$) and corresponding human-generated responses ($y$) (Liu et al., ). Alternatively, alignment can be pursued via preference optimization, using a human preference dataset that differentiates between a better response ($y_{w}$) and a worse one ($y_{l}$) for the same prompt ($x$): $\mathcal{D}=\{(x^{(i)},y_{w}^{(i)},y_{l}^{(i)})\}_{i=1}^{N}$.

To this day, RLHF (Ouyang et al., ) remains the most popular technique used in state-of-the-art LLMs like GPT-4 (OpenAI, ), Claude (Bai et al., ), Bard (Google, ), and Llama 2-Chat (Touvron et al., ). Different implementations of RLHF can vary in terms of data collection, training processes, and choice of RL algorithms. Typically, RLHF (Ouyang et al., ) involves three main steps: (1) collecting feedback, (2) training a RM based on that feedback, and (3) optimising the LLMs using RL techniques, such as Proximal Policy Optimization (PPO)Schulman et al. (). Since RLHF was first introduced, several advancements have been made, including fine-grained reward systems (Bai et al., ; Wu et al., ; Dong et al., ; Wang et al., , ), or replaced the original PPO algorithm with other RL techniques (Wu et al., ).

An alternative to RLHF is DPO (Rafailov et al., ), which employs an offline RL approach to optimize language models based on preference data, without the need for a separate reward model. While DPO can be used independently, it is often complementary to other training methods such as SFT or statistical rejection sampling, to further improve human alignment based on a RM (Zhao et al., ; Liu et al., ; Dubey et al., ). Statistical rejection sampling, also called best-of-N or top-k-over-N (Bai et al., ; Touvron et al., ; Dubey et al., ) is another widely used technique. Moreover, certain methods perform human alignment without RL to avoid instabilities, and fine-tune the model on filtered samples by a RM, or other sources (Dong et al., ; Yuan et al., ).

A significant challenge in all human alignment techniques is data acquisition (Casper et al., ). This includes problems such as evaluator misalignment, supervision difficulties, and feedback quality issues (Casper et al., ). However, as AI systems continue to improve, LLMs are increasingly employed for tasks that were traditionally handled by humans, such as data annotation and generation. Unlike human feedback, AI-generated feedback offers better scalability, enabling faster and more cost-effective data collection. For example, RLAIF, introduced by Bai et al. (), is a promising approach that trains reward models based on preferences generated by off-the-shelf LLMs. Variations of RLAIF have been explored in several studies (Lee et al., ; Jiao, ; Cui et al., ; Li et al., ; Yang et al., ). In the context of self-generating instructions, approaches like Self-Instruct (Wang et al., ), Self-Refine (Madaan et al., ), and Self-Alignment (Li et al., ) demonstrate how models can autonomously generate datasets based on their learned human preferences.

Different alignment methods like RLHF and RLAIF rely on the RM to incorporate the human feedback. The RM learns to predict human preference based on labeled examples, serving as a proxy for human judgment later. Therefore, the success of language model alignment relies heavily on the quality of the underlying reward model (Pace et al., ), which in turn dictates the behaviour of the resultant chatbot (Shen et al., ). Even in LLM inference, methods like best-of-N sampling use the RM to evaluate model outputs (Cui et al., ). RM has also become crucial for generating synthetic data for preference alignment. In recent RLAIF methods, reward modeling has expanded beyond its traditional role and is now used to generate artificial feedback.

#### 2.1.1 Reward modeling

In the original implementation (Ouyang et al., ), the goal of RM training is to train a classifier that predicts the probability of human preference $p^{*}$ between two completions (Equation 1), modelled by a Bradley-Terry model (Bradley and Terry, ). The typical setup involves showing two completions, with preferences being measured using win-loss-tie outcomes or a Likert scale to capture the strength of preference (Bai et al., ). The data is processed into prompt-chosen-rejected trios, where the chosen completion, $y_{w}$, is preferred over the rejected one, $y_{l}$, forming the basis for training (Ouyang et al., ).

$$ $p^{*}(y_{w}\succ y_{l}\mid x)=\frac{\exp(r^{*}(x,y_{w}))}{\exp(r^{*}(x,y_{w})) +\exp(r^{*}(x,y_{l}))}.$ (1) $$

Table: Table 1: Eye-tracking (ET)features computed per word.

### 2.2 Eye-Tracking

Eye-tracking (ET)systems monitor oculomotor behavior, such as eye movements and fixations, offering valuable insights into visual attention, information processing, and expands our understanding of reading and language comprehension. (Zhang and Hollenstein, ).
Specifically, ET data often include fixations – pauses in eye movement to focus on specific areas (Mathias et al., ); saccades – rapid movements between two points (McGuire and Tomuro, ); scanpaths – sequences of fixations that reveal saccades and regressions (Yang and Hollenstein, ); and other temporal and spatial gaze behavior features (Zhang and Hollenstein, ). Incorporating ET data into NLP tasks often involves the use of several features listed in Table 1.

While several publicly available datasets such as ZUCO (Hollenstein et al., ), ZUCO2 (Hollenstein et al., ), PROVO (Luke and Christianson, ), ETSA-I (Mishra et al., ), ETSA-II (Mishra et al., ), GECO (Cop et al., ), GECO-MT (Colman et al., ) are widely used in ET research, obtaining real ET data for NLP tasks remains a challenge. This is primarily due to the cost and precision requirements of ET equipment, the unavailability of gaze data during inference, as well as privacy concerns (Khurana et al., ). To address these challenges, two main approaches have been proposed. The first involves integrating ET data into the model during training through methods like Multi-task learning (MTL), which eliminates the need for ET data during inference (Mishra et al., ; Klerke et al., ; Ren and Xiong, ; Yu et al., ; Deng et al., ). The second approach involves techniques that directly predict users’ gaze behaviour (Deng et al., , ; Zhang and Hollenstein, ; Wang et al., ), creating synthetic ET data for any given text or stimulus (Deng et al., ; Bolliger et al., ; Khurana et al., ; Li and Rudzicz, ; Hollenstein et al., , ).

## 3 GazeReward: Reward modeling with ET Feedback

In this section, we discuss the proposed framework for augmenting the RM using implicit feedback derived from ET signals (Figure 2). Initially, we generate the ET features (subsection 3.1). For this step, we consider two state-of-the-art ET prediction models. Next, we combine the ET features with the text (subsection 3.2), producing different types of combined embeddings, and finally pass them as input into the RM to obtain the reward for the prompt and its corresponding response (subsection 3.3).

Figure: Figure 2: Overview of the GazeReward framework, incorporating eye-tracking features into the reward model. The architecture is illustrated in the figure using the second ET prediction model, but it would be identical if the first one were used instead (see subsection 4.1)
Refer to caption: x2.png

### 3.1 Eye-tracking features generation

As discussed insubsection 2.2, obtaining organic ET features for NLP applications presents several challenges. In this work, we consider an approach inspired by RLAIF research, where feedback is artificially generated from pre-trained LLMs and, in particular, from ET prediction models. Specifically, we incorporate the output of two different ET prediction models (Li and Rudzicz, ; Huang and Hollenstein, ) and evaluate the impact of different set of features. As input to these models, we pass the same text as we do in the RM: a combination of prompt $x$ and response $y$. The output is a set of ET features, denoted as $f_{et}$, for each token $f_{et}=\{f_{1},f_{2},\dots,f_{w}\}\in\mathbb{R}^{w\times f}$, where $w$ represents the number of tokens in the tokenizer used by the ET prediction model, and $f$ is the number of features. Depending on the specific model, between one and five synthetic features $f_{et}=\{f_{1},f_{2},\dots,f_{w}\}\in\mathbb{R}^{w\times f}$ are generated per token for the input text.

### 3.2 RM augmentation using eye-tracking features

We implement two different approaches for incorporating ET features into the RM, as shown in Figure 2. In the first approach, GazeConcat, we concatenate the ET embeddings with the text embeddings. In the second approach, GazeAdd, we add the ET embeddings to the text embeddings. Furthermore, we concatenate the prompt and the response to be evaluated and pass them through the pre-trained embedding layer of RM, to generate the embeddings $H=\{h_{1},h_{2},\dots,h_{n}\}\in\mathbb{R}^{n\times d}$, where $n$ is the number of tokens in the tokenizer used by the RM and $d$ is the model embedding size.

To project these features to the model embedding size ($d$), we use a Multilayer Perceptron (MLP)ET feature projector $fp()$. The $fp()$ consists of two linear layers, two dropout layers, two Layer Normalization layers, and ReLU activation, designed for stable, non-linear ET feature representation and overfitting prevention. The model’s input dimension dynamically adjusts to accommodate the number of features used during training. The ET features projector can be formulated as $emb_{ETF}=fp(f_{et})\in\mathbb{R}^{w\times d}$ (Figure 2). This formula describes the projection of ETF features ($f_{et}$) through a function $fp$, resulting in an embedding matrix $emb_{ETF}$ with dimensions $w\times d$, where $w$ represents the number of time steps and $d$ the embedding dimension.

GazeConcat:
The ET embedding, denoted as $emb_{ETF}$, is concatenated with the text embedding $H$ to form the input for the RM. To distinguish between the two modalities, we introduce two special tokens: ⟨eye⟩ and ⟨/eye⟩, which flag the start and end of the ET embedding, respectively (Figure 2). These special tokens are randomly initialized as one-dimensional vectors and added to the embedding layer or the RM model for training. The final input is structured as: $(emb(\textlangle eye\textrangle)\circ emb_{ETF}\circ emb(\textlangle/eye
\textrangle)\circ H)$. The same process is applied to the attentions masks.

GazeAdd:
The input to the RM consists of the ET embedding $emb_{ETF}$ and the text embedding $H$, which are added in an elementwise fashion: $(emb_{ETF}+H)$. The two ET prediction models use different tokenizers, which also differ from those used by the base models in the RM. As a result, the number of tokens $n$ in the input for the RM and the number of tokens $w$ generated by the ET prediction model may not match. To address this embedding alignment issue, and have the same dimension, we remap the ET features from the $w$-token space to the $n$-token space used by each base model in the RM. Further implementation details can be found in Appendix A.1.3.

**Table 2: Overview of different corpora used in the study to train the reward model.**
| Corpus | Train set | Val. set | Test set | Lang. | Reference |
| --- | --- | --- | --- | --- | --- |
| OASST1 | 6567 | 1160 | 416 | EN^∗ | Köpf et al. () |
| HelpSteer2 | 5938 | 1049 | 364 | EN | Wang et al. () |

### 3.3 Reward Model

The RM’s architecture and hyperparameters are identical to those of the pretrained LLM, except that the classification head used for next-token prediction is replaced with a regression head that outputs a scalar reward (Touvron et al., ). This scalar reward indicates the quality of the model generation, corresponding to the predicted score for the final reply in a conversation. Differences in these rewards represent the log-odds that one response is preferred over another. The loss function is defined in Equation 2, where $y_{w}$ refers to the preferred response in a pair of completions $y_{w}$ and $y_{l}$. The dataset $D$ consists of human comparisons, where $r_{\theta}\left(x,y_{w}\right),r_{\theta}\left(x,y_{l}\right)$ represents the RM $\theta$ scalar outputs for the preferred and less preferred completions, respectively Ouyang et al. ().

$$ $\operatorname{loss}(\theta)=-E_{\left(x,y_{w},y_{l}\right)\sim D}\left[\log \left(\sigma\left(r_{\theta}\left(x,y_{w}\right)-r_{\theta}\left(x,y_{l}\right )\right)\right)\right]$ (2) $$

In the proposed method, we augment the traditional RM, which uses text input (a combination of the prompt $x$ and response $y$), by incorporating (artificial) implicit feedback through ET features generated from the same text. These ET features provide valuable information for capturing human preferences, thereby improving the RM’s performance.

## 4 Experiments

### 4.1 Experimental setup

Datasets.
For our experiments, we use the OpenAssistant Conversations dataset’s (OASST1) (Köpf et al., ) and HelpSteer2 (Wang et al., ) ( Table 2). OASST1 is a human-generated, human-annotated, assistant-style conversation, created through global crowdsourcing and widely used for human alignment tasks (Köpf et al., ; Dettmers et al., ; Wu et al., ). We filtered all non-English text, as the ET prediction models were exclusively trained on English data. Among the different responses in the dataset, we selected the two most distinct responses to compare the chosen and the rejected responses (Wang et al., ). HelpSteer2 is a more recent, English-only dataset that has been used in studies such as Wang et al. (, ). The dataset provides annotations for five response attributes: helpfulness, correctness, coherence, complexity, and verbosity. To transform it into a preference dataset, we designate the response with the higher helpfulness score as the chosen response and the other as the rejected response, following a method similar to that used in DPO training (Wang et al., ) (see Appendix A.1.1 for more details about the datasets).

Dataset Preparation.
To tune LLMs for human-AI interaction, we need to define a chat dialogue protocol that allows the model to understand human instructions and rate them. To this end, we adopt a chat protocol that utilizes special header and termination tokens, similar to the format used in Llama 3. For example, in the case of the Llama 3 8B model, the concatenation of a prompt and its corresponding response would follow this structure: <im_start>user Example Prompt <im_end> <im_start>assistant Example Response <im_end> (see Appendix A.1.1 for more details).

Models.
As RM base models we use the pretrained checkpoint of Hugging Face for Llama 3 8B (^3^33[https://huggingface.co/meta-llama/Meta-Llama-3-8B](https://huggingface.co/meta-llama/Meta-Llama-3-8B)) (Dubey et al., ), Llama 3 8B-instruct (^4^44[meta-llama/Meta-Llama-3-8B-Instruct](meta-llama/Meta-Llama-3-8B-Instruct))(Dubey et al., ) and Mistral 7B (^5^55[https://huggingface.co/mistralai/Mistral-7B-v0.3](https://huggingface.co/mistralai/Mistral-7B-v0.3)) (Jiang et al., ).

ET prediction models.
In our analyses, we utilise two state-of-the-art ET prediction models, both pre-trained to predict ET features and kept frozen in our implementation. The input to these models is the same text used for the RM, with minimal modifications (Appendix A.1.2). The first model (Huang and Hollenstein, ), consists of a T5 embedding layer (Raffel et al., ), a two-layer BiLSTM (Hochreiter and Schmidhuber, ), and a one-hidden-layer MLP. This model was trained on the Dundee, GECO (Cop et al., ), ZuCo1 (Hollenstein et al., ), and ZuCo2 (Hollenstein et al., ) datasets, and predicts total reading time (TRT) per token (Figure 3). The second model (Li and Rudzicz, ), is based on RoBERTa (Liu et al., ) with a regression head on each token. This head is a linear layer that outputs five features: FFD, fixProp, GPT, TRT, and nFix (Table 1). The model is initialized with pre-trained weights and fine-tuned on the ZuCo1 (Hollenstein et al., ), ZuCo2 (Hollenstein et al., ) and PROVO (Luke and Christianson, ) datasets. Since RoBERTa’s maximum sequence length is 512 tokens and our input sequences are longer, we employ a sliding window approach. The input is split into 512-token segments with a 50-token overlap, and the results are combined using a linear weighted approach. Further details on these models and their integration into our framework are provided in Appendix A.1.2.

Baseline models.
To evaluate the improvement in accuracy for a RM that incorporates implicit feedback, and specifically ET signals, we compare the same RM with and without the ET embeddings. For each dataset and model, we train and evaluate all combinations of integrating and combining ET features, and then compare them against a RM trained on the same base model and dataset but without implicit feedback.

Evaluation metrics.
Performance is determined by measuring the model’s ability to predict the better reponse from pairs of replies with different ranks. Accuracy is calculated as the percentage of cases where the reward score for the preferred response is higher than that of the less preferred response, based on a held-out dataset. This method follows similar approaches found in Touvron et al. (); Yuan et al. (); Köpf et al. (); Cui et al. (). We use the test split proposed by the authors for each dataset (Table 2). We also conduct a complementary evaluation on RewardBench (Lambert et al., ), a benchmark dataset created for evaluating performance and safety features of RM’s (see Appendix B for more details).

Training procedure.

In our implementetion, the ET prediction model remains frozen while the ET features projector is trained (Figure 2). For the RM, we fine-tune the open-source models previously introduced with QLoRA (Dettmers et al., ) a Parameter-Efficient Fine-Tuning (PEFT)method based on Low-Rank Adaptation (LoRA)(Hu et al., ), with other memory optimization techniques. We follow the training process for the RM as outlined in Touvron et al. (); Ouyang et al. (). We independently train each model on its respective dataset for two epochs, as detailed in Wang et al. (). For hyperparameter tuning, we reserve 15% of each dataset for validation (shown in Table 2). The best-performing checkpoints are selected based on the lowest validation loss and used for performance evaluation. We perform a grid search to determine the optimal batch size and testing values of {8, 16, 32}. The AdamW optimizer (Loshchilov and Hutter, ) is used, with the Learning Rate (LR)is tuned over the range {1, 5, 10, 50}e-6, following the values reported in Touvron et al. (); Cui et al. (); Wang et al. (). Additionally, we evaluate different LR schedulers: constant, linear, and cosine with a minimum LR. Further hyperparameter values and implementation details for both the RM and the ET projector can be found in Appendix C.

### 4.2 Results

The results of our experiments on the OASST and HelpSteer datasets, covering all possible combinations of ET features, models, and inclusion methods, as shown in Table 3 and Table 4 respectively. For the Mistral model, results for the GazeAdd method are unavailable due to the inability to map features between the ET prediction model’s tokenizer and the reward model’s tokenizer (details in Appendix A.1.3). In what follows, we discuss the main findings.

**Table 3: Reward modeling accuracy (%) for OASST1 dataset. The highest results are in bold and the second highest are underlined.**
|  |  | Llama-3-8B-Instruct | Llama-3-8B | Mistral-7B |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  | baseline | 64.6 | diff(%) | 58.6 | diff(%) | 62.0 | diff(%) |
| GazeConcat | $fcomb_{1}$ | 68.5 | 6.1% | 68.5 | 17.0% | 63.9 | 3.1% |
| $fcomb_{2.5}$ | 70.7 | 9.4% | 70.4 | 20.3% | 71.2 | 14.7% |  |
| $fcomb_{2.2}$ | 68.5 | 6.1% | 73.1 | 24.8% | 72.6 | 17.1% |  |
| GazeAdd | $fcomb_{1}$ | 70.9 | 9.8% | 71.2 | 21.5% | - |  |
| $fcomb_{2.5}$ | 51.9 | -19.6% | 54.3 | -7.2% | - |  |  |
| $fcomb_{2.2}$ | 70.0 | 8.3% | 69.0 | 17.8% | - |  |  |

**Table 4: Reward modeling accuracy (%) for Helpsteer2 dataset. The highest results are in bold and the second highest are underlined.**
|  |  | Llama-3-8B-Instruct | Llama-3-8B | Mistral-7B |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  | baseline | 54.3 | diff(%) | 53.2 | diff(%) | 51.2535 | diff(%) |
| GazeConcat | $fcomb_{1}$ | 62.8 | 15.7% | 59.6 | 12.0% | 63.3 | 23.6% |
| $fcomb_{2.5}$ | 59.9 | 10.3% | 53.3 | 0.2% | 53.0 | 3.5% |  |
| $fcomb_{2.2}$ | 59.3 | 9.2% | 53.3 | 0.2% | 57.1 | 11.5% |  |
| GazeAdd | $fcomb_{1}$ | 63.2 | 16.3% | 64.6 | 21.3% | - |  |
| $fcomb_{2.5}$ | 59.9 | 10.3% | 58.8 | 10.5% | - |  |  |
| $fcomb_{2.2}$ | 59.1 | 8.7% | 59.6 | 12.1% | - |  |  |

Effect of Model Initialization.
We evaluate the impact of model initialization on performance. Open-access LLMs typically come in two forms: a pre-trained version without human alignment and a final version that has undergone alignment with human feedback. Since we lack access to intermediate checkpoints, we experiment with both pre-trained models (Mistral 7B and Llama 3) and models that are already human-aligned (Llama 3 Instruct). Our goal is to confirm that our method is effective for RM initialized with both pre-trained and human-aligned checkpoints. When comparing accuracy improvements relative to the baseline (without ET features), all models show considerable gains from incorporating implicit feedback. Notably, the Llama 3 8B and Mistral 7B models, which had no prior alignment, demonstrate over 20% performance improvement from the incorporation of ET features, indicating that unaligned models benefit more from implicit feedback.

Inclusion method.
The results shown Table 3 and Table 4 indicate that both GazeConcat methods and GazeAdd introduce a substantial performance improvements to the RM. Across both datasets, concatenating embeddings (GazeConcat) delivers more consistent results. Incorporating ET information through specialized separator embeddings allows the model to process both text and ET features more robustly. However, in the HelpSteer dataset (Table 4), directly adding ET information to the text embeddings (GazeAdd) results in the greatest improvement over the baseline.

Eye-tracking (ET)feature importance.
Different ET features capture distinct aspects of reading behaviour and information processing, influencing model performance uniquely (Zhang and Hollenstein, ). Here, we examine how model performance varies when incorporating three different feature combinations generated by two different ET prediction models: $fcomb_{1}$ – TRT generated by the first ET prediction model; $fcomb_{2.5}$ – five features (nFix, FFD, GPT, TRT, fixProp) generated by the second ET prediction model; and $fcomb_{2.2}$ – TRT and FFD generated by the second ET prediction model. TRT and FFD are widely used in ET research (Huang et al., ; Huang and Hollenstein, ; Zhang and Hollenstein, ; Maharaj et al., ; Wang et al., ), and they have been shown to correlate with attention scores from pre-trained transformer models (Wang et al., ; Bensemann et al., ; Sood et al., ). Other studies have used gradient-based saliency methods to explore similar correlations (Hollenstein and Beinborn, ; Wu et al., ). When comparing results, we observe that the RM benefits from implicit feedback regardless of the ET feature combination or ET prediction model used. Specifically, in most cases, $fcomb_{1}$ yields the best results, particularly with the GazeAdd method. For GazeConcat, $fcomb_{2.2}$ performs best for the OASST1 dataset, while $fcomb_{1}$ excels in HelpSteer2. We attribute the superior performance of $fcomb_{1}$ to how the ET prediction model generating the fixations was trained, including the data and preprocessing methods used (see Appendix A.1.2). Moreover, when comparing $fcomb_{2.2}$ and $fcomb_{2.5}$ – both generated by the same model – only in one case does integrating nFix, GPT, and fixProp improves performance. In some instances, using $fcomb_{2.5}$ results in worse performance than the baseline, confirming findings provided by prior studies, which suggest that features related to reading time, such as FFD and TRT, contribute most to performance gains.

RewardBench.
As a side contribution, we evaluate our best performing models (trained on the OAAST1 dataset) on RewardBench. This evaluation is not intended to directly compare our method with larger, more resource-intensive RM, but rather to show that through the integration of multimodal signals like ET features we can significantly enhance the performance of RM models.
The results shown in Table 5 demonstrate consistent improvements as previously observed, with gains exceeding 40% for the Mistral model – a notable gain considering that the base RM is the same.
We note that the performance of the baseline models is impacted by RM trained on base models with less than 9B parameters and on relatively small datasets (see details in Appendix B).

**Table 5: Reward modeling accuracy (%) evaluating on RewardBench dataset. All models are trained on OASST1 dataset. The highest results are in bold and the second highest are underlined.**
|  |  | Llama-3-8B-Instruct | Llama-3-8B | Mistral-7B |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  | baseline | 46.9 | diff(%) | 50.9 | diff(%) | 41.2 | diff(%) |
| GazeConcat | $fcomb_{1}$ | 57.8 | 23.1% | 58.4 | 14.5% | 59.9 | 45.4% |
| $fcomb_{2.5}$ | 58.4 | 24.4% | 58.1 | 14.1% | 60.3 | 46.4% |  |
| $fcomb_{2.2}$ | 58.1 | 23.8% | 58.5 | 14.8% | 60.5 | 46.9% |  |
| GazeAdd | $fcomb_{1}$ | 56.5 | 20.3% | 56.6 | 11.2% | - |  |
| $fcomb_{2.5}$ | 54.9 | 16.9% | 53.8 | 5.6% | - |  |  |
| $fcomb_{2.2}$ | 55.4 | 17.9% | 52.5 | 3.1% | - |  |  |

## 5 Related Work

Reward Modelling.
The most popular approach to reward modeling follows the framework introduced by Ouyang et al. (). Several studies have examined alternative versions for refining RM s. For instance, Bai et al. () proposed more fine-grained reward structures, evaluating helpfulness and harmlessness separately. Other approaches have explored different reward modelling strategies (Wu et al., ; Dong et al., ; Wang et al., ). Another line of research has focused on Process Based Reward Models (PRMs)(Lightman et al., ; Uesato et al., ) which differ from conventional RM s by predicting the correctness of intermediate steps, rather than solely evaluating final outputs. Other studies implement data augmentation techniques (Shen et al., ), or cross-attention mechanisms between encoded input text and candidate pairs (Jiang et al., ). Moreover, some works have leveraged synthetic preference data for reward modelling (Cui et al., ; Jiao, ). Wu et al. () built upon the LLM-as-a-Judge framework Zheng et al. () by introducing LLM-as-a-Meta-Judge, which evaluates the model’s judgments to generate preference pairs that enhance its decision-making capabilities. Finally, Pace et al. () incorporated a self-training approach to improve reward model training. However, to date, no research has explored the integration of ET or other implicit feedback signals into RM.

Eye-tracking in Natural Language Processing.
Several studies have investigated the use of ET data for a variety of NLP tasks, such as named entity recognition (Hollenstein and Zhang, ; Ren and Xiong, ; Yu et al., ; Hollenstein et al., ), text comprehension (Ahn et al., ; Reich et al., ; Sood et al., ), language modelling (Huang et al., ; Huang and Hollenstein, ; Deng et al., ), and question answering (Zhang and Hollenstein, ; Wang et al., ). Other applications include code comprehension (Alakmeh et al., ), code summarization (Zhang et al., ) and hallucination detection (Maharaj et al., ). Eye-tracking has also been applied to sentiment analysis and sarcasm detection tasks (Mishra et al., , , ; Barrett et al., ; Huang et al., ; Khurana et al., ; Hollenstein et al., ; Yang and Hollenstein, ; Kiegeland et al., ; Deng et al., ; Mathias et al., ; McGuire and Tomuro, ). The most relevant work to our approach is by

Kiegeland et al. (), which introduced a dataset generation method using ET signals for DPO, building on the controlled sentiment generation framework proposed by Deng et al. (); Yang and Hollenstein (). While this study has contributed to the first steps towards integrating ET for human alignment in LLMs, it is task- and dataset-specific, often relying on ranking criteria that underutilize the potential of ET feedback. In contrast, our approach presents a more general framework by directly incorporating implicit feedback into the RM, rather than limiting its application to dataset creation.

## 6 Discussion

In this work, we introduced a novel framework for integrating implicit feedback into the Reward Model, a key component for aligning LLMs and generating synthetic data for further alignment. We validated our approach using widely-adopted, open-source models such as Llama 3 and Mistral, for initializing the RM. By employing two different models to generate ET features, our results show that incorporating implicit feedback consistently improves the RM’s ability to predict user preferences, regardless of the model used and without the need to reach large parameter counts or train on massive datasets. Additionally, our method leverages ET features generated by models, making it fully scalable and applicable to various human alignment methods, including those that involve artificially generated datasets. This work advances the ongoing discussion on optimizing AI alignment with human values and shows the potential of multimodal signals for NLP research.

### 6.1 Limitations & Future Work

Data. A limitation of our study is that both ET prediction models were trained on a relatively small datasets (Appendix A.1.2) that are not tailored to our tasks. Future work could benefit from directly collecting ET data specifically for LLM-generated responses, to offer insights into human reading comprehension and information processing of prompts, which could further improve model performance. Additionally, since the ET prediction models used in our experiments were trained on English corpora, the method’s generalizability to other languages requires further investigation. Moreover, we explored two methodologies for integrating ET features into the RM, but other approaches could prove more effective. For instance, ET features could be used to modify the RM ’s attention mask, as suggested by Zhang and Hollenstein (). Regarding dataset selection, both models used, Mistral 7B (Jiang et al., ) and Llama 3 (Dubey et al., ), were fine-tuned on publicly available data, though specific details on the datasets are limited. Therefore, we cannot discount the possibility that the datasets we used may have been part of the models’ pretraining, particularly for Llama 3 7B Instruct, which has already undergone human alignment. However, as we compare against baselines using the same model checkpoints, any potential effects would be consistent across both conditions.

Training.
The scaling trends for the RM (Touvron et al., ) show that larger models or models trained on massive datasets perform better. A promising direction would be to evaluate our framework on larger models, without relying on PEFT methods, and on larger datasets. However, this would incure significant computation costs. Another direction is integrating the proposed RM into an alignment method like RLHF, or applying it in rejection sampling to generate synthetic preference datasets, ensuring that accuracy gains in the RM translate to improvements in the final LLMs.

#### Reproducibility statement

All the code necessary to reproduce this work will be released in a GitHub repository once published. Both datasets used are publicly available (Köpf et al., ; Wang et al., ). Additionally, both ET prediction models have been trained with public datasets (Cop et al., ; Hollenstein et al., , ).

#### Impact Statement

Since our research uses only synthetic ET data, there are no privacy concerns or need for large-scale experiments involving human subjects.

## Appendix A Appendix

### A.1 Implementation details

This section provides further details on the implementation of our method. Subsection A.1.1 provides more details on the datasets used and their preprocessing steps. In subsection A.1.2, further information is given about the models used for generating ET features, along with the specific preprocessing required for each. Subsection A.1.3 explains the process of mapping the fixations from the tokenizer used by the generation model to the tokenizer used by the Reward Model. Finally, additional implementation details are discussed in subsection A.1.4.

#### A.1.1 Dataset processing

In this subsection, we provide more details about the datasets used and the preprocessing to train the RM. We use two different datasets: OpenAssistant Conversations dataset’s (OASST1) (^6^66[https://huggingface.co/datasets/OpenAssistant/oasst1](https://huggingface.co/datasets/OpenAssistant/oasst1)) [Köpf et al., ] and HelpSteer2 (^7^77[https://huggingface.co/datasets/nvidia/HelpSteer2](https://huggingface.co/datasets/nvidia/HelpSteer2)) [Wang et al., ].

OASST1. A human-generated, human-annotated assistant-style conversation corpus consisting of 161,443 messages in 35 different languages, resulting in over 10,000 complete and fully annotated conversation trees. The basic data structure is a Conversation Tree (CT), with nodes representing written messages in a conversation. A CT ’s root node represents an initial prompt, given by the prompter. The data was collected using a web-app interface as a product of a worldwide crowd-sourcing effort involving over 13,500 volunteers, dividing the collection of each tree into five separate steps: prompting, labelling prompts, adding reply messages as prompter or assistant, labelling replies, and ranking assistant replies.

HelpSteer2. A CC-BY-4.0-licensed open-source helpfulness dataset, designed to train state-of-the-art RM consisting on 10,000 response pairs. It collects prompts mainly from ShareGPT (^8^88[https://huggingface.co/datasets/RyokoAI/ShareGPT52K](https://huggingface.co/datasets/RyokoAI/ShareGPT52K)), focusing on user inputs and filtering out non-English and programming-related prompts for quality. The prompts are clustered into topics and sampled based on complexity to ensure diversity. Multi-turn prompts are generated using an in-house model, with responses sourced from various internal models and human annotators. For each response, they annotate five attributes (helpfulness, correctness, coherence, complexity, and verbosity) on a Likert-5 scale involving multiple annotators for each response, ensuring high-quality ratings across five attributes.

Conversation format and dataset preparation.
To fine-tune LLMs for human-AI interaction, we need to define a chat protocol. We use a multi-message chat setup with a special header and termination tokens, similar to the one in Llama 3 Dubey et al. []. The header tokens differentiate the turns between the user and the system. For this, we use the apply_chat_template(^9^99[https://huggingface.co/docs/transformers/main/en/chat_templating](https://huggingface.co/docs/transformers/main/en/chat_templating)) feature from FastTokenizers in the transformers library.

The tokenizer used by the Meta-Llama-3-8B-Instruct model already incorporates this chat format since this model has already undergone human alignment. Therefore, we use this format in our experiments. For the other two models, we employ the default chat format provided by their respective tokenizers. We add new tokens in the embeddings layer for these chat formats and we train them as part of our process. Below, we provide an example of the template for each model.

- •
Meta-Llama-3-8B-Instruct:
<begin_of_text><start_header_id>user<end_header_id> Example Prompt <eot_id><start_header_id>assistant<end_header_id> Example Response <eot_id>
- •
Meta-Llama-3-8B: <im_start>user Example Prompt <im_end> <im_start>assistant Example Response <im_end>
- •
Mistral-7B: 

 Example Prompt 
 Example Response 


#### A.1.2 Eye-tracker features generation models

Special tokens are removed from the text before it is tokenized with the corresponding tokenizer used for the ET generator model. This is done to ensure that special tokens related to the chat format are not included in the input and are not assigned ET features to them, since these tokens are just for the RM to understand the chat format.

First model: Model presented in Huang and Hollenstein []. The code for the model along with the weights is publicly available, so we used the pre-trained checkpoint and we adapted their code for our implementation. This model was trained on several eye-tracking datasets, including Dundee [Kennedy et al., ], GECO [Cop et al., ], ZuCo1 [Hollenstein et al., ], ZuCo2 [Hollenstein et al., ]. More detailed information about this datasets is presented in Table 6. In Figure 3 we show an example of the synthetic total reading time (TRT)generated for the chosen and rejected response to a prompt.

For training this model, since the fixation duration is distributed differently across corpora, the authors normalize the fixation duration for each corpus, by dividing it by the mean duration of the corpus. Moreover, they map the duration values to discrete space $[1,2,···,K]$. Using K-quantiles, the fixation values were partitioned into $K$ subsets of nearly equal sizes, and each value was assigned to the index of the corresponding subset. The model is then trained in a multi-task setting, computing the mean and variance of the fixation duration. This quartile-based processing is used in other works [Huang et al., ] that use ET data to improve performance in NLP tasks, and we believe it is part of the reason why we obtained better results with this combination when training the RM. The authors proposed a method specifically for converting word-level TRT to token-level fixation data during model training. Initially, the TRT of a word is assigned to its characters, then a small number is assigned to the last character of the word (mainly to give small values to punctuation). After tokenizing the word the span of each subword is obtained, and the maximum value in each span is taken as the final token-level fixation data.

To use this model in our setup, we need to reverse this conversion process and recompute the features from token-level back to word-level, allowing us to remap the features to a different tokenizer. This is done by summing the orignal features for all tokens corresponding to a word and then distributing them across the tokens mapped to the same word in the other tokenizer. More details of this conversion are explained in Appendix A.1.3 and an example of the process in Table 7.

Second model: Model presented in Li and Rudzicz []. The code and training data are also publicly available, so we trained it following their original methodology and we adapted their code to incorporate it into our implementation. The model was trained using the ZuCo 1 [Hollenstein et al., ] and ZuCo 2 [Hollenstein et al., ] and PROVO [Luke and Christianson, ] datasets. For the ZuCo datasets, 800 sentences (15.7 tokens) were provided as training data and 191 sentences (3.5k tokens) were held out for evaluation. Information about the datasets used to train these models is in Table 6.

In this generative model, the conversion of word-level features to token-level features during training is done by assigning the features of a word to the first token and it is assumed that the rest of the tokens of this word do not have features. We reversed this process similarly during inference by forcing the predictions for tokens that are not the first in a word to be zero. Since the maximum sequence length for RoBERTa is 512 and we are dealing with longer sequences, we implemented a sliding window approach. We split the input into sequences of 512 tokens with a 50-token overlap. After processing, we combine the results using a linear combination.

**Table 6: Overview of different corpora used to train the ET features generator models.**
| Corpus | Lang. | Sents. | Tokens | Subjects | Reference |
| --- | --- | --- | --- | --- | --- |
| Dundee | EN | 2367 | 58598 | 20 | Kennedy et al. [] |
| Provo | EN | 189 | 2659 | 84 | Luke and Christianson [] |
| ZuCo 1 | EN | 300 | 6588 | 12 | Hollenstein et al. [] |
| ZuCo 2 | EN | 349 | 6828 | 18 | Hollenstein et al. [] |
| Geco | EN* | 2449 | - | 23 | Cop et al. [] |

Figure: TRT per word in chosen response.
Refer to caption: extracted/5895889/figures/fix_1_chosen_16_TRT_plot.png

#### A.1.3 Mapping ET features between different tokenizers

Both ET features generator models used are based on different tokenizers, which are also different from the tokenizers employed by the based models used as RM. As a result, the number of tokens $n$ in the input for the reward model and the number of tokens $w$ for the ET features may not be the same. For GazeAdd, to be able to combine elementwise the ET feature embedding and the text embedding, they must have the same temporal dimensions. Therefore, we need to map the ET features per token from the ET tokenizer to the tokens of the RM tokenizer. Specifically, we convert our $f_{et}\in\mathbb{R}^{w\times f}$ ($w$ is the number of tokens, and $f$ is the number of features) to $f_{et}^{mapped}\in\mathbb{R}^{n\times f}$ where $n$ is the number of tokens in the RM input. For that. we perform a mapping between the two tokenizers to obtain the mapped features $f_{et}^{mapped}$.

To map tokens generated by two different tokenizers, we use our EyeTrackPy python library that will be publicly released. First, we perform an initial mapping of tokens to the words they belong to in each tokenizer with some properties of FastTokenizers from the transformers library (^10^1010[https://huggingface.co/docs/transformers/main_classes/tokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer)). Then, we map words from one tokenizer to the words in the other and finally, we assume that the combination of the tokens that are mapped to a word in one tokenizer correspond to the tokens that are mapped to the word that is mapped to the initial word in the other tokenizer. Each row in Table 7, refers to a step in this process.

For each predictor, we reverse the method used to convert word-level features into token-level features (more details in Appendix A.1.2) but passing from tokens in the first one, to tokens in the second tokenizer. For example, if for the first ET features predictor models tokens $t_{1},t_{2}$ are mapped to tokens $t_{1},t_{2},t_{3}$ in another second tokenizer, the values sum for all the tokens in the first list and distribute them equally across all the tokens in the second list: being $t_{1}$ (1s TRT) and $t_{2}$ (2s TRT) each of $t_{1},t_{2},t_{3}$ are assigned a TRT of $(1+2)/3=1s$. In Table 7 is represented a example of this process where row TRT(1) are the finatl TRT mapped for the fist ET predictor and TRT(2) for the second one. Finally, because special chat tokens were removed when generating the ET features, we assign value 0 0 for all features in this tokens. At the time of publishing this work, some of the tokenizer functionalities needed for alignment between tokenizers were not available in Mistral 7B.

**Table 7: Example of mapping TRT between two different tokenizers. TRT (1) represents the process used for the first ET predictor, and TRT(2) for the second ET predictor.**
|  | Tokenizer 1 | Tokenizer 2 |
| --- | --- | --- |
| Words | astrophotography | astrophotography |
| Tokens str | [’_Astro’, ’photo’, ’graphy’] | [$\dot{C}$, ’Ast’, ’roph’, ’ot’, ’ography’] |
| Tokens idx | [22, 23, 24] | [23, 24, 25, 26, 271] |
| Tokens IDs | [15001, 17720, 16369] | [198, 62152, 22761, 354, 5814] |
| TRT (1) | [11.23, 11.49, 10.16] | [6.58, 6.58, 6.58, 6.58, 6.58] |
| TRT (2) | [24.53, 0, 0] | [24.53, 0, 0, 0, 0] |

#### A.1.4 Training datails

During training, the ET features predictor model remains frozen, while the ET features projector is normally trained without adapters (Figure 2). The RM is fine-tuned on top of the open-source models using QLoRA [Dettmers et al., ] based on Low-Rank Adaptation (LoRA)[Hu et al., ], which fine-tunes select dense layers by optimizing low-rank decomposition matrices representing weight changes, instead of directly updating pre-trained weights. QLoRA introduces memory optimization techniques such as the 4-bit NormalFloat (NF4), a novel data type, to improve performance without increasing memory usage. Following Dettmers et al. [] we use hyperparameters: r=8, alpha=32, and dropout=0.1.

We also fine-tune the RM embedding layer, since we are adding new tokens for the chat format and special separators tokens in our RewardConcat method (section 3). Also, the last layer added to the RM for the scalar reward is trained from scratch without adapters. Our implementation is based in pytorch and we use transformers (^11^1111[https://huggingface.co/docs/transformers/index](https://huggingface.co/docs/transformers/index)) from Hugging Face.

Hardware.
We trained the models on servers equipped with 2x Intel Xeon Platinum 8470 CPUs, 1TB of RAM, and either 2x NVIDIA H100 (80GB) or 4x NVIDIA A100 (80GB) GPUs. We always train using only GPU at a time per each model and training times were between 20 and 50 hours depending mainly on the number of steps between model evaluations.

## Appendix B Reward benchmark

As we described in section 6, a future direction would be to train a Reward Model on a larger model with more data. It has been proven the scaling trends for the reward model; More data and a larger-size model generally improve accuracy [Touvron et al., ]. Nevertheless, as a complement to our results, we evaluated our trained models on the dataset with the best results, OAAST1, in this RewardBench, a benchmark for Reward Models.
RewardBench, proposed in Lambert et al. [], is a benchmark designed to evaluate the performance and safety of reward models. It consists of a set of datasets intended for measuring how reward models perform on challenging prompts across chat, reasoning, and safety domains, using a trio structure of prompt-chosen-rejected pairs. It comprises 2985 diverse tasks, each sample is formatted as a prompt with a manual or human-verified chosen and rejected completion. Due to its diversity of tasks (4 categories and 23 sub-categories) this benchmark minimizes the likelihood of overfitting. Task accuracy is calculated based on whether the chosen response receives a higher reward than the rejected response. We directly evaluate their open dataset reward-bench (^12^1212[https://huggingface.co/datasets/allenai/reward-bench](https://huggingface.co/datasets/allenai/reward-bench))

## Appendix C Hyper parameter tuning

We performed hyperparameter tuning for the GazeConcat method and the baseline, and we replicated them in the GazeAdd method, as testing all combinations is computationally very expensive. For each dataset, 15% is reserved for validation to perform hyperparameter tuning. The best-performing checkpoints are selected based on the lowest validation loss and are subsequently used for performance evaluation in the test split. We trained for two epochs, as described in Wang et al. [] and in line with trends observed in Touvron et al. [] where they found that training longer can lead to over-fitting. We perform a grid search for the optimal batch size, testing {8, 16, 32} values. AdamW optimizer [Loshchilov and Hutter, ] is used and the learning rate is tuned within the range of {1, 5, 10, 50}e-6, inspired by the values reported in Touvron et al. [], Cui et al. [], Wang et al. []. Additionally, we explored different scheduler configuration, comparing constant, linear, and cosine with a minimum learning rate.

In general, the parameter that most affected the validation results was the learning rate. For the others, we ended up choosing values that worked well across all combinations. We achieved better results in both the baseline and the models concatenating the ET features with a learning rate of 0.0005 ( Figure 4). In 6(a) and 6(b), the validation loss and learning rate with different schedulers are shown. For lower learning rates, such as 0.00001, the scheduler had little effect. However, with higher learning rates, using a scheduler helped to mitigate overfiting. In 7(a) and 7(b), it represents validation loss and learning rates with a higher learning rate of 0.0005. We opted to use this 0.00005 learning rate for all experiments, employing a cosine learning rate scheduler with a minimum learning rate of 0.7, in line with other studies such as Wang et al. [], Touvron et al. []. We did not find a significant effect of training batch size on validation accuracy, but we opted for a value of 8, which often (especially with high learning rates and without a scheduler) was the one that tended to overfit the least ( Figure 5).

ET features projector
The PyTorch architecture of our ET features projector is shown below. $num_features$ varies between 1, 5, and 2 (depending on the configuration used $fcomb_{1}$, $fcomb_{2.5}$, $fcomb_{2.2}$ subsection 4.2). $p_{1},p_{2}$ are dropout values. Finally, after testing different combinations, we used $0.1$ and $0.3$.

Figure: Listing 1: PyTorch architecture of our gaze features projector

Figure: Figure 4: Validation loss with different LR on ConcatReward, batch size 8, features: $f1$ and Meta-Llama-3-8B-Instruct base model
Refer to caption: extracted/5895889/figures/learning_rate_plot.png

Figure: Figure 5: Validation loss with different batch size, learning rate: 5e-5, features: $f1$ and Meta-Llama-3-8B-Instruct base model
Refer to caption: extracted/5895889/figures/per_device_train_batch_size_plot.png

Figure: (a) Validation Loss Comparison for different LR Schedulers
Refer to caption: extracted/5895889/figures/scheduler_a1_plot.png

Figure: (a) Validation Loss Comparison for different LR Schedulers
Refer to caption: extracted/5895889/figures/scheduler_b1_plot.png

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 8
presentation: 4
questions: Q1. You don't scale this approach to larger models/datasets (understandably!). Do you foresee any potential challenges of scaling this approach other than compute cost? Do you believe this data would be best used to fully replace existing methods for reward modeling, or in conjunction?

Q2. Somewhat related to the above-- do you have a sense of any error category differences between RMs trained with eye tracking data and without?
soundness: 3
strengths: S1. The idea of using eye tracking data as reward model signal is exciting, interesting, and well-explored in this work. The paper analyzes several methods of integration and discusses the pros and cons of (synthetic or real) eye tracking data.

S2. The paper is beautifully written and clearly lays out prior work in both reward modeling and eye tracking for NLP. It was very easy to follow.

S3. The appendix reports details on hyperparameter tuning, implementations, and modeling assumptions. I believe it would be easy to replicate this work with the details provided.
summary: The paper examines the possibility of using eye-tracking data to train language reward models. The authors integrate synthetic eye tracking data from existing models into the reward model using two strategies: concatenation or addition of eye tracking features. They test their methods across multiple eye tracking models and LLMs and show that eye tracking data can improve reward models at a small to medium scale.
weaknesses: W1. Very minor, but I think section 2+5 could be better structured, perhaps by moving them both into section 2. I was a bit surprised on my first read to see a related work section near the end, since section 2 discusses much of the reward modeling literature; I think it makes sense to put these in the same spot, and I liked the placement near the beginning.

W2. Because the datasets are somewhat constrained, it's not clear that this would provide consistent gains over existing reward models in a large-scale setting (could this be a useful signal only in small data regimes?). I don't think the paper necessarily needs to provide evidence against this concern, as this might require excessive amounts of compute, but I think more discussion of this possibility would help temper the claims in the work.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: See weaknesses above.
soundness: 3
strengths: + Eye-tracking is being introduced as a novel feature to assist reward modeling. 
+ Substantial performance improvements with the GazeReward framework
summary: The paper introduces GazeReward, a framework that incorporates eye-tracking data into the reward modeling phase of RLHF to better align LLMs with human preferences. This represents a novel solution to the reward modeling task with extra information from eye-tracking features. Experimental results also show the effectiveness of the proposed approach with an impormvent in reward modeling accuracy.
weaknesses: + The experiments show that eye-tracking signals can improve the accuracy of reward modeling. As the reward model is used for RLHF processes like PPO and Best-of-n sampling, I would suggest the authors add relevant experiments to show the improvement in this down-stream application of the reward model.
+ What is the size of eye-tracking feature extractor? If the size of the eye-tracking component is not negligible, it might not be a fair comparison between the original model the model with eye-tracking feature extractor.

---

confidence: 3
contribution: 3
initial_rating: 3
presentation: 2
questions: - L.46-48 Could you elaborate how eye-tracking data mitigates the problems you cited in human feedback for RLHF? Would the eye-tracking features not also reflect biases from humans from which the ET models were trained on, or their domain expertise?
- L.48-49 How is scalable oversight relevant to the problem studied in this paper?
- L. 73 It's unclear what you mean by "better temporal and spatial resolution", could you please clarify?
- L. 74 What is the connection to attention patterns and human preference for reward modeling?
- S. 3.1 It would be helpful to describe more in this section what these ET models are trained on, the accuracy of these ET models.
- I would be curious to see results, or if not feasible a discussion, on how your GazeReward framework compares to if we used eye-tracking data directly collected on the preference prompts instead of features generated by an ET prediction model
- Please also discuss the ethical impact of this work, mainly to address concerns that incorporating an ET model may amplify biases present in the ET models
- Suggestion: make the text in your figures bigger
soundness: 2
strengths: The idea behind incorporating eye-tracking features to reward models is quite original, and to my knowledge, has not been previously explored. The authors are also able to demonstrate accuracy gains in reward modeling after adding eye-tracking features, which brings a positive impact to RLHF that is widely used in current LLMs.
summary: This work incorporates features extracted from eye-tracking prediction models into reward models for RLHF. They find that adding eye-tracking information improves reward modeling accuracy on two reward modeling datasets. In addition, the authors also perform ablation studies to study what type of eye-tracking features lead to the highest reward modeling accuracy.
weaknesses: I find two main weaknesses that prevent me from recommending this paper for acceptance, but that could be feasibly addressed by the authors. First, it is difficult for me to assess whether the improvements on reward modeling reported in the paper are significant. According to Table 2, the test sets used for reward model evaluation are quite small (416 and 364 examples) and I did not find information on the statistical significance of the differences in results. I am also skeptical whether the improvements in scores would be robust to different random seeds and other parameters. It would be beneficial to add statistical significance tests and further discussion on how you ensured your findings are robust.
The second weakness is the lack of motivation in using eye-tracking data. There are a few points the authors allude to in the introduction (see some of my questions below), but it would be very helpful to explain the intuition on why eye-tracking data would have a connection or be correlated with human preferences. Intuitively, I would think that people would spend more time gazing at sentences that are difficult to parse for example, rather than having a preference.

Meta-review: This paper introduces a novel framework that integrates eye-tracking data as implicit feedback into the reward model for aligning LLMs with human expectations, called GazeReward. The reviewers appreciate the novelty of the approach and the performance gains it can achieve by incorporating gaze data. However, they also expressed concerns about the limited scale of the experiments, the lack of clear justification for using eye-tracking data, the absence of downstream evaluation, and the lack of statistical analysis.

Decision: Accept (Poster)