ioi_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/amakelov/workspace/current/conda_envs/serimats/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from data_utils import *\n",
    "from data_utils import test_distribution\n",
    "from model_utils import *\n",
    "import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using pad_token, but it is not set yet.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded pretrained model gpt2-small into HookedTransformer\n"
     ]
    }
   ],
   "source": [
    "model = get_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "POSITION_SUBSPACE_PATH = 'subspaces/state_dict_head_outputs_1dim_922test.pt'\n",
    "rotation = RotationMatrix.load_rotation_old(path=POSITION_SUBSPACE_PATH, n=768)\n",
    "rotation.requires_grad_(False)\n",
    "POSITION_DIRECTION = rotation.R.weight.data[:, 0].detach().cuda()\n",
    "resid_node = Node('resid_post', layer=8, seq_pos=-1)\n",
    "mlp_node = Node('post', layer=8, seq_pos=-1)\n",
    "resid_node_mid = Node('resid_mid', layer=8, seq_pos=-1)\n",
    "NAME_MOVERS = [(9, 6), (9, 9), (10, 0)]\n",
    "BACKUP_NAME_MOVERS = [(9, 0), (9, 7), (10, 1), (10, 2), (10, 6), (10, 10), (11, 2), (11, 9)]\n",
    "\n",
    "# das directions\n",
    "das_mlp8 = torch.Tensor(joblib.load(filename='das_mlp8.joblib')).cuda()\n",
    "das_resid = POSITION_DIRECTION\n",
    "das_resid_mid = torch.Tensor(joblib.load(filename='das_resid_mid.joblib')).cuda()\n",
    "\n",
    "W_out = model.W_out[8]\n",
    "# Q is of shape (3072, 768), and the columns of Q are an orthonormal basis\n",
    "# for the rowspace of W_out\n",
    "Q, _ = torch.linalg.qr(W_out) \n",
    "das_mlp8_row = das_mlp8 @ Q @ Q.T\n",
    "das_mlp8_null = das_mlp8 - das_mlp8_row\n",
    "das_mlp8_row_unit = das_mlp8_row / das_mlp8_row.norm()\n",
    "das_mlp8_null_unit = das_mlp8_null / das_mlp8_null.norm()\n",
    "\n",
    "# gradients\n",
    "head_gs = joblib.load(filename='name_mover_gradients.joblib')\n",
    "head_gs = [torch.Tensor(g).cuda() for g in head_gs]\n",
    "summed_gradient = torch.Tensor(joblib.load(filename='summed_gradient.joblib')).cuda()\n",
    "\n",
    "# mean difference between ABB and BAB prompts\n",
    "v_mean = torch.Tensor(joblib.load(filename='v_mean.joblib')).cuda()\n",
    "\n",
    "### reproducible datasets to use for analysis\n",
    "random.seed(42)\n",
    "TEST_DATASET = test_distribution.sample_das(\n",
    "        model=model,\n",
    "        base_patterns=['ABB',],\n",
    "        source_patterns=['BAB'],\n",
    "        labels='position',\n",
    "        samples_per_combination=1_000,\n",
    "    )\n",
    "\n",
    "PATCHING_DATASET = test_distribution.sample_das(\n",
    "        model=model,\n",
    "        base_patterns=['ABB',],\n",
    "        source_patterns=['BAB'],\n",
    "        labels='position',\n",
    "        samples_per_combination=1_000,\n",
    "    ) + test_distribution.sample_das(\n",
    "        model=model,\n",
    "        base_patterns=['BAB',],\n",
    "        source_patterns=['ABB'],\n",
    "        labels='position',\n",
    "        samples_per_combination=1_000,\n",
    "    )\n",
    "\n",
    "TRAIN_DATASET = train_distribution.sample_das(\n",
    "        model=model,\n",
    "        base_patterns=['ABB',],\n",
    "        source_patterns=['BAB'],\n",
    "        labels='position',\n",
    "        samples_per_combination=1_000,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cosine similarity between DAS direction in residual stream and gradient of name mover heads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(-0.7823, device='cuda:0')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "das_resid @ summed_gradient\n",
    "torch.cosine_similarity(das_resid, summed_gradient, dim=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decomposing DAS-resid and gradient along name mover queries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decompose_resid_along_namemovers(v: Tensor):\n",
    "    WQs = [model.W_Q[layer, head] for layer, head in NAME_MOVERS] # each of shape (d_model, d_head)\n",
    "    WQ_concat = torch.cat(WQs, dim=1)\n",
    "    Q, _ = torch.linalg.qr(WQ_concat)\n",
    "    rowspace_component = v @ Q @ Q.T\n",
    "    nullspace_component = v - rowspace_component\n",
    "    return rowspace_component, nullspace_component\n",
    "\n",
    "das_resid_row, das_resid_null = decompose_resid_along_namemovers(das_resid)\n",
    "grad_row, grad_null = decompose_resid_along_namemovers(summed_gradient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "norm of das_resid_row: 0.9101414084434509\n",
      "norm of grad_row: 0.98272705078125\n"
     ]
    }
   ],
   "source": [
    "# both directions are significantly in the rowspace of the namemovers\n",
    "print(f'norm of das_resid_row: {das_resid_row.norm()}')\n",
    "print(f'norm of grad_row: {grad_row.norm()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Projections of prompts on the DAS resid and gradient directions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_all_hooks(model):\n",
    "    for _, submodule in model.named_modules():\n",
    "        submodule._forward_hooks.clear()\n",
    "\n",
    "def get_patching_acc_and_ld(patching_dataset: PatchingDataset,\n",
    "                            patcher: Patcher) -> Tuple[float, float]:\n",
    "    \"\"\"\n",
    "    Given a patcher, return the interchange accuracy and the logit difference on\n",
    "    the base dataset.\n",
    "    \"\"\"\n",
    "    patched_predictions = []\n",
    "    base_answer_logits_patched = []\n",
    "    for batch_ds in tqdm(patching_dataset.batches(batch_size=100, shuffle=False), total=len(patching_dataset) // 100):\n",
    "        _, _, _, logits_patched = patcher.run_patching(\n",
    "            model=model,\n",
    "            P_base=batch_ds.base.tokens,\n",
    "            P_source=batch_ds.source.tokens,\n",
    "            answer_tokens_base=batch_ds.base.answer_tokens,\n",
    "            answer_tokens_source=batch_ds.source.answer_tokens,\n",
    "            patched_answer_tokens=batch_ds.patched_answer_tokens,\n",
    "            return_full_patched_logits=True,\n",
    "        )\n",
    "        patched_predictions.append(logits_patched.argmax(dim=-1))\n",
    "        base_answer_logits_patched.append(logits_patched.gather(dim=1, index=batch_ds.base.answer_tokens.cuda()))\n",
    "    patched_predictions = torch.cat(patched_predictions)\n",
    "    interchange_accuracy = (patched_predictions == patching_dataset.patched_answer_tokens[:, 0].cuda()).float().mean().item()\n",
    "    base_answer_logits_patched = torch.cat(base_answer_logits_patched)\n",
    "    base_answers_logit_diff = (base_answer_logits_patched[:, 0] - base_answer_logits_patched[:, 1]).mean().item()\n",
    "    return interchange_accuracy, base_answers_logit_diff\n",
    "\n",
    "def get_resid_projections(v: Tensor, patching_dataset: PatchingDataset):\n",
    "    node = Node('resid_post', layer=8, seq_pos=-1)\n",
    "    prompts = np.concatenate([patching_dataset.base.prompts, patching_dataset.source.prompts], axis=0)\n",
    "    A = run_with_cache(prompts=prompts, nodes=[node], model=model, batch_size=100)[0]\n",
    "    projs = einsum(\"batch dim, dim -> batch\", A, v)\n",
    "    num_examples = len(patching_dataset.base.prompts)\n",
    "    return pd.DataFrame({\n",
    "        'pattern': ['ABB'] * num_examples + ['BAB'] * num_examples,\n",
    "        'projection': projs.cpu().numpy(),\n",
    "    })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:05<00:00,  3.72it/s]\n",
      "100%|██████████| 20/20 [00:05<00:00,  3.69it/s]\n"
     ]
    }
   ],
   "source": [
    "gradient_projs = get_resid_projections(patching_dataset=TEST_DATASET, v=summed_gradient)\n",
    "das_resid_projs = get_resid_projections(patching_dataset=TEST_DATASET, v=das_resid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradient_projs['direction'] = 'grad'\n",
    "das_resid_projs['direction'] = 'das'\n",
    "resid_projs_df = pd.concat([gradient_projs, das_resid_projs], ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set_theme()\n",
    "\n",
    "for direction in ('grad', 'das'):\n",
    "    # make a high-res plot\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    ax = sns.histplot(\n",
    "        data=resid_projs_df.query(f'direction == \"{direction}\"'),\n",
    "        x='projection',\n",
    "        hue='pattern',\n",
    "        # do not stack, but overlap them\n",
    "        multiple='layer',\n",
    "        bins=100,\n",
    "        stat='count',\n",
    "        common_norm=False,\n",
    "        element='bars',\n",
    "        fill=True,\n",
    "        alpha=0.5,\n",
    "        legend=True,\n",
    "    )\n",
    "    # plt.legend(title='Pattern', title_fontsize=24, fontsize=20,)\n",
    "    # set the x-axis limits\n",
    "    # increase title font size\n",
    "    # remove the labels of the x and y axes\n",
    "    ax.set_xlabel(None)\n",
    "    ax.set_ylabel(None)\n",
    "    # increase font of the tikz on the axes\n",
    "    ax.tick_params(axis='both', which='major', labelsize=20)\n",
    "    plt.setp(ax.get_legend().get_texts(), fontsize='30') # for legend text\n",
    "    plt.setp(ax.get_legend().get_title(), fontsize='36') # for legend title\n",
    "    plt.savefig(f'figures/resid_projs_{direction}.pdf', format='pdf')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sanity check: can we predict S or IO names from projections on DAS resid?\n",
    "If this direction encodes only name information, there should be no signal there\n",
    "about names in the sentence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:05<00:00,  3.68it/s]\n"
     ]
    }
   ],
   "source": [
    "das_resid_projs_df = get_resid_projections(patching_dataset=TRAIN_DATASET, v=das_resid)\n",
    "das_resid_projs = das_resid_projs_df['projection'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train acc: 0.01875\n",
      "Test acc: 0.005\n",
      "Train acc: 0.024375\n",
      "Test acc: 0.0075\n"
     ]
    }
   ],
   "source": [
    "### check if we can predict the S or IO name from the projections on DAS resid (we can't)\n",
    "io_names = [p.io_name for p in TRAIN_DATASET.base.prompts] + [p.io_name for p in TRAIN_DATASET.source.prompts]\n",
    "s_names = [p.s_name for p in TRAIN_DATASET.base.prompts] + [p.s_name for p in TRAIN_DATASET.source.prompts]\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X = das_resid_projs.reshape(-1, 1)\n",
    "for y in (io_names, s_names):\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0, )\n",
    "    clf = LogisticRegression(random_state=0, max_iter=1_000).fit(X_train, y_train)\n",
    "    print(f'Train acc: {clf.score(X_train, y_train)}')\n",
    "    print(f'Test acc: {clf.score(X_test, y_test)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code for Table 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_patch_metrics(patching_dataset: PatchingDataset,):\n",
    "    \"\"\"\n",
    "    Compute the following quantities:\n",
    "        - the components of das_mlp8 along the nullspace and rowspace of W_out,\n",
    "          and their norms;\n",
    "        - the logit difference when we only patch the rowspace component\n",
    "        - a histogram showing ABB vs BAB prompts on the nullspace component\n",
    "        - a histogram showing ABB vs BAB prompts on the rowspace component\n",
    "        - the cosine similarity between das_mlp8 @ W_out and true_subspace\n",
    "        - a histogram of ABB vs BAB prompts on true_subspace\n",
    "        - a histogram of ABB vs BAB prompts on das_mlp8 @ W_out \n",
    "        - a histogram of ABB vs BAB after patching along das_mlp8\n",
    "        \n",
    "        - a table of the logit differences and interchange accuracies for:\n",
    "            - the MLP8 direction\n",
    "            - the rowspace component of the MLP8 direction only\n",
    "            - the resid direction\n",
    "    \"\"\"\n",
    "    print(f'norm of das_mlp8_row: {das_mlp8_row.norm()}')\n",
    "    print(f'norm of das_mlp8_null: {das_mlp8_null.norm()}')\n",
    "    print(f'Check that das_mlp8_row and das_mlp8_null are orthogonal: {das_mlp8_row @ das_mlp8_null}')\n",
    "    print(f'Check that das_mlp8_null is in the nullspace of W_out: '\n",
    "          f'{torch.allclose(das_mlp8_null @ W_out, torch.zeros(768).cuda(), atol=1e-5)}')\n",
    "        \n",
    "    aggregate_metrics_rows = []\n",
    "    \n",
    "    ############################################################################ \n",
    "    ### compute clean predictions\n",
    "    ############################################################################ \n",
    "    clean_predictions = run_with_hooks(prompts=patching_dataset.base.prompts, \n",
    "                                  hooks=[], model=model, batch_size=100, \n",
    "                                  answer_tokens=patching_dataset.base.answer_tokens.cuda(),\n",
    "                                  return_predictions=True)\n",
    "    clean_logits = run_with_hooks(prompts=patching_dataset.base.prompts, hooks=[], model=model, batch_size=100,\n",
    "                    answer_tokens=patching_dataset.base.answer_tokens.cuda())\n",
    "    clean_accuracy = (clean_predictions == patching_dataset.base.answer_tokens[:, 0].cuda()).float().mean().item()\n",
    "    clean_logit_diff = (clean_logits[:, 0] - clean_logits[:, 1]).mean().item()\n",
    "    print(f'clean accuracy: {clean_accuracy}')\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'clean',\n",
    "        'accuracy': 0.0,\n",
    "        'logit_diff': clean_logit_diff,\n",
    "    })\n",
    "\n",
    "    ############################################################################ \n",
    "    ### intervention: full resid replace\n",
    "    ############################################################################ \n",
    "    full_resid_patcher = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=Full(),\n",
    "    )\n",
    "    patched_acc_resid_full, logit_diff_resid_full = get_patching_acc_and_ld(\n",
    "        patcher=full_resid_patcher,\n",
    "        patching_dataset=patching_dataset,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'full resid_post.8 patch',\n",
    "        'accuracy': patched_acc_resid_full,\n",
    "        'logit_diff': logit_diff_resid_full,\n",
    "    })\n",
    "\n",
    "    ############################################################################ \n",
    "    ### compute resid predictions and logit diff\n",
    "    ############################################################################ \n",
    "    resid_patcher = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=DirectionPatch(v=das_resid),\n",
    "    )\n",
    "    patched_accuracy_resid, logit_diff_resid = get_patching_acc_and_ld(\n",
    "        patching_dataset=patching_dataset,\n",
    "        patcher=resid_patcher,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'DAS resid_post.8',\n",
    "        'accuracy': patched_accuracy_resid,\n",
    "        'logit_diff': logit_diff_resid,\n",
    "    })\n",
    "    \n",
    "    resid_row, resid_null = decompose_resid_along_namemovers(v=das_resid)\n",
    "    resid_row_unit = resid_row / resid_row.norm()\n",
    "    resid_patcher_rowspace = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=DirectionPatch(v=resid_row_unit),\n",
    "    )\n",
    "    patched_accuracy_resid_row, logit_diff_resid_row = get_patching_acc_and_ld(\n",
    "        patching_dataset=patching_dataset,\n",
    "        patcher=resid_patcher_rowspace,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'DAS resid_post.8 along name movers',\n",
    "        'accuracy': patched_accuracy_resid_row,\n",
    "        'logit_diff': logit_diff_resid_row,\n",
    "    })\n",
    "\n",
    "    resid_null_unit = resid_null / resid_null.norm()\n",
    "    resid_patcher_nullspace = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=DirectionPatch(v=resid_null_unit),\n",
    "    )\n",
    "    patched_accuracy_resid_null, logit_diff_resid_null = get_patching_acc_and_ld(\n",
    "        patching_dataset=patching_dataset,\n",
    "        patcher=resid_patcher_nullspace,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'DAS resid_post.8 along nullspace',\n",
    "        'accuracy': patched_accuracy_resid_null,\n",
    "        'logit_diff': logit_diff_resid_null,\n",
    "    })\n",
    "\n",
    "    ############################################################################ \n",
    "    ### compute grad predictions and logit diff\n",
    "    ############################################################################ \n",
    "    grad_patcher = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=DirectionPatch(v=summed_gradient),\n",
    "    )\n",
    "    patched_accuracy_grad, logit_diff_grad = get_patching_acc_and_ld(\n",
    "        patching_dataset=patching_dataset,\n",
    "        patcher=grad_patcher,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'grad resid_post.8',\n",
    "        'accuracy': patched_accuracy_grad,\n",
    "        'logit_diff': logit_diff_grad,\n",
    "    })\n",
    "    \n",
    "    grad_row, grad_null = decompose_resid_along_namemovers(v=summed_gradient)\n",
    "    grad_row_unit = grad_row / grad_row.norm()\n",
    "    grad_patcher_rowspace = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=DirectionPatch(v=grad_row_unit),\n",
    "    )\n",
    "    patched_accuracy_grad_row, logit_diff_grad_row = get_patching_acc_and_ld(\n",
    "        patching_dataset=patching_dataset,\n",
    "        patcher=grad_patcher_rowspace,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'grad resid_post.8 along name movers',\n",
    "        'accuracy': patched_accuracy_grad_row,\n",
    "        'logit_diff': logit_diff_grad_row,\n",
    "    })\n",
    "\n",
    "    grad_null_unit = grad_null / grad_null.norm()\n",
    "    grad_patcher_nullspace = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=DirectionPatch(v=grad_null_unit),\n",
    "    )\n",
    "    patched_accuracy_grad_null, logit_diff_grad_null = get_patching_acc_and_ld(\n",
    "        patching_dataset=patching_dataset,\n",
    "        patcher=grad_patcher_nullspace,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'grad resid_post.8 along nullspace',\n",
    "        'accuracy': patched_accuracy_grad_null,\n",
    "        'logit_diff': logit_diff_grad_null,\n",
    "    })\n",
    "\n",
    "    ############################################################################ \n",
    "    ### patch along projection of mean diff direction onto namemovers\n",
    "    ############################################################################ \n",
    "    mean_diff_row, mean_diff_null = decompose_resid_along_namemovers(v=v_mean)\n",
    "    mean_diff_row_unit = mean_diff_row / mean_diff_row.norm()\n",
    "    mean_diff_patcher_row = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=DirectionPatch(v=mean_diff_row_unit),\n",
    "    )\n",
    "    mean_diff_patcher_full = Patcher(\n",
    "        nodes=[resid_node],\n",
    "        patch_impl=DirectionPatch(v=v_mean),\n",
    "    )\n",
    "    patched_accuracy_mean_diff_row, logit_diff_mean_diff_row = get_patching_acc_and_ld(\n",
    "        patching_dataset=patching_dataset,\n",
    "        patcher=mean_diff_patcher_row,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'mean diff of ABB vs BAB along name movers',\n",
    "        'accuracy': patched_accuracy_mean_diff_row,\n",
    "        'logit_diff': logit_diff_mean_diff_row,\n",
    "    })\n",
    "\n",
    "    patched_accuracy_mean_diff_full, logit_diff_mean_diff_full = get_patching_acc_and_ld(\n",
    "        patching_dataset=patching_dataset,\n",
    "        patcher=mean_diff_patcher_full,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'mean diff of ABB vs BAB',\n",
    "        'accuracy': patched_accuracy_mean_diff_full,\n",
    "        'logit_diff': logit_diff_mean_diff_full,\n",
    "    })\n",
    "\n",
    "    ############################################################################ \n",
    "    ### patching the full MLP8 direction\n",
    "    ############################################################################ \n",
    "    das_mlp8_patcher = Patcher(\n",
    "        nodes=[mlp_node],\n",
    "        patch_impl=DirectionPatch(v=das_mlp8),\n",
    "    )\n",
    "    patched_accuracy_das_mlp8, das_mlp8_logit_diff = get_patching_acc_and_ld(\n",
    "        patcher=das_mlp8_patcher,\n",
    "        patching_dataset=patching_dataset,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'DAS MLP8 direction',\n",
    "        'accuracy': patched_accuracy_das_mlp8,\n",
    "        'logit_diff': das_mlp8_logit_diff,\n",
    "    })\n",
    "    \n",
    "    ############################################################################ \n",
    "    ### patching only the rowspace component\n",
    "    ############################################################################ \n",
    "    rowspace_patcher = Patcher(\n",
    "        nodes=[mlp_node],\n",
    "        patch_impl=DirectionPatch(v=das_mlp8_row_unit),\n",
    "    )\n",
    "    patched_accuracy_rowspace, rowspace_logit_diff = get_patching_acc_and_ld(\n",
    "        patcher=rowspace_patcher,\n",
    "        patching_dataset=patching_dataset,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'DAS MLP8 rowspace component',\n",
    "        'accuracy': patched_accuracy_rowspace,\n",
    "        'logit_diff': rowspace_logit_diff,\n",
    "    })\n",
    "\n",
    "    ### patch only nullspace component\n",
    "    nullspace_patcher = Patcher(\n",
    "        nodes=[mlp_node],\n",
    "        patch_impl=DirectionPatch(v=das_mlp8_null_unit),\n",
    "    )\n",
    "    patched_accuracy_nullspace, nullspace_logit_diff = get_patching_acc_and_ld(\n",
    "        patcher=nullspace_patcher,\n",
    "        patching_dataset=patching_dataset,\n",
    "    )\n",
    "    aggregate_metrics_rows.append({\n",
    "        'intervention': 'DAS MLP8 nullspace component',\n",
    "        'accuracy': patched_accuracy_nullspace,\n",
    "        'logit_diff': nullspace_logit_diff,\n",
    "    })\n",
    "\n",
    "    aggregate_metrics_df = pd.DataFrame(aggregate_metrics_rows)\n",
    "    return aggregate_metrics_df\n",
    "\n",
    "def compute_full_mlp8_patch(patching_dataset: PatchingDataset):\n",
    "    ############################################################################\n",
    "    ### full MLP8 patch\n",
    "    ############################################################################\n",
    "    full_mlp_patcher = Patcher(\n",
    "        nodes=[mlp_node],\n",
    "        patch_impl=Full()\n",
    "    )\n",
    "    patched_accuracy_full_mlp, full_mlp_logit_diff = get_patching_acc_and_ld(\n",
    "        patcher=full_mlp_patcher,\n",
    "        patching_dataset=patching_dataset,\n",
    "    )\n",
    "    return patched_accuracy_full_mlp, full_mlp_logit_diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:19<00:00,  1.05it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.003000000026077032, 3.631676435470581)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_full_mlp8_patch(patching_dataset=PATCHING_DATASET)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "norm of das_mlp8_row: 0.7532718777656555\n",
      "norm of das_mlp8_null: 0.6570469737052917\n",
      "Check that das_mlp8_row and das_mlp8_null are orthogonal: -1.3737007975578308e-08\n",
      "Check that das_mlp8_null is in the nullspace of W_out: True\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:05<00:00,  3.49it/s]\n",
      "100%|██████████| 20/20 [00:05<00:00,  3.55it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "clean accuracy: 0.9155000448226929\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:18<00:00,  1.07it/s]\n",
      "100%|██████████| 20/20 [00:19<00:00,  1.02it/s]\n",
      "100%|██████████| 20/20 [00:20<00:00,  1.00s/it]\n",
      "100%|██████████| 20/20 [00:18<00:00,  1.07it/s]\n",
      "100%|██████████| 20/20 [00:18<00:00,  1.06it/s]\n",
      "100%|██████████| 20/20 [00:19<00:00,  1.03it/s]\n",
      "100%|██████████| 20/20 [00:19<00:00,  1.05it/s]\n",
      "100%|██████████| 20/20 [00:19<00:00,  1.04it/s]\n",
      "100%|██████████| 20/20 [00:19<00:00,  1.04it/s]\n",
      "100%|██████████| 20/20 [00:20<00:00,  1.00s/it]\n",
      "100%|██████████| 20/20 [00:19<00:00,  1.04it/s]\n",
      "100%|██████████| 20/20 [00:18<00:00,  1.07it/s]\n"
     ]
    }
   ],
   "source": [
    "metrics_df = compute_patch_metrics(patching_dataset=PATCHING_DATASET)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# joblib.dump(metrics_df, 'patching_metrics_ioi.joblib')\n",
    "metrics_df = joblib.load('patching_metrics_ioi.joblib')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def include_fractional_ld(df):\n",
    "    df = df.copy()\n",
    "    clean_ld = df.query('intervention == \"clean\"')['logit_diff'].item()\n",
    "    df['FLDD'] = df['logit_diff'].apply(lambda x: np.round(100 * (1 - x / clean_ld), 2))\n",
    "    return df\n",
    "metrics_df = include_fractional_ld(metrics_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>intervention</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>logit_diff</th>\n",
       "      <th>FLDD</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>clean</td>\n",
       "      <td>0.000</td>\n",
       "      <td>3.364</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>full resid_post.8 patch</td>\n",
       "      <td>0.544</td>\n",
       "      <td>-0.723</td>\n",
       "      <td>121.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>DAS resid_post.8</td>\n",
       "      <td>0.737</td>\n",
       "      <td>-1.309</td>\n",
       "      <td>138.92</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DAS resid_post.8 along name movers</td>\n",
       "      <td>0.618</td>\n",
       "      <td>-0.874</td>\n",
       "      <td>125.98</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>DAS resid_post.8 along nullspace</td>\n",
       "      <td>0.006</td>\n",
       "      <td>2.906</td>\n",
       "      <td>13.60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>grad resid_post.8</td>\n",
       "      <td>0.431</td>\n",
       "      <td>-0.320</td>\n",
       "      <td>109.52</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>grad resid_post.8 along name movers</td>\n",
       "      <td>0.387</td>\n",
       "      <td>-0.151</td>\n",
       "      <td>104.49</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>grad resid_post.8 along nullspace</td>\n",
       "      <td>0.004</td>\n",
       "      <td>3.290</td>\n",
       "      <td>2.20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>mean diff of ABB vs BAB along name movers</td>\n",
       "      <td>0.454</td>\n",
       "      <td>-0.408</td>\n",
       "      <td>112.14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>mean diff of ABB vs BAB</td>\n",
       "      <td>0.523</td>\n",
       "      <td>-0.650</td>\n",
       "      <td>119.33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>DAS MLP8 direction</td>\n",
       "      <td>0.043</td>\n",
       "      <td>1.821</td>\n",
       "      <td>45.87</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>DAS MLP8 rowspace component</td>\n",
       "      <td>0.007</td>\n",
       "      <td>2.918</td>\n",
       "      <td>13.24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>DAS MLP8 nullspace component</td>\n",
       "      <td>0.003</td>\n",
       "      <td>3.364</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                 intervention  accuracy  logit_diff    FLDD\n",
       "0                                       clean     0.000       3.364    0.00\n",
       "1                     full resid_post.8 patch     0.544      -0.723  121.50\n",
       "2                            DAS resid_post.8     0.737      -1.309  138.92\n",
       "3          DAS resid_post.8 along name movers     0.618      -0.874  125.98\n",
       "4            DAS resid_post.8 along nullspace     0.006       2.906   13.60\n",
       "5                           grad resid_post.8     0.431      -0.320  109.52\n",
       "6         grad resid_post.8 along name movers     0.387      -0.151  104.49\n",
       "7           grad resid_post.8 along nullspace     0.004       3.290    2.20\n",
       "8   mean diff of ABB vs BAB along name movers     0.454      -0.408  112.14\n",
       "9                     mean diff of ABB vs BAB     0.523      -0.650  119.33\n",
       "10                         DAS MLP8 direction     0.043       1.821   45.87\n",
       "11                DAS MLP8 rowspace component     0.007       2.918   13.24\n",
       "12               DAS MLP8 nullspace component     0.003       3.364    0.00"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics_df.round(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code for figure 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def histograms(patching_dataset, true_subspace):\n",
    "    ############################################################################ \n",
    "    ### histograms within MLP8\n",
    "    ############################################################################ \n",
    "    # mlp_activations = run_with_cache(\n",
    "    #   prompts=patching_dataset.base.prompts,\n",
    "    #   batch_size=100,\n",
    "    #   model=model, \n",
    "    #   nodes=[mlp_node],\n",
    "    # )[0]\n",
    "    # activation_mean_diff_mlp8 = mlp_activations[:num_examples].mean() - mlp_activations[num_examples:].mean()\n",
    "    # # print(f'Cosine sim between nullspace direction and activation mean diff: '\n",
    "    # #         f'{torch.cosine_similarity(das_null_unit, activation_mean_diff_mlp8, dim=0)}')\n",
    "    # # print(f'Cosine sim between rowspace direction and activation mean diff: '\n",
    "    # #         f'{torch.cosine_similarity(das_row_unit, activation_mean_diff_mlp8, dim=0)}')\n",
    "    # acts_at_row = einsum('batch d_mlp, d_mlp -> batch', mlp_activations, das_row_unit)\n",
    "    # acts_at_null = einsum('batch d_mlp, d_mlp -> batch', mlp_activations, das_null_unit)\n",
    "    # row_df = pd.DataFrame({\n",
    "    #     'value': acts_at_row.cpu(),\n",
    "    #     'variable': 'row',\n",
    "    #     'pattern': ['ABB'] * num_examples + ['BAB'] * num_examples,\n",
    "    # }) \n",
    "    # null_df = pd.DataFrame({\n",
    "    #     'value': acts_at_null.cpu(),\n",
    "    #     'variable': 'null',\n",
    "    #     'pattern': ['ABB'] * num_examples + ['BAB'] * num_examples,\n",
    "    # })\n",
    "    # df_within_mlp8 = pd.concat([row_df, null_df])\n",
    "\n",
    "    ############################################################################     \n",
    "    ### histograms onto true subspace direction in the residual stream\n",
    "    ############################################################################     \n",
    "    mlp_out_node = Node('mlp_out', layer=8, seq_pos=-1)\n",
    "\n",
    "    ### first, see what this looks like under normal conditions\n",
    "    num_examples = len(patching_dataset.base.prompts) // 2\n",
    "    mlp_out_activations = run_with_cache(\n",
    "        prompts=patching_dataset.base.prompts,\n",
    "        batch_size=100,\n",
    "        model=model,\n",
    "        nodes=[mlp_out_node],\n",
    "    )[0]\n",
    "    df_mlp_out_normal = pd.DataFrame({\n",
    "        'value': einsum('batch d_model, d_model -> batch', mlp_out_activations, true_subspace).cpu(),\n",
    "        'variable': 'normal',\n",
    "        'pattern': ['ABB'] * num_examples + ['BAB'] * num_examples,\n",
    "    })\n",
    "\n",
    "    das_mlp8_patcher = Patcher(\n",
    "        nodes=[mlp_node],\n",
    "        patch_impl=DirectionPatch(v=das_mlp8),\n",
    "    )\n",
    "    ### now, see what this looks like after patching\n",
    "    mlp_out_patched_activations = das_mlp8_patcher.get_patched_activation(\n",
    "        model=model,\n",
    "        node=mlp_out_node,\n",
    "        X_base=patching_dataset.base.tokens,\n",
    "        X_source=patching_dataset.source.tokens,\n",
    "        batch_size=100,\n",
    "        cache_base=None, \n",
    "        cache_source=None,\n",
    "    )\n",
    "    df_mlp_out_patched = pd.DataFrame({\n",
    "        'value': einsum('batch d_model, d_model -> batch', mlp_out_patched_activations, true_subspace).cpu(),\n",
    "        'variable': 'patched',\n",
    "        'pattern': ['BAB -> ABB'] * num_examples + ['ABB -> BAB'] * num_examples,\n",
    "    })\n",
    "    df_mlp_out = pd.concat([df_mlp_out_normal, df_mlp_out_patched])\n",
    "    return df_mlp_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:05<00:00,  3.67it/s]\n",
      "100%|██████████| 20/20 [00:15<00:00,  1.31it/s]\n"
     ]
    }
   ],
   "source": [
    "df_mlp_out = histograms(PATCHING_DATASET, summed_gradient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_theme()\n",
    "# make a high-res plot\n",
    "plt.figure(figsize=(10, 10))\n",
    "ax = sns.histplot(\n",
    "    data=df_mlp_out,\n",
    "    x='value',\n",
    "    hue='pattern',\n",
    "    # do not stack, but overlap them\n",
    "    # multiple='layer',\n",
    "    bins=100,\n",
    "    stat='count',\n",
    "    # common_norm=False,\n",
    "    element='bars',\n",
    "    fill=True,\n",
    "    # put the legend  in the upper left corner\n",
    "    alpha=0.5,\n",
    ")\n",
    "# do the legend manually, using values from the \"pattern\" column\n",
    "from matplotlib.patches import Patch\n",
    "ax.legend(\n",
    "    handles=[\n",
    "        Patch(facecolor='C0', label='ABB (no intervention)'),\n",
    "        Patch(facecolor='C1', label='BAB (no intervention)'),\n",
    "        Patch(facecolor='C2', label='patch BAB -> ABB'),\n",
    "        Patch(facecolor='C3', label='patch ABB -> BAB'),\n",
    "    ],\n",
    "    title='Input',\n",
    "    title_fontsize=24,\n",
    "    fontsize=18,\n",
    "    loc='upper left',\n",
    "    bbox_to_anchor=(0.0, 1.0),\n",
    "    ncol=1,\n",
    ")\n",
    "# set the x-axis limits\n",
    "# ax.set_xlim(-1.5, 3.0)\n",
    "# ax.set_title('Output of MLP8 projected onto ground truth subspace')\n",
    "# increase title font size\n",
    "# remove the labels of the x and y axes\n",
    "ax.set_xlabel(None)\n",
    "ax.set_ylabel(None)\n",
    "# increase font of the tikz on the axes\n",
    "ax.tick_params(axis='both', which='major', labelsize=20)\n",
    "# increase legend font size\n",
    "# plt.setp(ax.get_legend().get_texts(), fontsize='30') # for legend text\n",
    "# plt.setp(ax.get_legend().get_title(), fontsize='36') # for legend title\n",
    "plt.savefig(f'figures/mlp_output_histograms.pdf', format='pdf')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.12",
   "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.10.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "fd8dbfdfd1a6a4c5f3a98a8b5f239185c4ac44e8c535538c941237e2ab93d1b0"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}