Having established the need for AI-generated feedback in RLAIF, we now focus on how to teach a model to understand these AI judgments. The core component for this is the preference model. Its objective is to learn a function, let's call it $p_\theta$ , that estimates the probability that one response, $y_w$ (winner), is better than another response, $y_l$ (loser), for a given input prompt $x$ , according to the criteria used by the AI labeler. Mathematically, we want to model:

p_\theta(y_w \succ y_l | x)

This preference model acts as a proxy for the AI labeler's judgment process, allowing us to score arbitrary responses during the reinforcement learning phase.

Preference Model Architecture

A common and effective approach is to adapt the base Large Language Model (LLM) architecture itself to serve as the preference model. Here's how it typically works:

Input: The model takes the prompt $x$ concatenated with a response $y$ as input.
Processing: This combined input sequence is processed through the transformer architecture.
Scoring Head: A linear layer (the "scoring head") is added on top of one or more of the final hidden states (often just the state corresponding to the last token of the response). This head outputs a single scalar value, $s_\theta(x, y)$ , representing the "preference score" for that specific response given the prompt.

The parameters $\theta$ include the LLM's weights (which might be fine-tuned) and the weights of the newly added scoring head. The intuition is that the LLM's deep understanding of language allows it to capture the nuances that make one response preferable over another.

Alternatively, a distinct, potentially smaller, model could be trained solely for preference scoring. This might offer computational savings during training and inference but could potentially sacrifice some representational capacity compared to using the full base LLM. The choice often depends on resource constraints and the complexity of the preference criteria.

Training Data and Format

The preference model is trained in a supervised manner, but instead of direct labels, it learns from pairwise comparisons. The training data consists of tuples $(x, y_w, y_l)$ , where:

$x$ is the input prompt.
$y_w$ is the response deemed "better" or "winning" by the AI labeler.
$y_l$ is the response deemed "worse" or "losing" by the AI labeler.

These tuples are generated using methods discussed in the subsequent section ("Generating AI Preference Labels"). A diverse and high-quality dataset covering various prompts and response types is important for training a robust preference model.

The Bradley-Terry Model and Loss Function

To train the model parameters $\theta$ , we need a way to relate the scalar scores $s_\theta(x, y)$ to the probability $p_\theta(y_w \succ y_l | x)$ . The widely adopted approach relies on the Bradley-Terry model, which posits that the probability of $y_w$ being preferred over $y_l$ can be modeled based on the difference between their underlying quality scores. Specifically, we use the logistic function (sigmoid) applied to the difference in scores generated by our model:

p_\theta(y_w \succ y_l | x) = \sigma(s_\theta(x, y_w) - s_\theta(x, y_l))

Here, $\sigma(z) = 1 / (1 + e^{-z})$ is the sigmoid function, which conveniently maps the score difference (ranging from $-\infty$ to $+\infty$ ) to a probability between 0 and 1.

The training objective is then to maximize the likelihood of the preference judgments observed in the training dataset $\mathcal{D}$ . This is equivalent to minimizing the negative log-likelihood of these preferences, often referred to as the pairwise preference loss:

\mathcal{L}(\theta) = - \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} [\log p_\theta(y_w \succ y_l | x)]

Substituting the sigmoid formulation, the loss becomes:

\mathcal{L}(\theta) = - \mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}} [\log \sigma(s_\theta(x, y_w) - s_\theta(x, y_l))]

This loss function encourages the model to assign a higher score $s_\theta$ to the winning response $y_w$ compared to the losing response $y_l$ for each triplet in the dataset.

The preference model training process. For each data point $(x, y_w, y_l)$ , the model computes scores $s_\theta$ for both responses. The difference is passed through a sigmoid to get the predicted probability $p_\theta(y_w \succ y_l | x)$ , which is used to calculate the loss.

Implementation Considerations

Scoring Efficiency: When training, you compute $s_\theta(x, y_w)$ and $s_\theta(x, y_l)$ . This often involves two separate forward passes through the underlying transformer model for each training example $(x, y_w, y_l)$ . Some implementations optimize this by packing the prompt with both responses into a single sequence if possible, though this can complicate attention masking.
Optimizer and Learning Rate: Standard optimizers like AdamW are commonly used. Learning rates are typically small (e.g., in the $10^{-6}$ to $10^{-5}$ range when fine-tuning a large base model) and often employ a learning rate schedule, such as linear decay.
Initialization: If fine-tuning a pre-trained LLM, the scoring head is initialized randomly, while the base model weights retain their pre-trained values. The base model weights might be kept frozen initially or fine-tuned alongside the head.
Gradient Accumulation: Due to the large size of the models and potentially long input sequences (prompt + response), gradient accumulation is frequently used to simulate larger batch sizes than might fit into GPU memory directly.

Challenges in AI Preference Modeling

Training preference models with AI-generated labels introduces specific challenges compared to using human labels:

Label Quality and Noise: The AI labeler is not infallible. It might produce noisy, inconsistent, or systematically biased preferences based on its own limitations or the heuristics/constitution used to guide it. The preference model must learn the underlying "intended" preference signal despite this noise. Techniques like dataset filtering (removing pairs where the AI expressed low confidence) or robust loss functions might be employed.
Calibration: The raw scores $s_\theta(x, y)$ are trained based on differences. Their absolute values might not be well-calibrated probabilities or meaningful quality indicators on their own. While this is often sufficient for ranking, the conversion to a reward signal for RL might require normalization or calibration steps to ensure stable RL training.
Generalization: The preference model needs to generalize effectively to new prompts and responses encountered during RL training, which might differ from those in its own training set. Poor generalization can lead to inaccurate reward signals and hinder the RL agent's learning.
Computational Resources: Fine-tuning a large LLM as a preference model requires significant computational resources (GPUs, TPUs, time), similar to other LLM training tasks.

Successfully training this preference model is a significant step in the RLAIF pipeline. Its learned scoring function, $s_\theta(x, y)$ , becomes the foundation for generating the reward signal that guides the LLM policy during the subsequent reinforcement learning phase, which we explore next.