# How well do truth probes generalise?

Representation engineering (RepEng) has emerged as a promising research avenue for model interpretability and control. Recent papers have proposed methods for [discovering truth in models with unlabeled data](https://arxiv.org/abs/2212.03827), [guiding generation by modifying representations](https://arxiv.org/abs/2308.10248), and [building LLM lie detectors](https://arxiv.org/abs/2310.01405). RepEng asks the question: If we treat representations as the central unit, how much power do we have over a model’s behaviour?

Most techniques use linear probes to monitor and control representations. An important question is whether the probes **generalise**. If we train a probe on the truths and lies about the locations of cities, will it generalise to truths and lies about Amazon review sentiment? This report focuses on **truth** due to its relevance to safety, and to help narrow the work.

Generalisation is important. Humans typically have one generalised notion of “truth”, and it would be enormously convenient if language models also had just one[^g027webgyta]. This would result in extremely robust model insights: every time the model “lies”, this is reflected in its “truth vector”, so we could detect intentional lies perfectly, and perhaps even steer away from them.

We find that truth probes generalise surprisingly well, with **the 36% of methodologies recovering >80% of the accuracy on out-of-distribution datasets** compared with training directly on the datasets. The **best probe recovers 92% accuracy**.

*Thanks to* [*Hoagy Cunningham*](https://www.lesswrong.com/users/hoagy) *for feedback and advice. Thanks to* [*LISA*](https://www.safeai.org.uk/) *for hosting me while I did a lot of this work. Code is available at*[*mishajw/repeng*](https://github.com/mishajw/repeng)*, along with *[*steps*](https://github.com/mishajw/repeng#how-well-do-truth-probes-generalise) *for reproducing datasets and plots.*

Methods
=======

We run all experiments on [Llama-2-13b-chat](https://huggingface.co/meta-llama/Llama-2-13b-chat-hf), for parity with the source papers. Each probe is trained on 400 questions, and evaluated on 2000 different questions, although numbers may be lower for smaller datasets.

What makes a probe?
-------------------

A probe is created using a **training dataset**, a **probe algorithm**, and a **layer**.

We pass the **training dataset** through the model, extracting activations[^9ap2ou7rf7i] just after a given **layer**. We then run some statistics over the activations, where the exact technique can vary significantly - this is the **probe algorithm** \- and this creates a linear probe. [Probe algorithms](#Probe_algorithms) and [datasets](#Datasets) are listed below.

A probe allows us to take the activations, and produce a scalar value where larger values represent “truth” and smaller values represent “lies”. The probe is always linear. It’s defined by a vector ($v$), and we use it by calculating the dot-product against the activations ($a$): $v^T a$. In most cases, we can avoid picking a threshold to distinguish between truth and lies (see [appendix](#Thresholding) for details).

We always take the activations from the **last token position** in the prompt. For the majority of the datasets, the factuality of the text is only revealed at the last token, for example if saying true/false or A/B/C/D.

For this report, we’ve replicated the probing algorithm and datasets from three papers:

*   [Discovering Latent Knowledge in Language Models Without Supervision](https://arxiv.org/abs/2212.03827) (DLK).
*   [Representation Engineering: A Top-Down Approach to AI Transparency](https://arxiv.org/abs/2310.01405) (RepE).
*   [The Geometry of Truth: Emergent Linear Structure in Large Language Model Representations of True/False Datasets](https://arxiv.org/abs/2310.06824) (GoT).

We also borrow a lot of terminology from [Eliciting Latent Knowledge from Quirky Language Models](https://arxiv.org/abs/2312.01037) (QLM), which offers another great comparison between probe algorithms.

Probe algorithms
----------------

The DLK, RepE, GoT, and QLM papers describe eight probe algorithms. For each algorithm, we can ask whether it's **supervised** and whether it uses **grouped** data.

**Supervised** algorithms use the true/false labels to discover probes. This should allow better performance when truth isn’t salient in the activations. However, using supervised data encourages the probes to predict what humans would label as correct rather than what the model believes is correct.

**Grouped** algorithms utilise “groups” of statements to build the probes. For example, all possible answers to a question (true/false, A/B/C/D) constitute a group. Using this information should allow the probe to remove noise from the representations.

![](https://lh7-us.googleusercontent.com/5fhQ9HLyegjlhqVY2v3fJ-vhHNJ7w5XgoVXOri-MmJzWP6H5lOjruyGFFQB6n7K4JX6qEqYc4FUbPdGow_vYwfq47jGcilG3lL5iRxe44zTFzTjCqq0UF4v5UqyAsP3jHL8bvTE5jznVgzybOd8sXGU)

*Sketch of what the data and training process looks like when we have grouped/ungrouped and labelled/unlabelled data. Note that for CCS the “group normalisation” stage consists of taking two contrasting statements and returning the difference between them.*

|     | **Outline** | **Supervised**[^islv9quj2pa]**?** | **Grouped?** |
| --- | --- | --- | --- |
| **Linear Artificial Tomography (LAT)** from RepE. | Takes the first principle component of the differences between random pairs of activations. [Details](https://github.com/mishajw/repeng/blob/main/repeng/probes/linear_artificial_tomography.py). | No. | No. |
| **Contrast-Consistent Search (CCS)** from DLK. | Given contrastive statements (e.g. “is the sky blue? yes” and “is the sky blue? no”), build a linear probe that satisfies: * Consistency: $p(x_+) = 1 - p(x_-)$ * Confidence: $min(p(x_+), p(x_-)) = 0$ [Details](https://github.com/mishajw/repeng/blob/main/repeng/probes/contrast_consistent_search.py). | No. | Yes. |
| **Difference-in-means (DIM)** from GoT (as MMP). | Take the difference in means between true and false statements. [Details](https://github.com/mishajw/repeng/blob/main/repeng/probes/difference_in_means.py). | Yes. | No.[^w8aspy3zmq] |
| **Linear discriminant analysis (LDA)** from GoT (as MMP-IID). | Take the difference in means between true and false statements (like DIM), and skew the decision boundary by the inverse of the covariance matrix of the activations. [Details](https://github.com/mishajw/repeng/blob/main/repeng/probes/linear_discriminant_analysis.py). Intuitively, this takes the truth direction and then accounts for interference with other features. | Yes. | No. |
| **Principal component analysis (PCA)**. | Take the top principal component of the activations. [Details](https://github.com/mishajw/repeng/blob/main/repeng/probes/principal_component_analysis.py). | No. | No. |
| **Grouped principal component analysis (PCA-G)**[^kpb2a4mlia] from DLK (as CRC-TPC) | For each question, calculate the mean activation and subtract it from every answer’s activations. Then take the top principal component of the question-normalised activations. [Details](https://github.com/mishajw/repeng/blob/main/repeng/probes/principal_component_analysis.py). | No. | Yes. |
| **Logistic regression (LR).** | Perform a logistic regression, taking in activations and predicting whether they are true. [Details](https://github.com/mishajw/repeng/blob/main/repeng/probes/logistic_regression.py). | Yes. | No. |
| **Grouped logistic regression (LR-G).** | As LR, but using activations that have the group means subtracted. [Details](https://github.com/mishajw/repeng/blob/main/repeng/probes/logistic_regression.py). | Yes. | Yes. |

Datasets
--------

The key contribution of the papers above isn’t just the probe algorithms, it’s also the datasets they use to build the probes. Across all papers, we find 18 datasets (eight from DLK, five from RepE, and five from GoT).

The **DLK** datasets are straight-forward binary questions, used to craft contrasting pairs.

The **RepE** datasets differ in two important ways. One, they allow more than two answers per question, as the RepE paper doesn’t use contrasting pairs. Two, they add the suffix “*The probability of the answer being plausible is*” which prompts the model to evaluate the truthfulness of the statement.

The **GoT** dataset is the most principled of this collection. They take “uncontroversial, unambiguous, and simple enough” statements, attempting to hone in on the obviously true. These statements really are simple, such as “{city} is in {country}” or “{x} is less than {y}”.

|     | **Choices?** | **Style?** | **Simple?** | **Approx. prompt template** | **Datasets** |
| --- | --- | --- | --- | --- | --- |
| **DLK** | Binary[^4bm4ocq47y2]. | Q&A. | No. | *Consider the following example: {content}* *Choice 1: {choice1}* *Choice 2: {choice2}* *Between choice 1 and choice 2, the sentiment of this passage is {choice 1 / choice 2}* | imdb, amazon\\_polarity, ag\\_news, dbpedia_14, rte, copa, boolq, piqa |
| **RepE** | Multiple (2-5). | Q&A. | No. | *Consider the correctness of the following:* *Question: {question}* *Answer: {answer}* *The probability of the answer being plausible is* | openbook\\_qa, common\\_sense\\_qa, race, arc\\_challenge, arc_easy |
| **GoT** | Binary/none[^q5o487leuua]. | Statements. | Yes. | *The city of {city} is in {country}.* | cities, sp\\_en\\_trans, larger\\_than, cities\\_cities\\_conj, cities\\_cities_disj |

Measuring generalisation
------------------------

We measure generalisation by seeing how well probes trained on one dataset generalise to other out-of-distribution datasets. For example, we train a probe on whether a news article is about business or sports ([ag_news](https://huggingface.co/datasets/ag_news)) and see how well it performs when detecting if numbers are bigger or smaller than each other ([larger_than](https://github.com/saprmarks/geometry-of-truth/blob/main/datasets/larger_than.csv)). We use 18 diverse datasets.

### Recovered accuracy

We measure how well a probe recovers the accuracy on an out-of-distribution dataset, compared with training a probe directly on that dataset.

For each evaluation dataset, we create an accuracy threshold for that dataset. When evaluating whether a probe generalises to the evaluation dataset, we compare its accuracy to this threshold.

To **create a threshold** for a dataset we:

*   Train a suite of probes (one for every probing algorithm and layer) on the *train* subset.
*   Take the best performing probe according to accuracy on the *validation* subset.
*   Take its accuracy on the *test* subset as the threshold.

To **evaluate a probe** against a threshold we:

*   Train the probe on the *train* subset of its dataset (typically different from the evaluation dataset).
*   Evaluate the accuracy of the probe on the *evaluation *dataset’s *test* subset.
*   Taking the percent of the threshold accuracy achieved by the probe (accuracy/threshold).
*   We clip recovered accuracy at 100%.

### Finding the best generalising probe

The obvious way to compare two probes is to compare their average recovered accuracy across all datasets. However, if one probe has been trained on a dataset that is *difficult to generalise to* but nevertheless still offers good performance, then it has an unfair advantage.

To remedy this, do a pairwise comparison between each probe which looks at only the datasets that *neither* of them were trained on. We take the best probe as the probe with the highest number of “wins” across all pairwise comparisons.

Note that, as above, we perform the pairwise comparisons on the validation set. All results below are reported from the test set.

Results
=======

We train ~1.5K probes (8 algorithms * 18 datasets * 10 layers[^d5oro180xek]), and evaluate on each dataset, totalling ~25K evaluations (~1.5K probes * 18 datasets).

While probes on early layers (<=9) perform poorly, we find that for mid-to-late layers (>=13) **36% of all probes recover >80% accuracy. **This is evidence in favour of a single generalised truth notion in Llama-2-13b-chat. However, the fact that we don’t see 100% recovered accuracy in all cases suggests that either (1) there is interference in how truth is represented in these models, and the interference doesn’t generalise across datasets, or (2) truth is in fact represented in different but highly correlated ways.

![](https://lh7-us.googleusercontent.com/zFDqQp86CQTR66F-yejDvZixWAtqX9RN8REwhwmJhdv9fzyY5yeYmyvld5Xkp77l3sKUEZDQRDZ7BvPY8ciFAz7d5V5WO-aAwG1fsU4P5Sy6zPljaO0CFYltuAczXaflCL476oxyyZha7YkPjHVhVu4)

*ECDF plots of recovered accuracy, broken down by layer. You can read this as: for a given recovered accuracy, what percent of probes trained achieved it?*

The [best](https://docs.google.com/document/d/1Akk_kPYPR-YnZK_sNQfTEaTBMYP_LcNMODMX0CLGV2Y/edit#heading=h.rfxa45gy0z6h) generalising probe is a DIM probe trained with [dbpedia_14](https://huggingface.co/datasets/fancyzhx/dbpedia_14) on layer 21. It recovers, on average, **92.8% of accuracy on all datasets**.

Examining the best probe
------------------------

Let’s dig a bit deeper into our best probe. We vary each of the three hyperparameters (algorithm, train dataset, and layer) individually. This shows that the probe isn’t too sensitive to hyperparameters, as other choices perform nearly as well.

![](https://lh7-us.googleusercontent.com/u05YnSO6H8EqOXS1uZy3agiGEQB3Gb3IJyThk11PjpoCEEJm3qWKoPnxiVehztmS695fdTLaS8m47Dcr7MpC80w4q06DBWwuRD9G-WotMnZ2By2BwYyv_J3KeeC9nvjiEtjZfxq410jMDxyAHkCmyz8)

*How well training on dbpedia_14 and layer 21 generalises to evaluation datasets when varying the probe algorithm. Recovered accuracy metric is shown.*

![](https://lh7-us.googleusercontent.com/XUngNLKdIA7j3y4JJo4VySvDt7Seaal3pEMmrXOzwy0eIEqUgPvkvNTCj-4JPbMEI8XLk-eJrIcX2R4PK04PEgKKdHxcscugaVzjuV25XQfwoC8lfNpwj-j-Yh4_HeM_iyobUvpeiTEwYwENpnCHQtM)

*How well training with DIM and layer 21 generalises to evaluation datasets when varying training dataset. Recovered accuracy metric is shown.*

![](https://lh7-us.googleusercontent.com/5jxm4FmHaxmzr73y9b1nv9a-D5a05UNlMeoflmRcFNasN02CxeI83GYZaz1TqetxWHJCUKWE5weuuX1OQTuqBTj0xbDX9vhZlKFlwoZMOh9Y1QyxJsCZD_YyuYafTRBlLqwAKJDvTZviGlpc5CSaErQ)

*How well training with DIM and dbpedia_14 generalises to evaluation datasets when varying the layer.  Recovered accuracy metric is shown.*

Examining algorithm performance
-------------------------------

Let’s break down by algorithm, and take the average recovered accuracy across all probes created using that algorithm. 

![](https://lh7-us.googleusercontent.com/lkhxqTadlRmaKvTWCdBAAM6HsdU-Kh8LfOZLeX_u1GdgCBq7Qdqk5iYgduydlHaZn8_IKvttVnFU9e6bqxP34nge6hnnRnewtUCnsRI5uXW4MW9FIaJmm6TBS7nfaol-sZ51byZ3M3NTICIpRRJQDgI)

Takeaways:

*   There is little variation in probe performance.
*   Supervised methods appear to outperform unsupervised methods.
*   There isn’t a standout pattern in grouped methods: the PCA-G significantly outperforms the PCA version, but there’s less of a difference between LR and LR-G.
*   LDA is an outlier, performing significantly worse than other probes. See [appendix](#Validating_LDA_implementation) for further investigation.

Examining dataset performance
-----------------------------

Similarly to above, we break down by what dataset the probe is trained on. 

![](https://lh7-us.googleusercontent.com/BcEjaQ8PrGJjgvLK7InXZWA2Ct8qbeh-__aayfSqD9eUl-DGvJ4rKeltPg3-bEyV-RGdbyFpBBBqLPNSjRnORbFC4KIG-nR92e6OXTsLpTyPTbE2b1J1EhIgCcHpAwd9BLxkiIEwOeqHQzW7S2wEApE)

Takeaways:

*   The DLK datasets generally perform better than RepE and GoT datasets.
*   Surprisingly, the got\_cities\_cities_conj dataset outperforms all other datasets, and has a huge margin over the other GoT datasets.
    *   My initial assumption was that the [threshold](#Recovered_accuracy) for this dataset was set very low, so all probes managed to meet it. This was not the case, the threshold is set to 99.3%.

We can also plot a “generalisation matrix” showing how well each dataset generalises to each other dataset.

![](https://lh7-us.googleusercontent.com/OgWJ4lORglnlBAgU-FoWAbINF8paZGlIIjMs2yKLZByGOUb9OhDthjSE8I0FbS1ZRfreomPoFPrMfVAyycFu8EcYFamDJVmnNH-skYzU4ePb5bbDIeAdA254rGpGRjTU5ck-6FvT2o_JHnopyNjf1i0)

*How well each training dataset generalises to different evaluation datasets. Metric is recovered accuracy averaged over layer and probe algorithm. We only look at layer>=13.*

There seems to be some structure here. We explore further by clustering the datasets, and find that they do form DLK, RepE, and GoT clusters:

  
 

![](https://lh7-us.googleusercontent.com/6OumK1JcDia9mNyjq2l2I0hmY7PQ-qxfd4DqvvGckJ0m6jeymNYCAqRAi7t4PphOuj4HUteLuKjr7Vo9Px_WWP7PNiUPtqFj4b4dG9COMQYW6J0PsUdreluyYMj5KExlE1IsdosguucP8BRb2k_JBTc)

*Agglomerative clustering of the datasets, where we use (1 - recovered accuracy) as the distance measure between datasets, and use average distances to merge clusters. We only look at layer>=13.*

Another interesting thing to look at is a comparison between how well a dataset *generalises to other datasets*, and how well other datasets *generalise to it*.

![](https://lh7-us.googleusercontent.com/hHNovBqY0hfEA-QTDOb2DhTbiDcRgw-g5YzXa7H6B26VRELOsWHvbiXfpJIh5flZMW6JPsvvb_8tDUR98lqTxWHw3A-3v5jt60dSqo1zhiWDZX8Mvp9-XxkWdEl74bsEN4ZcmpypSIcckZzLVxx74GY)

*Comparison of how well a dataset generalises to other datasets (generalizes\_from) and how well other datasets generalise to that dataset (generalises\_to). Mean recovered accuracy shown.*

  
 Takeaways:

*   DLK datasets are better than RepE and GoT on both generalising from and to.
*   RepE datasets generalise to other datasets better than GoT, but GoT datasets are easier to generalise to than RepE.
    *   Perhaps the DLK/GoT probes have overfit to the token where truth is established, and the RepE’s [prompt suffix](#Datasets) breaks this assumption.
*   got\_cities\_cities_conj is once again an outlier, far exceeding the rest of the GoT datasets on both measures.

How do we know we’re detecting truth, and not just likely statements?
---------------------------------------------------------------------

Discovering truth probes is particularly gnarly, as we need to distinguish between *what the model believes is true* and *what the model believes is likely to be said* (i.e. likely to be said by humans).

This distinction is hard to make. One good attempt at it is to measure probe performance on [TruthfulQA](https://arxiv.org/abs/2109.07958), which is a dataset designed to contain likely-sounding but untrue statements as answers (e.g. common misconceptions).

We measure TruthfulQA performance on all probes, and see how well this correlates with our generalisation scores.

![](https://lh7-us.googleusercontent.com/Ecdw3FmL50_tEHosZIDIKP7vY220uvT2Q5KASFqDWIgAgKQHCK0DXZFWe6rZ5lLDR32Qb3izNNQh5ETd8VTdr9htrJzgHzqTzRpDV9vnbdYiatmxkf5tlQC6GFm9P1SNzdxc8ORl4L6Jl7sLhncegTI)

*TruthfulQA accuracy against generalisation score of all probes trained. Dotted green line is the TruthfulQA score for Llama-2 13B chat. Dotted grey line is the same, but prompting for a calibrated score. Results taken from the RepE paper, *[*table 8*](https://arxiv.org/pdf/2310.01405.pdf#page=38)*.*

We find that 94.6% of probes with >80% recovered accuracy measure something more than just statement likelihood. This is evidence for the probes learning more than just how likely some text is. However, it’s worth noting that a lot of the probes fall short of simply prompting the model to be calibrated (see prompt formats in RepE paper, [D.3.2](https://arxiv.org/pdf/2310.01405.pdf#page=52)).

Conclusion & future work
========================

We find some probing methods with impressive generalisation, that appear to be measuring something more than truth. This is evidence for a generalised notion of truth in Llama-2-13B-chat.

The results above ask more questions than they answer:

*   Why do probes not generalise perfectly?
    *   Do they overfit to the interference from other features?
    *   Are some datasets biased in some way, skewing truth probes?
    *   Is truth represented in highly-correlated but distinct ways in different datasets?
*   What explains the variance in performance between probes?
*   Does training on multiple datasets improve performance?
*   Do smaller models also have a generalised notion of truth?
*   Why does got\_cities\_cities_conj generalise well?
*   Why does LDA generalise poorly?

There’s a lot of work to be done exploring generalisation in RepEng (and even more work to be done in RepEng generally!). Please reach out if you want to discuss further explorations, or have any interest in [related experiments](https://docs.google.com/document/u/0/d/1akOy08gvO25v7-lG4xjgOo6ZsXrzt5LXdpHULm5WS1Y/edit) in RepEng.

Appendix
========

Validating implementations
--------------------------

We validate the implementations in a few ways.

**Do we get 80% accuracy on arc_easy?** This should be easily achievable, as it is one of the easiest datasets we investigate.

![](https://lh7-us.googleusercontent.com/ulg7x7u8pZnP_5ve4Z6g1jqE7paS-pJxk0UjfnZDEflekJ8r1ps_q2LfcgoSiXLUwJSu9eEQdN43Uorl50OCR4DjyJZeUt3iVY9oFFZ0KcjNi1cZ8Crl64UyhacWytpI29tRzi1b9oCHVuStDkiOARg)

**Do we get ~100% accuracy on GoT datasets?** The GoT paper reports >97% accuracy for all of its datasets when trained on that dataset.

![](https://lh7-us.googleusercontent.com/vhlskCG7MjGNBROKtfFjeqlyc2eDZIp-zLP_OlW_0VEbS-o7y9iN-mlHvvCI-GqnfL1kVrT9F9pPCRb-smMV5in-KXraa4hllUXTezousIK2AxB7f47pwAbvCbdbXV9C2hm7J6LKmZLNM-iEFO__yd8)

**Can we reproduce accuracies from the RepE paper?** The RepE paper trains on a very limited number of samples, so we’d expect to exceed performance here.

![](https://lh7-us.googleusercontent.com/yG2g9GWphCTZnbQ27F3XRGRGhXe6mv8EPuoBdAtJpLy6fDz6WUuYjdLDoOMVFXpYWvH8djgEkiKSfm2RNvA3KitBxsTLEjb9jtoBSB26C6m-Q4W-gBK69aRLW9uz7JruK6NjYQ0E1xFL_lLLirIMl4s)

Validating LDA implementation
-----------------------------

Above, the LDA probe performs poorly. This hints at a bug. However, our [implementation](https://github.com/mishajw/repeng/blob/main/repeng/probes/linear_discriminant_analysis.py) simply calls out to scikit. We also find that the probe performs better than LDA in-distribution, but worse out-of-distribution:

![](https://lh7-us.googleusercontent.com/GVZFh0tdP9o1EkNGwjxH5JByEj-RJZcTRbnPrnwQdYVVhysxtdOQvYA5nX_3sh8gTFH04p74xzcfaxkjim_su9D_ZgMJ9v65HKxoI2ONBsmZ9u5YvPixEDhy7MinI_ItZIw03Lv0hTPWeA1O74pGg4c)

*Accuracy of DIM and LDA trained on boolq (type=train\_boolq) and when trained directly on the dataset (type=train\_eval). LDA outperforms DIM in-distribution, DIM outperforms LDA out-of-distribution.*

Thresholding
------------

To evaluate probe performance, we run the probe over activations from correct and incorrect statements, and check that the probe has higher “truth values” for correct statements. This way, we can avoid having to set thresholds for the truth values that distinguish between truths and lies, as we’re looking at relative values.

Some datasets don’t have groups of statements, so we can’t look at relative values. In this case, we take the best threshold using a [ROC curve](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and report accuracy from there. This is done for got\_cities\_cities\_conj and got\_cities\_cities\_disj.

[^g027webgyta]: What it really means for a language model to have a “notion” of “truth” is… poorly defined. Here, I mean this empirically: if the model says something that “it knows is not true” (i.e. something obviously contradicting its training data), does this always pass through the same “notion” (i.e. representation vector). 

[^9ap2ou7rf7i]: In the case of Llama-2, this is the residual stream after the MLP has been added to it. 

[^islv9quj2pa]: For unsupervised methods, we do technically use the labels in two places. One, we select the sign of the probe based on labels. Two, for some datasets, we only want one true and false answer each, while there may be many. We use the labels to limit to one each. 

[^w8aspy3zmq]: This probe doesn’t change if you make it grouped, as the diff-of-means is equal to the mean-of-diffs. 

[^kpb2a4mlia]: We go against the literature and call this PCA-G rather than CRC, to make the contrast with PCA clear. 

[^4bm4ocq47y2]: In cases where the Q&A dataset contains >2 answers, we take a single true and single false answer. 

[^q5o487leuua]: We differ slightly from the original GoT paper in naming, and use got_cities to refer to both the cities and neg_cities datasets. The same is true for sp_en_trans and larger_than. We don't do this for cities_cities_{conj,disj} and leave them unpaired. 

[^d5oro180xek]: Llama-2 13B has 40 layers. We take every fourth layer starting from the second and ending on the last.