weight_fitting_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4cae3596-388b-4ca7-9793-3e38ab156646",
   "metadata": {},
   "source": [
    "## Weight Fitting Example\n",
    "\n",
    "In this notebook, we give an example of using our RBR weight fitting code defined in `rbr_weight_fitter.py`\n",
    "\n",
    "We first import our weight fitting code as well as some classes that return reward model scores and RBR features and a util for reading data files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d8dd2195-5497-4068-bf07-ab71479db96b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from rbr_weight_fitter import RBR_ExampleWithMetadata, RBRWeightFitter\n",
    "from cached_classes import CachedRewardModelScores, CachedFeaturesValues, RESPONSE_TYPES\n",
    "from utils import read_jsonl, to_string"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55c9bf91-fde2-4157-84e9-29bb3082aaa4",
   "metadata": {},
   "source": [
    "### Loading Data\n",
    "**IMPORTANT NOTE**: This data is not what is actually in paper experiments, as the prompts we start with are all synthetic (the prompts of the RBR Gold dataset). In the paper experiments we start with safety PPO prompts.\n",
    "\n",
    "This file is saved in the format of a list of `([prompt_string, [completion_items])` tuples.\n",
    "- `prompt_string` is a string representation of the prompt (see the provided `to_string` method)\n",
    "- a `completion_item` contains the following information:\n",
    "  - `prompt` is the conversation up to the last user turn in a list of dicts in the format `[{'role': ..., 'content':...} ...]` (note that this is the same for every completion item in the list for a given prompt_string)\n",
    "  - `completion` a possible assistant completion in the same format as the prompt\n",
    "  - `response_type` the ideal behavior we would like to respond with (ex. Comply, Hard Refuse, etc) (note that this is the same for every completion item in the list as it is decided based on the prompt)\n",
    "  - `completion_type` describes the completion (ex. perfect hard refusal, bad hard refusal, contains disallowed, etc)\n",
    "  - `category` gives the safety category (ex. None, C-R, C-C, etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c18f53db-75e6-4fe6-8c0e-97a12f8edf34",
   "metadata": {},
   "outputs": [],
   "source": [
    "SYNTHETIC_EXAMPLES_PATH = 'data/weight_fitting_data/{split}.jsonl'\n",
    "weight_fitting_data_train_raw = dict(read_jsonl(SYNTHETIC_EXAMPLES_PATH.format(split='train')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dc2c2cc3-2544-45cc-ba50-3aa6715fd7eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are a total of 349 train prompts\n",
      "There are a total of 5892 train prompt completion pairs\n",
      "There is an average of 16.88 examples per prompt\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "num_examples_per_prompt = []\n",
    "total_examples = 0\n",
    "#get some train stats\n",
    "for prompt, completion_items in weight_fitting_data_train_raw.items():\n",
    "    n_examples = len(completion_items)\n",
    "    num_examples_per_prompt.append(n_examples)\n",
    "    total_examples += n_examples\n",
    "print(f\"There are a total of {len(weight_fitting_data_train_raw)} train prompts\")\n",
    "print(f\"There are a total of {total_examples} train prompt completion pairs\")\n",
    "print(f\"There is an average of {np.mean(num_examples_per_prompt):.2f} examples per prompt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1da0aa33-ac23-415a-953f-971f8023567a",
   "metadata": {},
   "source": [
    "### Calculating Feature and Reward Model Values\n",
    "For each `(prompt, completion)` pair we will need the feature values (in our case, the probabilities of various propositions as judged by a grader LLM model) and reward model score.\n",
    "\n",
    "For this example, we provide the following values which we have cached:\n",
    "- **Features**: The probability of propositions as graded by our Helpful-Only SFT GPT4 size model. The prompts used for grading are in `config/proposition_prompts.yaml`\n",
    "- **Reward Model Scores**: We provide the reward model scores for our `Large` sized Helpful-Only RM model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3fa450c5-d7c5-48ca-8a23-aa18ec8f8046",
   "metadata": {},
   "outputs": [],
   "source": [
    "rm_score_calculator = CachedRewardModelScores()\n",
    "feature_value_calculator = CachedFeaturesValues()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8744926b-1821-4021-81c3-ea643943928b",
   "metadata": {},
   "source": [
    "### Formatting Data\n",
    "We will format train examples for the weight_fitter, we will fit separate weights for each response type (aka behavior class), so we need to sort the data by response types. In our case, the response types are `['Hard Refuse', 'Comply', 'Safe Refuse 1', 'Safe Refuse 2']`.\n",
    "\n",
    "We will also format examples without any RM score (by setting them all to 0) to investigate the RBRs themselves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5cb892bf-c517-42c0-9035-ba7b8aaa10b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_formatted_train_examples = {rt:[] for rt in RESPONSE_TYPES} #with RM score\n",
    "all_formatted_train_examples_noRM = {rt:[] for rt in RESPONSE_TYPES} #without RM score\n",
    "\n",
    "rt_to_completion_types = {rt: set() for rt in RESPONSE_TYPES}\n",
    "rt_to_feature_names = {}\n",
    "\n",
    "all_safety_categories = []\n",
    "for prompt_str, completion_items in weight_fitting_data_train_raw.items():\n",
    "    completions = [ci['completion'] for ci in completion_items]\n",
    "    prompt = completion_items[0]['prompt']\n",
    "    c_rm_scores = rm_score_calculator.get_reward_model_scores(prompt, completions)\n",
    "    c_feature_values = feature_value_calculator.get_features(prompt, completions)\n",
    "    assert len(c_rm_scores) == len(completion_items), \"number of rm scores and completions don't match up!\"\n",
    "    assert len(c_feature_values) == len(completion_items), \"number of features sets and completions don't match up!\"\n",
    "\n",
    "    #all completion items have the same response type and safety category as those are properties of the prompt\n",
    "    response_type = completion_items[0]['response_type']\n",
    "    \n",
    "    #track safety categories for analysis purposes, this is not used\n",
    "    safety_category = completion_items[0]['category']\n",
    "    all_safety_categories.append(safety_category)\n",
    "    \n",
    "    for ci, rm_score, feature_value in zip(completion_items, c_rm_scores, c_feature_values):\n",
    "        completion_label = ci['completion_type']\n",
    "        rt_to_completion_types[response_type].add(completion_label)\n",
    "\n",
    "        #make sure all the features are consistent for each response type:\n",
    "        if response_type not in rt_to_feature_names:\n",
    "            rt_to_feature_names[response_type] = set(feature_value.keys())\n",
    "        else:\n",
    "            assert rt_to_feature_names[response_type] == set(feature_value.keys()), \"There is a features mismatch\"\n",
    "        \n",
    "        all_formatted_train_examples[response_type].append(\n",
    "            RBR_ExampleWithMetadata(\n",
    "                convo_prompt = to_string(prompt), #turn conversation to a string so it can be hashed\n",
    "                convo_completion = to_string(ci['completion']), #turn conversation to a string so it can be hashed\n",
    "                response_type = response_type,\n",
    "                completion_label = completion_label,\n",
    "                base_reward = rm_score,\n",
    "                features = feature_value,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        all_formatted_train_examples_noRM[response_type].append(\n",
    "            RBR_ExampleWithMetadata(\n",
    "                convo_prompt = to_string(prompt), #turn conversation to a string so it can be hashed\n",
    "                convo_completion = to_string(ci['completion']), #turn conversation to a string so it can be hashed\n",
    "                response_type = response_type,\n",
    "                completion_label = completion_label,\n",
    "                base_reward = 0, #no RM score\n",
    "                features = feature_value,\n",
    "            )\n",
    "        )\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "31cc6151-4d93-4672-a54c-e8b40091958e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'None': 70, 'SH-R2': 58, 'SH-C': 47, 'C-R': 37, 'K-R': 33, 'K-C': 28, 'H-C': 26, 'C-C': 23, 'H-R': 18, 'SH-R1': 9})\n"
     ]
    }
   ],
   "source": [
    "#we can take a look at all the safety categories breakdown:\n",
    "from collections import Counter\n",
    "print(Counter(all_safety_categories))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "138bbef9-d451-47c5-9325-678f27b9124f",
   "metadata": {},
   "source": [
    "### Fitting the weights\n",
    "We first set our ordering over preferences and then we run the weight fitting code.\n",
    "\n",
    "We then run the weight fitting code which fits a linear model to optimize the hinge loss to main the specified ordering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e1a8b18f-62f8-4973-a748-a5a1c1e94d0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Setting our ordering preferences\n",
    "rt_orderings = {\n",
    "    'Hard Refuse':{\n",
    "        'disallowed content': [], #disallowed content is the worse\n",
    "        'bad hard refusal': ['disallowed content'], #we prefer a bad hard refusal over disallowed content\n",
    "        'perfect hard refusal': ['bad hard refusal', 'disallowed content'], #we prefer a perfect hard refusal over bad hard refusals and disallowed content\n",
    "    },\n",
    "    'Safe Refuse 1': {\n",
    "        'disallowed content': [],\n",
    "        'bad safe completion': ['disallowed content'],\n",
    "        'perfect safe completion': ['bad safe completion', 'disallowed content'],\n",
    "    },\n",
    "    'Safe Refuse 2': {\n",
    "        'disallowed content': [],\n",
    "        'bad safe completion': ['disallowed content'],\n",
    "        'perfect safe completion': ['bad safe completion', 'disallowed content'],\n",
    "    },\n",
    "    'Comply': {\n",
    "        'perfect refusal': [],\n",
    "        'imperfect refusal': [],\n",
    "        'random non-refusal': [],\n",
    "        'partially complies': ['imperfect refusal', 'perfect refusal', 'random non-refusal'],\n",
    "        'fully complies': ['partially complies', 'imperfect refusal', 'perfect refusal', 'random non-refusal'],\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ce9a4794-8a9d-478d-84f0-2e5e2644f352",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting weights for Hard Refuse\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 1568.72it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting weights for Comply\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:01<00:00, 995.00it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting weights for Safe Refuse 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 2660.21it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting weights for Safe Refuse 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 2394.01it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting weights for Hard Refuse but without RM score\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 2342.12it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting weights for Comply but without RM score\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:01<00:00, 994.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting weights for Safe Refuse 1 but without RM score\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 2683.76it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting weights for Safe Refuse 2 but without RM score\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:00<00:00, 2366.69it/s]\n"
     ]
    }
   ],
   "source": [
    "#Fitting the weights:\n",
    "\n",
    "all_weights = {}\n",
    "for rt in RESPONSE_TYPES:\n",
    "    print(f\"Fitting weights for {rt}\")\n",
    "    weight_fitter = RBRWeightFitter(\n",
    "        feature_names = rt_to_feature_names[rt],\n",
    "        examples = all_formatted_train_examples[rt],\n",
    "        orderings = rt_orderings[rt],\n",
    "        wd = 0.05\n",
    "    )\n",
    "    weights_dict, metrics = weight_fitter.fit_weights()\n",
    "    all_weights[rt] = weights_dict\n",
    "\n",
    "all_weights_noRM = {}\n",
    "for rt in RESPONSE_TYPES:\n",
    "    print(f\"Fitting weights for {rt} but without RM score\")\n",
    "    weight_fitter = RBRWeightFitter(\n",
    "        feature_names = rt_to_feature_names[rt],\n",
    "        examples = all_formatted_train_examples_noRM[rt],\n",
    "        orderings = rt_orderings[rt],\n",
    "        wd = 0.05\n",
    "    )\n",
    "    weights_dict, metrics = weight_fitter.fit_weights()\n",
    "    all_weights_noRM[rt] = weights_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e52dbd5-655b-4475-bb2e-902acf5fd72b",
   "metadata": {},
   "source": [
    "## Testing and Visualization\n",
    "\n",
    "Lets use the test split to test and visualize how the reward score does. We will look at the following 3 reward signals:\n",
    "- The reward model by itself\n",
    "- The reward model with the safety RBRs\n",
    "- The safety RBRs by themselves\n",
    "\n",
    "To visualize, we will first center the reward to the average ideal completion reward (to remove the case where some prompts have higher base scores), we then plot a histogram of rewards grouped by completion type (ex. perfect hard refusal, etc) to see how well the reward signal can order the completions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a9862f2-3fa8-433c-80f6-97561af78ad7",
   "metadata": {},
   "source": [
    "### Load in the test split, then format, sort, and calculate the reward signals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c9487288-706d-4000-ae15-2e9478a8728e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are a total of 167 test prompts\n",
      "There are a total of 2688 test prompt completion pairs\n",
      "There is an average of 16.10 examples per prompt\n"
     ]
    }
   ],
   "source": [
    "weight_fitting_data_test_raw = dict(read_jsonl(SYNTHETIC_EXAMPLES_PATH.format(split='test')))\n",
    "\n",
    "num_examples_per_prompt = []\n",
    "total_examples = 0\n",
    "#get some train stats\n",
    "for prompt, completion_items in weight_fitting_data_test_raw.items():\n",
    "    n_examples = len(completion_items)\n",
    "    num_examples_per_prompt.append(n_examples)\n",
    "    total_examples += n_examples\n",
    "print(f\"There are a total of {len(weight_fitting_data_test_raw)} test prompts\")\n",
    "print(f\"There are a total of {total_examples} test prompt completion pairs\")\n",
    "print(f\"There is an average of {np.mean(num_examples_per_prompt):.2f} examples per prompt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8d69ec75-fcce-4191-803e-2e7665fc1146",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "#Function for calculating the rewards:\n",
    "def get_reward(weights, features, reward=0.0):\n",
    "    assert (\n",
    "        weights.keys() == features.keys()\n",
    "    ), f\"Features don't match!! Weights: {weights.keys()}, Example: {features.keys()}\"\n",
    "    multiplied_weights = {key: weights[key] * features[key] for key in weights}\n",
    "    return reward + np.sum(list(multiplied_weights.values()))\n",
    "\n",
    "#Combine the two safe refusal classes for clarity:\n",
    "NEW_RESPONSE_TYPES = ['Hard Refuse', 'Comply', 'Safe Refuse']\n",
    "\n",
    "rt_orderings['Safe Refuse'] = {'disallowed content': [],\n",
    "    'bad safe completion': ['disallowed content'],\n",
    "    'perfect safe completion': ['bad safe completion', 'disallowed content'],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f6579437-82e3-4b22-87d3-c55eed091cf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_examples_by_rt = {rt:[] for rt in NEW_RESPONSE_TYPES} #with RM score\n",
    "\n",
    "all_safety_categories_test = []\n",
    "\n",
    "for prompt_str, completion_items in weight_fitting_data_test_raw.items():\n",
    "    completions = [ci['completion'] for ci in completion_items]\n",
    "    prompt = completion_items[0]['prompt']\n",
    "    c_rm_scores = rm_score_calculator.get_reward_model_scores(prompt, completions)\n",
    "    c_feature_values = feature_value_calculator.get_features(prompt, completions)\n",
    "    assert len(c_rm_scores) == len(completion_items), \"number of rm scores and completions don't match up!\"\n",
    "    assert len(c_feature_values) == len(completion_items), \"number of features sets and completions don't match up!\"\n",
    "\n",
    "    #all completion items have the same response type and safety category as those are properties of the prompt\n",
    "    response_type = completion_items[0]['response_type']\n",
    "    \n",
    "    #track safety categories for analysis purposes, this is not used\n",
    "    safety_category = completion_items[0]['category']\n",
    "    all_safety_categories_test.append(safety_category)\n",
    "\n",
    "    for ci, rm_score, feature_value in zip(completion_items, c_rm_scores, c_feature_values):\n",
    "        #Add in RM score to saved data:\n",
    "        ci['rm_score'] = rm_score\n",
    "\n",
    "        #Add in RM + RBR score to saved data:\n",
    "        features_weights = all_weights[response_type]\n",
    "        ci['rm_rbr_score'] = get_reward(features_weights, feature_value, rm_score)\n",
    "\n",
    "        #Add in RBR score without RM to saved data:\n",
    "        features_weights_noRM = all_weights_noRM[response_type]\n",
    "        ci['rbr_only_score'] = get_reward(features_weights_noRM, feature_value, 0)\n",
    "    \n",
    "    #Compress Safe Refuse 1 and Safe Refuse 2 for simplicity    \n",
    "    if response_type in ['Safe Refuse 1', 'Safe Refuse 2']:\n",
    "        all_examples_by_rt['Safe Refuse'].append({prompt_str: completion_items})\n",
    "    else:\n",
    "        all_examples_by_rt[response_type].append({prompt_str: completion_items})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "686d5ff4-423f-4e2a-a76e-99280107adee",
   "metadata": {},
   "outputs": [],
   "source": [
    "#center and sort rewards\n",
    "best_categories = {\n",
    "    'Hard Refuse': 'perfect hard refusal',\n",
    "    'Safe Refuse 1': 'perfect safe completion',\n",
    "    'Safe Refuse 2': 'perfect safe completion',\n",
    "    'Comply': 'fully complies'\n",
    "}\n",
    "\n",
    "#Function for normalizing rewards\n",
    "def center_rewards(completion_items, reward_key):\n",
    "    all_ideal_rewards = []\n",
    "    all_rewards = []\n",
    "    for ci in completion_items:\n",
    "        reward = ci[reward_key]\n",
    "        all_rewards.append(reward)\n",
    "        if ci['completion_type'] == best_categories[ci['response_type']]:\n",
    "            all_ideal_rewards.append(reward)\n",
    "    avg_ideal_reward = np.mean(all_ideal_rewards)\n",
    "    centered_rewards = [r-avg_ideal_reward for r in all_rewards]\n",
    "    for cr, ci in zip(centered_rewards, completion_items):\n",
    "        ci[reward_key + '_centered'] = cr\n",
    "    return centered_rewards\n",
    "\n",
    "#Function for sorting the rewards by completion type (ex. perfect hard refusal)\n",
    "def center_and_sort_rewards(data_dict, reward_key):\n",
    "    centered_rewards_by_rt_ct = {rt: {\n",
    "        completion_type: [] for completion_type in rt_orderings[rt].keys()\n",
    "    } for rt in NEW_RESPONSE_TYPES}\n",
    "    \n",
    "    for response_type in NEW_RESPONSE_TYPES:\n",
    "        rt_data = data_dict[response_type]\n",
    "        for datapoint in rt_data:\n",
    "            completion_items = list(datapoint.values())[0]\n",
    "            centered_rewards = center_rewards(completion_items, reward_key)\n",
    "            for ci, cr in zip(completion_items, centered_rewards):\n",
    "                centered_rewards_by_rt_ct[response_type][ci['completion_type']].append(cr)\n",
    "    return centered_rewards_by_rt_ct\n",
    "\n",
    "#Calculate the centered rewards:\n",
    "\n",
    "#RM only\n",
    "centered_rewards_by_rt_ct_rm_only = center_and_sort_rewards(all_examples_by_rt, 'rm_score')\n",
    "\n",
    "#RM with RBR\n",
    "centered_rewards_by_rt_ct_rm_rbr = center_and_sort_rewards(all_examples_by_rt, 'rm_rbr_score')\n",
    "\n",
    "#RBR only\n",
    "centered_rewards_by_rt_ct_rbr_only = center_and_sort_rewards(all_examples_by_rt, 'rbr_only_score')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a1b5d31-ef3c-46d8-8d1c-91ebb79f1011",
   "metadata": {},
   "source": [
    "### Visualization\n",
    "Now lets visualize how well the reward signal does at distinguishing between good and bad completions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "acc56e11-1933-4f7e-8435-1835175b5dc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plotting function:\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#some plotting helper functions or colors and relabelling\n",
    "from utils import color_mapping, labels_map \n",
    "\n",
    "def plot_histogram(centered_rewards_by_rt_ct, title = None):\n",
    "    #centered_rewards_by_rt_ct should have rewards sorted by response_type and then by completion_type\n",
    "    # Create a 1x3 grid of subplots\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(12, 4))\n",
    "    bins = np.linspace(-5, 3, 21)\n",
    "\n",
    "    # Loop through the dictionaries and axes to plot each dictionary in a subplot\n",
    "    for ax, response_type in zip(axes.flatten(), NEW_RESPONSE_TYPES):\n",
    "        centered_rewards_by_ct = centered_rewards_by_rt_ct[response_type]\n",
    "        for completion_type, values in centered_rewards_by_ct.items():\n",
    "            ax.hist(values,  label=labels_map[completion_type], alpha=0.8,  color=color_mapping[response_type][completion_type])\n",
    "        ax.set_xlabel('Centered Rewards')\n",
    "        ax.legend()\n",
    "        ax.set_title(response_type)\n",
    "    \n",
    "    if title is not None:\n",
    "        fig.suptitle(title, fontsize=12)\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5023669f-3ec6-423a-9f2d-48040f7b3724",
   "metadata": {},
   "source": [
    "**Reward Model Only**\n",
    "\n",
    "We see that the reward model by itself does not do a good job of separating out good completions from bad ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ebe3359a-a045-454b-8dc6-5ad806a98a34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_histogram(centered_rewards_by_rt_ct_rm_only, \"Reward Model Only\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4043699-c2ea-4116-962a-400cec6b1186",
   "metadata": {},
   "source": [
    "**Reward Model with RBR**\n",
    "\n",
    "Adding in the RBRs allow better separation of good completions (Ideal) from bad ones (ex. bad refusals), and bad ones from really bad completions (ex. disallowed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "19f73594-0909-4666-a0c0-86dec88476ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_histogram(centered_rewards_by_rt_ct_rm_rbr, \"Reward Model + RBR\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0e62ab4-2151-41c9-b31d-0e4a050fe9a1",
   "metadata": {},
   "source": [
    "**RBR Only**\n",
    "\n",
    "We also show the RBR itself at ranking completions, it also has good separation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3c83e249-e06b-4398-abc6-4034665d58f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_histogram(centered_rewards_by_rt_ct_rbr_only, \"RBR Only\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "580894e9-a3a2-454f-9322-1df9b550257a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}