{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "66a4b111-2ed8-402d-a3bf-16ddedeb1db2",
   "metadata": {},
   "source": [
    "### Initial Demonstrations of Tangermeme\n",
    "\n",
    "As an initial demonstration of the capabilities of tangermeme, we showed off the timings for one-hot encoding the entirety of chr1, how to avoid silent failures when running DeepLIFT/SHAP with unregistered model components, and how operations can be stacked on each other to decompose the sequence manipulation and the model operation step."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3090022f-0212-43f8-8657-6ed7593d5333",
   "metadata": {},
   "source": [
    "#### One-Hot Encoding Timings\n",
    "\n",
    "First, we timed various implementations of one-hot encodings across packages. To demonstrate the a compute-intensive case, we show the time it takes to one-hot encode the entire human genome. To avoid differences in whether an implementation is multi-threaded or single-threaded, we forced using only a single thread. Part of the reasoning here is because multi-threaded implementations will have vastly different performance profiles depending on the hardware of the user (not only the number of CPUs/threads but also how well thread communication is handled) and so limiting to a single thread provides a fairer comparison. \n",
    "\n",
    "Because some of the evaluations below take quite some time to perform repeatedly, we have commented out the actual calls to those functions and instead read in pre-computed results. However, this still shows how long each of the functions takes and what our procedure for calling those functions is. Feel free the uncomment those lines to perform the timings yourself on your hardware.\n",
    "\n",
    "Let's start off by loading up chr1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3b75ef50-25c8-445f-8eef-f14f5ece6312",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "248956422\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "\n",
    "import pyfaidx\n",
    "import numba\n",
    "numba.set_num_threads(1)\n",
    "\n",
    "\n",
    "fa = pyfaidx.Fasta(\"/users/jacob.schreiber/common/hg38.fa\")\n",
    "X = fa['chr1'][:].seq.upper()\n",
    "print(len(X))\n",
    "\n",
    "n_repeats = 10\n",
    "timings = numpy.zeros((6, n_repeats), dtype=numpy.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aaf6e84-c9b1-4896-8666-684d2e432499",
   "metadata": {},
   "source": [
    "Now, let's create a general-purpose timing wrapper that takes in the function and runs it a specified number of times. Having a wrapper function like this will diminish the potential for errors across comparisons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "08acf7e7-5b94-46b6-b835-1b2c051d791d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def time_function(f, X, n_repeats):\n",
    "    timings = numpy.zeros(n_repeats)\n",
    "    f(X)\n",
    "    \n",
    "    for i in range(n_repeats):\n",
    "        tic = time.time()\n",
    "        \n",
    "        f(X)\n",
    "        \n",
    "        timings[i] = time.time() - tic\n",
    "    \n",
    "    return timings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a035db33-05c9-4722-9f81-623b34457faf",
   "metadata": {},
   "source": [
    "First, we will time tangermeme. Remember that we have commented out the actual running of the function and so the time is incorrectly shown as \"0.0\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d86435a6-1959-4526-bbcb-322925c2f80f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 0.0)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tangermeme.utils import one_hot_encode\n",
    "\n",
    "#timings[0] = time_function(one_hot_encode, X, n_repeats=n_repeats)\n",
    "timings[0].mean().item(), timings[0].std().item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d182d1d-56ce-40cb-82aa-884a6188cb4f",
   "metadata": {},
   "source": [
    "Next, we will look at SeqPro. Doing a one-hot encoding with SeqPro requires creating a `NucleotideAlphabet` object that then has a `ohe` method. Creating this object does not take that much time, but we will exclude this time from the actual comparison. This slightly disadvantages tangermeme, which still has to figure out what to do with an alphabet of letters as part of the running time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "29f07986-83a3-4340-8951-ef26695ff4df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 0.0)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from seqpro.alphabets import NucleotideAlphabet\n",
    "\n",
    "n = NucleotideAlphabet(\"ACGT\", \"TGCA\")\n",
    "\n",
    "#timings[1] = time_function(n.ohe, X, n_repeats=n_repeats)\n",
    "timings[1].mean().item(), timings[1].std().item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c11c46a9-9bd5-4198-b797-5e568042435f",
   "metadata": {},
   "source": [
    "Next, we will compare against crested, which also has a one-hot encoding function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3ed6b01a-ef76-4864-967f-e7058065560f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 0.0)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from crested.utils import one_hot_encode_sequence\n",
    "\n",
    "#timings[2] = time_function(one_hot_encode_sequence, X, n_repeats=n_repeats)\n",
    "timings[2].mean().item(), timings[1].std().item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07d9cea5-b1d8-4ec1-8ce0-db5167d01ac3",
   "metadata": {},
   "source": [
    "Next, we will compare against gReLU, which also has a one-hot encoding function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e84245fa-f3c4-4094-8372-8668c8e544c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/users/jacob.schreiber/anaconda3/envs/tangermeme/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"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.0, 0.0)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from grelu.sequence.format import strings_to_one_hot\n",
    "\n",
    "#timings[3] = time_function(strings_to_one_hot, X, n_repeats=n_repeats)\n",
    "timings[3].mean().item(), timings[1].std().item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a843db8f-6ba7-4cfe-b58e-b6c9748aad6a",
   "metadata": {},
   "source": [
    "Next, we will compare against selene, whose one-hot encoding function has to be wrapped to make it more compatible with our expected usage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a13ef8b9-88ce-4feb-ab0e-7bbdee61223a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 0.0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from selene_sdk.sequences.sequence import sequence_to_encoding\n",
    "\n",
    "BASE_TO_INDEX = {'A': 0, 'C': 1, 'G': 2, 'T': 3}\n",
    "BASES_ARR = ['A', 'C', 'G', 'T']\n",
    "\n",
    "selene_ohe = lambda x: sequence_to_encoding(x, BASE_TO_INDEX, BASES_ARR)\n",
    "\n",
    "#timings[4] = time_function(selene_ohe, X, n_repeats=n_repeats)\n",
    "timings[4].mean().item(), timings[3].std().item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be1208a6-c61e-433b-95a2-03077ef7a13e",
   "metadata": {},
   "source": [
    "Finally, we will compare against the one-hot encoding function in the official ChromBPNet repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d47fbcec-3649-42f3-aab1-800b4a6411d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 0.0)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def chrombpnet_dna_to_one_hot(seqs):\n",
    "    \"\"\"\n",
    "    Converts a list of DNA (\"ACGT\") sequences to one-hot encodings, where the\n",
    "    position of 1s is ordered alphabetically by \"ACGT\". `seqs` must be a list\n",
    "    of N strings, where every string is the same length L. Returns an N x L x 4\n",
    "    NumPy array of one-hot encodings, in the same order as the input sequences.\n",
    "    All bases will be converted to upper-case prior to performing the encoding.\n",
    "    Any bases that are not \"ACGT\" will be given an encoding of all 0s.\n",
    "    \"\"\"\n",
    "    seq_len = len(seqs[0])\n",
    "    assert np.all(np.array([len(s) for s in seqs]) == seq_len)\n",
    "\n",
    "    # Join all sequences together into one long string, all uppercase\n",
    "    seq_concat = \"\".join(seqs).upper() + \"ACGT\"\n",
    "    # Add one example of each base, so np.unique doesn't miss indices later\n",
    "\n",
    "    one_hot_map = np.identity(5)[:, :-1].astype(np.int8)\n",
    "\n",
    "    # Convert string into array of ASCII character codes;\n",
    "    base_vals = np.frombuffer(bytearray(seq_concat, \"utf8\"), dtype=np.int8)\n",
    "\n",
    "    # Anything that's not an A, C, G, or T gets assigned a higher code\n",
    "    base_vals[~np.isin(base_vals, np.array([65, 67, 71, 84]))] = 85\n",
    "\n",
    "    # Convert the codes into indices in [0, 4], in ascending order by code\n",
    "    _, base_inds = np.unique(base_vals, return_inverse=True)\n",
    "\n",
    "    # Get the one-hot encoding for those indices, and reshape back to separate\n",
    "    return one_hot_map[base_inds[:-4]].reshape((len(seqs), seq_len, 4))\n",
    "\n",
    "#timings[5] = time_function(chrombpnet_dna_to_one_hot, X, n_repeats=n_repeats)\n",
    "timings[5].mean().item(), timings[4].std().item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfee4297-7183-46ce-a1b1-7da75846e55a",
   "metadata": {},
   "source": [
    "Be careful here -- we can either save the timings (commented out by default) or load the pre-calculated ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1bd7e8f1-80bf-458a-9095-b00256ae10ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "#numpy.save(\"ohe_timings.npy\", timings)\n",
    "timings = numpy.load(\"ohe_timings.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8d27757-834c-429e-b0ce-c12d75c8eb36",
   "metadata": {},
   "source": [
    "Now, we can plot the mean and standard deviation of each run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3bafcf6b-9328-4cb5-bd58-54c1fdc1c26c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "matplotlib.use('pdf')\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set_style('whitegrid')\n",
    "\n",
    "colors = ['#FCAE7C', '#F9FFB5', '#D6F6FF', '#B3F5BC', '#FD706B', '#D18DFF']\n",
    "names = ['tangermeme', 'SeqPro', 'CREsted', 'gReLU', 'Selene SDK', 'ChromBPNet']\n",
    "t = timings.mean(axis=1)\n",
    "\n",
    "plt.figure(figsize=(3, 3))\n",
    "plt.bar(range(6), t, facecolor=colors, edgecolor='0.2')\n",
    "plt.errorbar(range(6), t, yerr=timings.std(axis=1), fmt='none', c='k', barsabove=True)\n",
    "\n",
    "for i in range(timings.shape[0]):\n",
    "    plt.text(i-0.25, 11, s=\"{:3.3}\".format(t[i]), fontsize=7)\n",
    "\n",
    "plt.title(\"One-Hot Encode chr1\", fontsize=10)\n",
    "plt.ylabel(\"Time (s)\", fontsize=8)\n",
    "plt.xticks(range(6), names, rotation=40, fontsize=8)\n",
    "plt.yticks(fontsize=8)\n",
    "\n",
    "\n",
    "seaborn.despine(left=True)\n",
    "plt.grid(False, axis=\"x\") \n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-timings.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46ad5111-1a6d-4ce1-8ee8-258b5bff92c4",
   "metadata": {},
   "source": [
    "#### Convergence Deltas with Captum\n",
    "\n",
    "Although DeepLIFT/SHAP have been extensively used as feature attribution algorithms, their implementations are surprisingly brittle. Specifically, they rely on overriding the forward and backward pass operations on *solely non-linear* operations. How do the implementations know which operations are non-linear? Good question -- and exactly where the issues arise. I have written more extensively about this issue [here](https://tangermeme.readthedocs.io/en/latest/vignettes/Attribution_Trickiness_and_DeepLiftShap_Implementations.html) but the gist is basically that almost all other implementations will silently fail if you do not register all your non-linear operations correctly. This can include:\n",
    "\n",
    "1. Failing to add your custom non-linear layer to their internal (sometimes hard to find) dictionary of operations\n",
    "2. Failing to add a built-in non-linear layer that simply is not already in their internal dictionary, e.g. for an operation added to PyTorch after the DeepLIFT implementation was released\n",
    "3. Re-using non-linear layers, like activations, multiple times in the same forward function\n",
    "4. Creating non-linear layers in the forward function instead of in __init__ \n",
    "5. Using non-linear operations outside the context of a registered torch.nn.Module object, e.g. running `torch.exp` within the forward function\n",
    "\n",
    "Each of these can cause a non-linear operation to be treated as a linear one, and when that happens the convergence property of DeepLIFT/SHAP no longer holds. When the divergence is too high, tangermeme will issue a warning.\n",
    "\n",
    "Let's see this in action with a GATA2 BPNet model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2af2406e-4045-4c65-9e43-ef643d8c080e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "from bpnetlite.bpnet import ControlWrapper\n",
    "from bpnetlite.bpnet import ProfileWrapper\n",
    "from bpnetlite.bpnet import CountWrapper\n",
    "\n",
    "model = torch.load(\"/users/jacob.schreiber/models/bpnet/GATA2.torch\")\n",
    "model = ControlWrapper(model)\n",
    "\n",
    "profile_model = ProfileWrapper(model)\n",
    "count_model = CountWrapper(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fbbc1b1-c117-423c-af0f-a520fc267e3f",
   "metadata": {},
   "source": [
    "As a sequence to analyze, let's make a random one-hot encoded sequence where we stick a high affinity GATA motif into the middle. Because we will be using different implementations of DeepLIFT, we should also pre-shuffle our sequences to make sure the results from the two methods are comparable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bb0a456b-c0bf-4733-a9e7-1b2d62e3a255",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tangermeme.utils import random_one_hot\n",
    "from tangermeme.ersatz import substitute\n",
    "from tangermeme.ersatz import dinucleotide_shuffle\n",
    "\n",
    "X = random_one_hot((1, 4, 2114), random_state=0).type(torch.float32)\n",
    "X = substitute(X, \"AGATAAG\")\n",
    "\n",
    "X_dinuc = dinucleotide_shuffle(X, random_state=0)\n",
    "\n",
    "X = X.cuda()\n",
    "X_dinuc = X_dinuc.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35130cac-56ec-4cf7-b309-72713e50bacb",
   "metadata": {},
   "source": [
    "First, let's run the two implementations on the count head of the BPNet model. This should be fairly straightforward as there are no additional non-linear operations that would need to be registered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d71e8f60-948f-4479-959d-92c5837dca9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/users/jacob.schreiber/anaconda3/envs/tangermeme/lib/python3.10/site-packages/captum/attr/_core/deep_lift.py:336: UserWarning: Setting forward, backward hooks and attributes on non-linear\n",
      "               activations. The hooks and attributes will be removed\n",
      "            after the attribution is finished\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "from captum.attr import DeepLiftShap\n",
    "\n",
    "from tangermeme.predict import predict\n",
    "from tangermeme.deep_lift_shap import deep_lift_shap\n",
    "from tangermeme.deep_lift_shap import hypothetical_attributions\n",
    "\n",
    "X_attr_t = deep_lift_shap(count_model, X, references=X_dinuc, raw_outputs=True)\n",
    "y_hat = predict(count_model, X)\n",
    "y_dinuc_hat = predict(count_model, X_dinuc[0])\n",
    "\n",
    "input_diff = torch.sum((X - X_dinuc) * X_attr_t.cuda(), dim=(2, 3))[0].numpy(force=True)\n",
    "output_diff = (y_hat - y_dinuc_hat)[:, 0].numpy(force=True)\n",
    "\n",
    "count_deltas_t = numpy.abs(input_diff - output_diff)\n",
    "\n",
    "###\n",
    "\n",
    "X_attr_c, count_deltas_c = DeepLiftShap(count_model).attribute(X, X_dinuc[0], return_convergence_delta=True)\n",
    "count_deltas_c = numpy.abs(count_deltas_c.numpy(force=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "007af7d9-bffa-47d6-bd8a-b9d6b8457b29",
   "metadata": {},
   "source": [
    "Other than a generic warning about hooks being set, both implementations seem to run without issue. There is a little bit of additional code for calculating the deltas from the tangerememe attributions.\n",
    "\n",
    "Next, let's try calculating attributions for the profile head. This involves a non-linearity, as the 1000 bp output is converted to a single number by doing the dot product between itself and the exponentiated version of itself. This operation can be easily registered in tangermeme through the `additional_nonlinear_ops` argument and using the `_nonlinear` tag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "20ae8810-7096-4ca5-9c2d-e6a03c2ae848",
   "metadata": {},
   "outputs": [],
   "source": [
    "from bpnetlite.bpnet import _ProfileLogitScaling\n",
    "from tangermeme.deep_lift_shap import _nonlinear\n",
    "\n",
    "X_attr_t = deep_lift_shap(profile_model, X, references=X_dinuc, \n",
    "    additional_nonlinear_ops={_ProfileLogitScaling: _nonlinear}, raw_outputs=True)\n",
    "\n",
    "y_hat = predict(profile_model, X)\n",
    "y_dinuc_hat = predict(profile_model, X_dinuc[0])\n",
    "\n",
    "input_diff = torch.sum((X - X_dinuc) * X_attr_t.cuda(), dim=(2, 3))[0].numpy(force=True)\n",
    "output_diff = (y_hat - y_dinuc_hat)[:, 0].numpy(force=True)\n",
    "\n",
    "profile_deltas_t = numpy.abs(input_diff - output_diff)\n",
    "\n",
    "###\n",
    "\n",
    "X_attr_c, profile_deltas_c = DeepLiftShap(profile_model).attribute(X, X_dinuc[0], return_convergence_delta=True)\n",
    "profile_deltas_c = numpy.abs(profile_deltas_c.numpy(force=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e864460-0855-40f9-be65-d6bbcf25255c",
   "metadata": {},
   "source": [
    "Both implementations seem to run without warnings. What happens when we plot the convergence deltas?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fbeb8291-8ddd-4ab9-adb2-127e413809ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 250x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(2.5, 3))\n",
    "\n",
    "plt.boxplot([count_deltas_t, count_deltas_c, [], profile_deltas_t, profile_deltas_c])\n",
    "\n",
    "plt.ylabel(\"Divergence\")\n",
    "plt.yscale(\"log\")\n",
    "plt.xticks([1, 2, 4, 5], ['tangermeme', 'captum', 'tangermeme', 'captum'], rotation=90)\n",
    "plt.grid(False, axis='x')\n",
    "\n",
    "seaborn.despine(bottom=True, left=True)\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-divergence.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2838ec99-56f4-4d7d-ad4a-3e6c00e67173",
   "metadata": {},
   "source": [
    "Looks like tangermeme and captum product attributions with similarly low divergences for the count model (the left two boxes) whereas captum produces attributions with very high divergences for the profile model, even though it did not raise a warning suggesting that something was wrong. In contrast, by registering the component with tangermeme, the convergence deltas remain similarly low as the count model."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2e4d5e2-7ba3-4493-9242-5eff1b45361d",
   "metadata": {},
   "source": [
    "#### Operation Stacking\n",
    "\n",
    "One of the strengths of tangermeme is that operations can be stacked on top of each other in a flexible manner. Frequently, this comes in the form of operations like variant effect prediction where most implementations fuse together the sequence manipulation operation (the substitution) with the model operation (the prediction). But these operations do not have to be fused together -- any pair of sequence and model operations can be stacked together. For instance, given the same substitution, one may wish to then run DeepLIFT or some other attribution method to evaluate how a substitution influences how a sequence gets read. One may wish to run an in silico marginalization but report attributions instead of predictions. Or you may have some custom function that you want to apply before and after the sequence operation happens.\n",
    "\n",
    "Let's see this in action with a ChromBPNet model applied to a randomly generated sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ab74d929-842d-4304-b754-9f09128184cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from bpnetlite import BPNet\n",
    "from tangermeme.utils import random_one_hot\n",
    "\n",
    "X = random_one_hot((100, 4, 2114), probs=[0.28, 0.22, 0.22, 0.28], random_state=0).float()\n",
    "model = BPNet.from_chrombpnet(\"/users/jacob.schreiber/models/chrombpnet/fold_0/model.chrombpnet_nobias.fold_0.ENCSR868FGK.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89cf69b7-f95d-4d0a-9240-f88e385221ff",
   "metadata": {},
   "source": [
    "The subsequent plots are panels for the figure below. I will only include brief descriptions of what each one is.\n",
    "\n",
    "First, we have predictions when marginalizing an AP-1 motif."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8157ab22-1d58-4a78-8a93-3424cf791029",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 250x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tangermeme.marginalize import marginalize\n",
    "\n",
    "y_before, y_after = marginalize(model, X, \"ATGATGTCAT\")\n",
    "\n",
    "yb = torch.nn.functional.softmax(y_before[0].mean(dim=(0, 1)), dim=-1)\n",
    "ya = torch.nn.functional.softmax(y_after[0].mean(dim=(0, 1)), dim=-1)\n",
    "\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(2.5, 2))\n",
    "\n",
    "plt.plot(yb, c='0.6', linewidth=1)\n",
    "plt.plot(ya, c='m', linewidth=1)\n",
    "plt.ylim(ya.min(), ya.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-marginalization-pred.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4dfca85-c2a5-4d01-bb26-25be316cf669",
   "metadata": {},
   "source": [
    "Now, DeepLIFT/SHAP attributions with the same motif."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1b959f5e-ed0e-48d5-b29f-b370cf3284bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from bpnetlite.attribute import deep_lift_shap  # Note that we use the bpnet-lite version which registers the BPNet-specific non-linearities\n",
    "from tangermeme.plot import plot_logo\n",
    "\n",
    "y_before, y_after = marginalize(ProfileWrapper(model), X, \"ATGATGTCAT\", func=deep_lift_shap, n_shuffles=1, random_state=0)\n",
    "yb = y_before[:, :, 1040:1075].mean(dim=0)\n",
    "ya = y_after[:, :, 1040:1075].mean(dim=0)\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(3, 2))\n",
    "\n",
    "plt.subplot(211)\n",
    "plot_logo(yb)\n",
    "plt.ylim(ya.min(), ya.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.subplot(212)\n",
    "plot_logo(ya)\n",
    "plt.ylim(ya.min(), ya.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-marginalization-attr.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bb01dee-aef2-4fe0-8a2e-5ba71ecef368",
   "metadata": {},
   "source": [
    "Finally, saturation mutagenesis on the same motif."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3c02a558-801e-4af3-bbc4-eea49f71f84c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASIAAAC+CAYAAACRbQI6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAANGlJREFUeJztnXd4VFX6xz/TW5JJL0ASeidU6U2qBVTUFQuoa8W6uC522HVXXQviT3bX3lZQcQUbKlgQpErvPZSEkISQnsxMpt7fHyeTAikT2iThfJ5nnrlzy5n3tu953/ece65KURQFiUQiCSLqYBsgkUgkUogkEknQkUIkkUiCjhQiiUQSdKQQSSSSoCOFSCKRBB0pRBKJJOhIIZJIJEFHCpFEIgk6UogkEknQkUIkkUiCjhQiiUQSdKQQSSSSoCOFSCKRBB0pRBKJJOhIIZJIJEFHCpFEIgk6UogkEknQkUIkkUiCjhQiiUQSdKQQSSSSoCOFSCKRBB0pRBKJJOhIIZJIJEFHCpFEIgk6UogkEknQkUIkkUiCjhQiiUQSdKQQSSSSoCOFSCKRBB0pRBKJJOhIIZJIJEFHCpFEIgk6UogkEknQkUIkkUiCjhQiiUQSdKQQSSSSoCOFSCKRBB0pRBKJJOhIIZJIJEFHCpFEIgk6UogkEknQkUIkkUiCjhQiiUQSdKQQSSSSoCOFSCKRBB0pRBKJJOhIIZJIJEFHCpFEIgk6UogkEknQkUIkkUiCjhQiiUQSdKQQSSSSoCOFSCKRBB0pRBKJJOhIIZJIJEFHCpFEIgk6UogkEknQkUIkkUiCjhQiiUQSdKQQSSSSoCOFSCKRBB0pRBKJJOhIIZJIJEFHG2wDJE2X3Fw4dgxKS8HrhZAQSE6GmJhgWyZpaqgURVGCbQSA0wl79kBGBpSUgKJARAT07AktWwbbOklVvv8eHn4YHA549lno3BmMRigqAq0WRo4MtoXBQ1Hg0CHIzBTHw2CAxETo2BE0mmBb13g5bx6RzwcqlfjUx+uvw5NPQrt28I9/QEqKuKBzcyEvr/kK0b59sGGD8ChatxYXrVotvIsePSAuLtgW1ozXCx6PsFWnEx+tVnyrL+Jg/9134W9/E9f8bbdBUpI4Tj/8AA8+CO3bB9E4dykU74OyE+B1iHlaC1i7giU5iIaVm3IuCnG54IUX4McfxcHv2xdMJlE7uFziJBiNtW+fnw9lZWCxiJsvNlZc2Gp186hFtmZtZcGuBQA8NOAhWoW1QlHg669h1SohOq1bB9XEBnHV5aVMXPY5J1JTScvvgH2/lRKfhhBjGW16p8CxvZC1FELaQ1hnceH7XODzQOIk0EectQ1Oj5M8Rx4A8SHxqFUXSAGL90P+ZnDmgtcOagMYosjRXcM994QBsHz5+fMK39n8Dtuyt6FT65g1YhZR5qj6N8r4Ftb8AaIGwsCPQKWGnFWQuw4KtkG3J8+PsQ3gnIRmWVniwB84AP/6F4wfD+Hh4HYLF7VnT1Fb1orPw8k9a9jyex4Z2RZKHBYUBcJDHAyZ0IuOKY076VDgKOD19a+jKAojWo9gVJtR1Zb1frs3idZEMksySQhJYPlty9FpTjkgftexcUTKgDAlN1eEyk6nqFxiYsCS+jTseQE6PQJ95kDRHsj8QVzY0YPAnAhZSyCsi/jYj4mb15EBXR6D+DEoCthsogJyu0WFYzaLyqjCi67lmGw8vpGpX01lUOIgjhQcQavW8uHVH5JoTQxov5weJwt2LcDpdZJsTWZ8+/GBHZANd8Oh96DbTOhwHziyoPQwODJRYkbywDMpvPkmDB0Kjzwi8mVut7gvxoyBFi3rCA/qOe+KovDXFX/l5TUv89l1n/HK2lcocZXw89SfiQ+Jr9turwuyf4bC7aAPB60QTAq2ioqi/d2V69Z0zI9+Bkc/FhWItTuo9WK+zwXdnqr7vwPknOWIFJWKdJI4SAdKCMWBCT0uosllqHsF2rp8rzWTIf1/0Od16PgQ5G2AvN/BfhziRkKLK87ONkXh+VXP8/W+r9GqtYxpO4a/X/r302vRusSgaoxZZbndbWfsvLHkO/K5vP3lvLnpTX6a8hPDkoehKApXL7iaxQcW8+zIZ8kuzebNTW8yY/AMXh77MoqisDJtJR9s+4AhiUNYl7GOEckjuKn7TRi0hrPa57MhKwseeEDU7FOnwuDBEBoqRCMnB+671wPZP5GX8SNHi47hVhtpH55EtEaBmKHQciIAPsWHWl3u0pYfM5sNJk+GZcvgzjth0iSIjBTh3vHjMGqU+K9SVykhhlAADuTup2NUR0CI0EtrXmJQq0EkWZPwKT525eziWPEx/nHpP8g+kMjmzeIv27Wr9MR9PujWDUo0R7hh4Q0UlRUxrd80nvn1GW7reRuvXfYaGsXIxo1w8KCwJypKeOaKIirWoS3+C7v+CqGdIPkmcSNm/gDHv4GeL0LXx0lNs/HcvJXk5Rhw2UwMbN2bDm2MXHV5EWGO5eAuhra3CaNOrgXFJ8TB2q38MCkoiGOlQoWq/Lp7de2rzPl9Dvf0uYcQfQgAiw8sBuDLyV8SaYoM7OTWcY2vSV/DkOShABzOP0TbiLbCvu86QukhGLUcYofDsYWQ9hkU7oQBH0LsMH498iuf7fyM9pHtybHlMH3g9IArBmiAEO3YIVpIQkKgRQtxglQqsT8xMWJ+XTuaVpjG+1vfp7CskDhLHMeKj3FXn7vo16IfOLLxHJlPbs56ygzxlKEiWuUlSrFB0mS2+drw4/4VZJVm0TGqI2nFqVgNEfSPH8rQ9j0xGFTsz93P4YLDxFhiKHAU0K9FP6LMUTjcDu789k6+3Psld/S+A51axztb3uGKDlfw8TUfY9Fb6jxJDreDL/Z8wY+HfmRwq8GszVjLxI4TmdR5EmqVmqsXXM2aY2uY1HkSCSEJfLnvS06UnuC3239je/ZWnv71Gab3vYuesd1ApeLHIyv4fO/XfHL1R6jyf2dr5np6J41BZ4pFKcthX/5BTGoNkwY8jd4UW+v5OHgQPvpIJPdHjhTnwG9+WBgMGxbIWa2Z/fvhuutg717h4Q4aJMTB4YATJ+DSUV5e+/01Zi6fyeXtLwdgSeoSnrv0OaYPnM6+3H18tO1jtmfvoGdsX/bn7cWkNTGhw9VM6jQOS+bnFBw/wqGyFOyKFZW9CKvajsXko/XIW/gh7Rce/OFBYi2x9E3oy0fbP+LRQY8yc/hMTDpTredLUeD99xV+W2snLP4kl/TTYvcVEmEKJ84cT/vOLj46MBuj1ljhtbq8Lr7a+xUpcSmEp0/h0UdV2O1iv5OShCdfVib+KrlrDl/u/ZJtactICW9JXkkGaq2Jwe2vZki7iSzct4hnfn2GrjFdubXnrSzYtYAtWVuYNWIWt3edhDvrJ3ZnruOAW01CWCJ5+XsZFh5JTHgHTsRN4JOdn7D86HJahbbCq3g5YTvB6Dajuan7TcRYYmrdbwCvz8u6jHUMTRYn/rW1c7i0zaX0jOuJSiXujznr5pBZmknb8Lbsz9vPnwb8icvaX0ZmSSYzfp7ByrSVTOs3jSMFR1iSuoS7+tzFE0OfwKzWwMlVULwXPA5QaQAf6CMpjhjL8yu+YkfONoYnjaZNZCt2529hR+5Gbux4NzcNrIwO6iJgIXrh8RkUZBym0GGmTHFj0rkw69zo1F7SS3REhhRh1nkoLNPj8WnQazwYtT58ChwpNVEQmkdKiIu339wBwOwZHchRfJzMjSGzKIxCcyE6r47VC9YAMOjmgah9aqy2cCKIJsLgxal4eHfR5wA8fttodGqFffkW0p0RuDwWQjQ2dJoy3BoPbq0Lk9OMSuPB7W6BwR6BXluMRuMAvQ2npQSVU4c35DiHY9KwOkIJt4Xj0ro4GZqH2W0k6URrdOEFGHQevCVhuBUVRo0Xt6kEjVeL1xZK67gSTC4zOQXhqNVuIsw2wmOzKXGYSMtIxudIJK8kliWr/gbA9ePvw6Dx4lY5MJpPEGexoVaBza1FUVSEGlzoNV7250ayP7cbjrIoQgz5GPTF+NRiv/QuE5Ghxyi0nqTAXIjGo0Pr1eIw2LGWhRBdHEuU2kC0yYPNq6XUraDXujDp3JjUkF1kYmTbDFqE2FmfkUCO3Uis2U5ciB2j1sOKtBYUlelxucJZ+tN8AC7p9xwajQuDoQBtzG6KzcVY7VZ+WbQMgDHXjabIXESYPQwlvz0ORxwaTRkmUw5qtaf8vtGg0dpxmwuwGWys+/R3AIbeOASf2oelzILabcZg0mL1mcANPpULResmLOoEToeJE5ntyc/tS5kzhNCwQxj0drRqLxoV+LT5hEanotc78bmMeLwatBofaF2oAHtRBLbCnjjLotEZT6LXFaHXutGpFbyKmrDw/VySmI0ODak58fh8GsKMTiJCi8gsMbDhWBsczgg0Xh2rVs0V+z1uCj61D526jBGtj9ApqojM4hAKyoyYdR7aRxZg0Hp4b9MlrD98Be6yCOJbrEFvyEdReynTOwlxWkg05hJuUOPzabF7vKjVPoxaLzqNhxKnluSIIjpEFpFjs5Br1xNudNIyrASr0cXq9Dg6Jx0j3FTGmvQWFDn1tAixE2ktwujT8c3W/uzNuQSlNIGo8FR0+mJ8ajd2g50Qj5YIfSl5Jy/BY48iNOQYBr0NRePGp/ai1xVA6FGKTcXYfXq0tlgcgBYV4T6FlloHo5KKMGkVtmXH4Fa8JIcX0i4yH7dPww0v7Dy3QvTi6hfJKM7g5bEvY9aZAXhj4xvsOLGD50c9X3fSLH8zrLgCdKHChTUlQNEu2DgNIi+B8Rtq31ZR4ORqsGdAWCfQhYErXyQ+AaIuAXVdCaiqeytqEp9Xqda6s/voCZ7/5nO0zhgy8vPo3/ISRnceQM+eInFeK94y4Z66iyBhrJhXtB9QQGflx5XxLFokwoMJE4TXqFaLMCE2tp5WFI8d0r+gqGAX6ZoYQiwJlJUcJUmvw2KMhLZ3QnnY4/Q4UVAwaAwVrnx9LNr9Of/b/C+GxPegf8tL2Ja9nQ3HN3BFp6u5rNeDFLuKsRqsWAzlrq6icKL0BABxIeeoOa8m79lxAnJXi+mwroACZTkiRDBEs3xbCl98ITYZM0Z4f/6WxlatoGvXMzfH6XHy/cHv+XLvl+g1esIMYRwrPsbEjhO5rst1hJaHijXic8Pu58S13uoaMCZAaaqYr1JDh/spKjWSnS1aSQ2GylZllQq6dKnHuBPLIW89mJPBklTeAOAGxUOpZRRzXtOQk57NyKElJCVp0OpUgILHZyKuXRu++054z337QnR0Zeum0QhHjgjv2mSCa68Fq7XyOm3dGubPh3nzRK536lRx7fp8IkwfNtRLcshGsKdD8mRRaN5mULzifg/rHNCxD1iINmVuYsgHQwgzhDGm7RgO5B1gS9YWnhr6FM+Pfr7ujQ++BZvug1bXwpD/QVkWZP8ilhmiKnIKweCWW+DTT+Hmm0XLnz/EKSoCvV7kL+qkrhv/XCWez1MiO7s0m/9s+A+hhlDy7HlM6zeNNhFtKHYWM+j9Qbi9biZ1ngRAYVkh72x5hznj5vDIoEfO7o8vxDG7yNi8WXQHUamqp058PhgwQFzLZ4KiiHzh/Pkwdizcfru4R3w+OHlSCFurVuUrn8V12qBk9WvrXuPRnx7l8+s/Z8bPM0i0JrLithVo1AG0sR9bBJlL8DgKcHijcfu0mPQuTO2uFDVIkMjKgiVL4PBh0V8pNLSyhu3XL4Ca6kIQhBa1wwWH6f9ufwYlDmLW8FmM+GgEU1Km8M7Edy6YDZLGg6KIxoT8fLDbRStnRIRoGaxoEb9QQgQweeFk1qSvwawzs+zWZQFnxufOhfffh6NHRSI1PFwoamgoLFzYYLslF4CVaSsZO28sRq2RPgl9+GnKT6d3O5BIzgEX5BGP+fMrY8tdu+SzSBKJpDoXpDtqaan41utFQkwikUiqckE8IkWBp56CDz8UYjR+vIgvc3JELmbevPNtgUQiacxc0Kfv/U8mnzwpOsdFRYmnkqWXJJFc3DSaYUAkEsnFy0U8aINEImksSCGSSCRBRwqRRCIJOlKIJBJJ0JFCJJFIgo4UIolEEnSkEEkkkqAjhUgikQQdKUQSiSToSCGSSCRBRwqRRCIJOlKIJBJJ0JFCJJFIgo4UIolEEnSkEEkkkqAjhUgikQQdKUQSiSToSCGSSCRBRwqRRCIJOlKIJBJJ0NEG2wDJGVLX++NBvkNe0qSQHpGk0TJu3jj6v9uf9Rnrg22K5DwjPSJJo2V1+mocHgfZpdnBNkVynpFCdJGzPXs7+3L30Tq8NQNaDQi2ORX4FB8OjwMAm9sWZGsk5xsZml3kfLD1A25cdCNzfp8TbFOq4XA7KqbtbnsQLZFcCKQQXeSUukqrfTcWqnpBNpf0iJo7Uogucvw3fGO72avaI0Oz5o8UoouBzCWwbCRk/3raogohOtOb/eRqWNwedr9wFgaejvSILi6kEDV3nHmw+lrI+Q1WXQX2zGqL/Tf5Gd3sPg+suQFKD8GOpyHzh3NhMVA9LyRzRM0fKUTNnfTPwVsmpj022FPdczkrj+jEr+DIqvy9Y6b4Vqlq/wSIDM0uLqQQNXeOzj/l9yeVwsRZJquPzqv+u2ALFOxoeDk1UC00k0LU7JFC1JyxH4fcddXnuQuhcGfFzzMOzRQfZHxz+vz8jQ00smaqeUQyR9TskULUnMnfXMuCyufQ/N6G0+vE6/MGXnZJKnhKzsK4upE5oosLKURNFUWp/NQ2r2BrvcWccS4mgLLPBhmaXVxIIWrOFG6rc7HX5614jAIamCcq3H6GRgWGDM0uLqQQNWdKDtW5+NSQp0E3fOmRM7EoYKRHdHEhhag5Y0+rc/GpN3iDbnjb0TMwKHD8IhluDJc5oosAKUTNFVchuIvFtEoNg+ZDzLBqq/g9IBWqar8DoqrIDfgQOv7pbKw9Db8t0eZoGZpdBEghaq7Y0iunEy6D1rfA4E9Bra9cpdwDijRFVvtdLz53ZUfG0E7Q5jboPRtCOzbYzHnzYOxY+P77U8x3VxEiGZo1e+R4RM0VV37ldNu7xLe5FbS6tmK2PzkdY4khz5EXeLLaVVil7D+W95rWQvtpYl7Vljx/b+oahq5dvhxuvVVMr1gBmzdDSor4XVWIPD4PLq8LvUZ/WhmS5oH0iJor7qLK6dgRldOtb6mY9Ic8MeaYar/rL7u4cjpmSOV00uQGmfj3v1dOezzwxBOVv+1uO2qVmnBjeMVvSfNFClFzxS8WpgQwRFbOj7sU1Aag0uuIscRU+x1w2QDW7pXT5hYQ0TugItavF15QVZYsgRMnxLTNZcOsM2PRWSp+S5ovUoiaK36xMCdVn6+1VIhHRULYFF3td/1ll3tb2hDQh1dfFtEroCIWL655fln5Y3A2txAis85c8VvSfJE5ouaKXyyMsacvU2uA6jmiqr/rL7u49rJVgdVty5bVvdzvEVUIkV8k5WuUmiXSI2qu+MXCUINYlFMRmpnPMDSro+y6cDphYz3PxkqP6OJCClFzpS6vpZyKZLWlgclqT/1l18X+/eCt5/lau9teTYhksrp5I4WoueIPzc6HR+SqI+wLgN27K6eNRtGXaPToU2yrLTSTNEtkjqgJ8MPBH8gozqB/y/70iu8V2EYV4VNUrauc5hE1NDTTR9a9Xi3s21c5fffdMGUKXHUVtGkj5nl9XpxepwzNLiKkR9QEeG7lc9z73b0s3LMw8I38YqEx1LpKqVskp6PNotUs4GS1PzRTn1kHQ38TPcD06eI7LAweeEBM+0VHekQXD1KImgB5jjzxbc8LfCNfeTu4SlfrKv6bO0QfglFrDPxm9zrF9xkKUV75biQmQtu2lfNvKe9r6c8HyRzRxYMMzZoAfgHyC1JAKOXZ4DrEwu95WHQWzDpz4OFPRdm1i1xd5OaK7+7dq8/v1En0sE4rLveItDI0u1iQQtTI8Sk+CsoKAMh35NezdtUNTxELxVdloXijhs1lQ6vWotPosOgsgXtEp4qctww89sr/04XWublfiBITT1+m1VYRSL3l9NAswOfYJE0LGZo1corKivCVi8hZeUSbHoAFGvHZ/Q9A5IT8j1CYdebAc0SnekSHP4Avo8Rn/R31bl6XEEGl6Mhk9cWDFKJGTlXxaVCOKIDwyd9pEIT30eDQrI78U62bKtVzRDUhc0QXH1KIGjlVxadBHhHloVhdQuSyYdFXekQND80aLkQlJeB2i+mWLWuxq6ZWM+kRNWukEDVyqoqP3W2nzFNWx9pVCCBvUtUjMuvMuH1u3F53AIUH/sbWU8mroqUWSy121RSayeb7Zo0UokaO3yPy934OODxTiQdb8dUuLDaXrSJHVDHcRiCeRwBl14bTWTltqKWLU1WPyKQ1BW6XpMkihaiR4/eI2kW2q/a7XuoRC4/PU9F7Gaj4Dihh7S9babgQeTyV07UJUdUckUatwaAxyBxRM0cKUSPH32TfLqJdtd/1Uo8Q+UMdf46oQQOQ+Yf68LoCs6UKgQhR1dDM/y1Ds+aNFKJGjj8U8wtRwKGZ2i9ENYtF1fCn6neDQrOz9IiMxprXqck2GZo1b2SHxkbOGYdm/jqmFrGo8Dq0pwhRQB7RmeeIqgqRrpZGN78NU7+ailln5oTtBFGm2h/elTR9pBA1cvIceWhUGpKtyeJ3oB6Rptzd8ItFx4fFMLH7XgUqc0Hzdsxj4d6FFa1xAeWINKbqZbe6VoyDveGu+jfVVE67a9Exfz4ovSj9tHmS5okUokZOnj2PCFNExbvHAvaIdGHi21ve3G/tAmFdKxb7Qx23z43b6T5tfoPKNsVDeEpgZlXxgqq2oFWlJhtsbhuKoqCqb6hYSZNE5ogaOXmOPCKMZyJEVvHtqjm5XVsIFlBo5hciV0M6WAq0Vaq+hgiRT/Hh9NaygaTJI4WokZNnzyPSFEmEKaLid0D4xcJ5ssbFtXk+DfKIaim7LqoKUVktfTPPSiQlTRIpRI0Yp8eJzW0j0hSJSWvCoDEE3nzvF4uymsWitlxQQDmiesquC32VUUka4hHVNV/S9JFC1Ijxi06EKQKVSkWEKaLhOaLaPKJzEZqdgUcUVaXxy1bLX9WWmJYJ6+aLFKJGjF90Io0iPxRpimzyoVlYWGV4lplZ8zrnMjRzu+VwRU0BKUSNGL/o+PNDEcYI8h35KIHcWf5ktf1YjYvP6mbXlguRu7jyjR4BolJBtBgim2M1m3ZOQrOffoKUFBEKxsbCM8/UHgpKgo8UokaM3yPy+rwcLjiMXqPHq3gpcgZw8/u9FlsauE/P+5wTjwigeE/9659CvUJ0lh7Rv/4F48fDzp3id24uPP88/PxzQy2VXCikEDVi/B7RC6tfoN3cdiw/urza/DrRVhGL3DWnLT4nyWqAnJX1r38K/jxRTULk8ZxdjigrCx57TEyrVDBhAgwd2mATJReYc9qhMS8PFi+GtDTIzxf5gG7d4PrrqzfbSgKjtsR0niOPdrSre+Oq7zM7/BEkjK/23NlZeUT6cMSYRAoc+Qi6PAa+wOMev0dU9UWLAAcOgFrnxu1zE2eJ45rO1wCw5+QeVqWvCsi2zz4T3QJUKli6FMaNE/N//LH2h2wlweeceUSvvALx8TBjBjgcQoDCw2HRIrDLxo4zoram+oCa8C1JldMZX8GxRXDwjYpZ/jBn7wN7sT1lo+iJomrz60StA1MLMV28Dw7Mhd3P179dOX4hSksTHz+ffgr2crHpEdeDtya8xVsT3uKO3ncEbNuacudv1KhKEQIRqo0cGbCJkgvMOfFTDhyAxx8XrRPffw/9+5+LUi8ifG7I/V0kf82JEN4dVOpaQ7CAQjNdOGhDwFMqvJXV11db7Pcuos3RFQ+86tS6wBPClmRwHBfTW6YHtk05sVXeVP366zBnjhhC9j//gctvqP7kfdXpQGxbu1Z8X3ll7ets3iw8902boLRUCGP//vCXv8DRo/Df/8Jvv0FOjqhU4+Jg0iRxjZ93FB/kbwZHpjh/4T3O+NXeTYlzIkQOR2UTqdV6LkpsZORvhvQvIH8TKB4wtRShTptbz77s1Ldh51+hrMrrT81JMOFgnaFZvahUQiyKdte42J8LOvWGD/hNHpZkyF0b2Lqn0Llz5fRbb8HAgfDhhyKp7PBWDopW1S6oP0fk80F2tphu1armdZ57DmbOFGmDu++Gjh1FGmHpUhg7FoYMAZdLCOQNN0BEhOhmcOTIGe1qwzgyD7bNqH4tAAz9EhInXQADgsc5EaKePeH+++GNN8Q7zP/8Z2jXTtRy69bBrFkQElJ3GQ4HLFwoarSsLHFRtW0LU6dC377nwso6KNwpwpfSo+AuFDVRSDvo/GdI+ww23gv6CGh9qwhJbEfFK3TOVogyf4CN08SwGh0fhsi+opXryMegeGsXokD7EoW0q1WI/GGOfyhWKH+TR6B9dULa1r9OLXTrVjntcMDkyZW//aGZf3gSCHyIkqrN86E1vFrt8GH429/E9Ndfw6WXVi574gl45BFhz6BBla+/BkhKEp/zSv4W+P1W0RAw/DuIHy1eUnByNeirD4HidovXdmu1wrtUX4gmJ1cRHPsCSg6CqwAMMeJ6Tbz2nBR/zlLI//433HOXm0Wf5rHuV4XvFmoIs6rp3tOEXl/LKOnlHDwII0YIAZo0CSZOFInFvXthy5bzLET7XxehRewI6Pq0qOk9pVC4Qxz87U+K9casAmuVO+hc9JJLfUt893wRuvylcn7XJ0ClIc+eh0Fj4PXLXgfEsBgvrH4h8N7V4Slw/NsaF/kHzq/6NLtZZybHlhNg2T0DW68GOnUSw4F4vacvc3iqjxzpt8tvc10YjcIRVBTh5ZzKvn2V/zlgwOnLJ00SntC2bcJDGj9elOfxCI+oQ4eAdu/MOPSe+O74J2h5pehy4S4Ca3fQmPD54P33xX22c6cQH5VKvIDgs8/g8svPo21ZP4nQXvFC0mQIaS28th3PNDIhUhRU25+gZ+qb9LxiEMSPFV6F86TIf+j/XufmTz0lROiaa0Ry+4KO9LBvtvju/RpE9oZ9c0S+BsDjEE+vm1pUitCvo6H8ZmHIF2Cp5eVc5SiK2Lf0dJGP8HpF+Nq+nUJ09i9ipaQ/iO+C7SJPBGDtQp4jjxhLDPf2uxeAQ/mHGiZEEb1qWaCuNnC+H//bXgMabqM2IVLVXz0bjaJy2bDh9GV2z5nniFQq4YmnpsKhQ6cvHzhQNKAUFsK8eXDvvVX+1w7Dhonc0DvvwD33iNY3s1mcs0mTYO7cencNEB5LYaGICPwdKiuesXMVQcFWcOYCPjDEijyQv5e6ufwdS4feg62PiOnkm/jn8k955hkRcv72GwweLBbt3l1etrsU0hdA9s/gyAZfGRiiIXYkdJkhPK6j88R/e8tEg4PaCO3vhSSRP3S5RF6spERct1YrxMcpaDY9AJ4SuHQZxI+q3NFz2GX93AhR3nrY+zKEtIeRS4Vybrq/crnHDlVc7VPJyBDfbdvWLUJer7hgnE5Ro4aEVI5vk5MDe/ZAUZG4gEwmaNEC+vWrx/ZW18GB1+HgvyHleWj7R3DmwZ4XIPISMcBY2Qlxck3x0OFB2DkLinaJE3pskQixXAVgjBdhluKB6MF8tW0q06eLMHPmTOEJWCwiF+IsUxjhdQgb/L2gNz1Q0edHGbKIfEc+XWMqxxBq8BP4EbW4krHDsLlfJdwYXm22WWfGq3hxeV0YtPW0dYe2F2GEXzj9xAwPyLTRo2sWIofnzHNEIHI8qamiQnvmmerXk8UiEtF//CNMmybyUv4c0erVUFikYhgwrHx9BfChRoMP/gXMFTee0ymu2fx8UX58vHhH21dficT7kSNwxRVinscj+kvNmumlXd49QgziRgsPXG2EvA3i/okeDMcWQtaPQhza3w2h7WDlVUClCD7+uBBMPykpiLHDfx4BBVug1yuQfKNorCjLhtLDcHINLBsu7s9hX4uxqUCIoquAn34SxyorS4hz+/Yi7MvPh9aJDsaVpor1oweJ72UjRToDYOhCiKsS454hAQvR+vXCXbXboXt3caOr1eImu6RvL5JjR8LJlbDrbxA3BtrcBuumgu0I9HoZqF2IHnoIfv9duJ5jxoikoUYjWjByc8UFs3SpiN0nThS1mt/97tRJXFSbN4v4f/RosdzhEF5IvULU+1VxgI8tglVXCy9Ia4LkmyFuJLimw94XYflY6PQnMMZVvmAwczFsfVTs78glolZL/0IsU7wcOgTHj0OPHtC7t7BVp4OCAnA61VDSVlwoRbshZgj0ng17X4KMrylxO/D4PEQYIypMtRqsqFAF/gR+SGuI6C1qQT+mBIgeSqmrlBahLaqtXvVNHvUKkUoNLa+Box9Xn5d4fa2bVGXiRPjnP0+f71bV4REFkL8aPlyIzfbtojf1k0+Kmv6ll8S1cNVVQhjWrYONG8WDt336iPWUwUqlcKlUqACN/1wjckzTp8OyZcIj6dVL3LDHjolWt+nTxXX5yy/iOqxG2kKRV4wbBSN+EJ72kf8Kb1tjFNfbwf+IXOWKy8V6pZVuXUSEqGxP1vR4X+F2IUKW1pUh/q9jRAsciOtY8Ynr3NpFeN7bn4CcFWDtxi/LNrFxo0iP3HILtG4tBNZmg9ISE+wcBLnrRL603R0w7CvY/DAcnV85SmfZSShNLe/F7xOjgVpag7mWVoNTCFiIFi0STZ4pKeKm8icDS0oQyj7qV1z5W1i+6Z9o0lYTYbDSp/NfUIV1BG0NmcMq3HyzcNfnzoWrrxaej14vTvLs2cKlLixUsBhdlOTZ8ZS6UWt0eLFgt+vJyhIHLikJkpOFS+lwBLhjag0kTxYf/1VY1eWM7AvWrniOzEe9/RlQgdqSDJ1nQPx4CP9Y3OgH/l3uJVhh/e1gacNfHr2NqVduY+OqE2z6TsPy/5nwKWqsIU4Gjussbtq9L4uLYvi3ED0QzOVDwjpLxN+XD4gGoFFrsBqtDXvja/JN1YWo/f24FC8en+f00Exf+W6zKAIYIzr5pupClPgHMMUFZNagQaJmX7Wqct748aAzl+eIdA3PEQHceCM8/bRoPZs5U+R87HbxWby4vDwzjB6jYjScHl54bKJvlJ9jX1Y0o996awJr1oiK89QwTVGEJz57NvzpT3D77ZUe0eHDcNf1XWip1olkb+lhUaFZe8DKiaL8DvfDuA349v8HX8b3sO8NfBorSovb0bW7k1deEeHhiy+Ky3TYMPG9dSv06ZXCpeE9RV5z/1yRxxm6EH4dJc59/3eF13V0vjA0sq+oPLOWgtfJyy8p3D35ABtWnuSLN1TYy3RoNAoGg4pLJ7Ynrv97sPYW2HCnEEtzoigPwFUIS/uIZxp7vwqhnURjji0NCndBh2n1njNogBBNfXQn2vGfsSdnD3ujerEz6yBWYxiTelxBQqvxFDrtXLP4UbJKs3h+1PNc9+2dTHElMPfye9F47ZC5HMqyxE5ozKL2VHyi413BNq6N+YRr5ySjRA4g76QHxV1KlLUEdasrYdffuPXan6DbMxBRfsCdeaJW6f5XjqzZyo7NJezNaMc380JxODWYDF5aJuq4JDldtEKZWkD8GHCXCC/NXSxCr4Rxte6zT/Hx65Ff+Wznb+SWhtEv9gl+z1xFlDuGyS0m0Cm3K59s2Ia3JINJloOEW4pQqSPwtF6Jz9yOjlumE3dgLhMGPg3d/ypOTN46UXtEFEHMDOGJnVwNX8UJEbKLcZprEiL/75O2Bjz1nnQjbH9KhIuGWOj40Gmv6/HT4Leqxo8WHpYjS+Qcus8M3C6EUPg7HWo0wkNaUXZ2HpHZDPPni3xjaanwqKsuOxWvz4vG/8aTo5+IcbfjRkHhbhF6n1wl8jn2DAYOvIM1a4T3npoqQhiA4mJRIT/2GFxx226e/OI9dvq68O2uXG7udT2TJ3ckrn0KxK2CQ+/C6mtBrRfjfFu7QlR/vvgCnnsuErd7Jo89NpPEROE922wQckB4kHt2OnnnbQ8rl2tY8KkarRY6dfQxepQeuq9EOTKfkvQv0aS+jwYFY0iiyNea4vENX8z329/jyNFvSShYgUat57LhSzHH9IdN99Mh9S06jPkrdHlceOgFm8V5jRoA1svJGbaUhWuepAV2nAUnGdzxaRLbTBL38cH/iAPhsYn7quSAyL26i8+9EPUo3UAPwwFIGSASt22TwHYYSn/AUZTMQ7+9glFr5C+D/kKBo4B/jv4nH237iOdWPsesHhNQZS4Wg66bk0UTeeEuyN8gkp6xI8EQCWq9eDo7olTEoNm7wZIgQgC1ETzFoqOXxgy2LeDKw1e4m7zji7BY8xjd/SoshjDyT67HmbuJlpYYdpfMZvPR4cQpKtqWgM4YTalLTVbRVhLKPHSJFe5uSQmoaIcON6SJisNiUbN2/hgy141h8GAYEAMj207H5wNHBkQMdNHvin1sOpDBomwVcZER5DlyiQtRkaI30bHzo/h0VpSSVFR7X0HRWKAsC1X+ZtTmRJFMHL8Rx5555OxeTWmmCk3oBGK7DMITmUBKXApdortUOw/9W/Znz8k9eHwetOoATp8lEQbNF/2V+rwGeituWw4pcSl0i+lWbdVOUZ1IiUtBIcAkpFoncg5bH4WuT1ZvVQyAsWPh3Xfh449F03nv3rB5SygpcSnEh8RXrKdT6+gV34tEa90NA35Gj4bUXSd44/8KObDPRVikmWtvjmXYCCO/HPyJdQe/xvv1DbSP6sDub24gKbQlozpcQYi5G7kt7qCdkkdI1lLQhuLxeth9ZClhcUN45WUfl1+aw9oVRTz/hBqnS4NB70Gvhz9MiWbN8Q/4avcnDO92GT0Toth3Io1fj9xCSP4EOiiPQfQAiB5AviqSfCJx7EglJETkMnuFC7E5elSE7lptZcui2QyOvXMxpX3FtJv7EzZ9AHZbFt7SI0T6ighJnManm/P439ZUrIahDG7bm5XpK1Dlqbih27X0K3Hw8tq/k2vPZUzbKRhMEaxMX87na/7LjEEJ9Ov8F9E9pfSIyJVqzMLDKdiCEtKeL7Z+x2vL59Etoi/W9gPZZd/O3F9WcHk7Czf2uoZFGXOxZZsZrjiJjSxFox7DwZAUnMQwub6TVY5KCWhMCZg1axbbtm0D4NtyH/eqiRMD/JtKatrWP682alr31P/2qrx8/+0PAIybNBaDx4AKFQoK2eHZHIk9gkpRofapcWvdtM1pS3xBPIftieQ544jweQkLT0Wl8lJiKsGlcdOmxIpJ4z7Nxpr2u75jUtPyrKxBHDz4B5xOKy1brsRkOgmoKCuLIiFhDeHhNTT9XGDO5lwHg1t67OOy9mn8nhHPtuwYIkxljEg+TqfoQl5c1YdWVhtmnYf1GfGUunTEWuzEhdjxKSr+m2NkQ4eNtMtuR+uTrQHICcthZ/JOuh7ryiSVlfaRhWQUh3CsKIRQgxurwYlF72bvyUjyHEYMGh+g8NmXPwJwwyTRrm53Gdi79zYyM4dgMuUSG7sFna4Uj8eE02mle/f3K/ahrmOuoLB48XfVlvt8akpKkvB4zKxZ+xIA48dNKd9ChV5fhEql1Ft2bcvz8zvjdEZgMOSzeo1oZR439jYAtLoitnb4nbzQPFrkt0Dv0VNiKiE7PJveR3uz5aMtAZ23gIWo+lY15FLq4HjxcW7/5nYcbgc3dLsBq8HKN/u/YW/uXj68+kM6R3fm+v9dz+r01Tw66FH25O5h8f7FzBoxi1kjZgX+3/XZVcNyn+Jjzro5PPvbs9zf736WpC4hRB/CR9d8RMeojqdvew7/OzxctPK9+y7cVf+beIJDA8910Flxuch99HsD4seJhG9Zjqjh299T/WHgU1AUha5vdGVf7j6MWiMqVDg8DsIMYWQ8kkGooUqus4Hne8ECuOkm0chTXFzPQ+BncC2dzbbLDi/jx0M/MqnzJFqGie4DmzI3sT5jPff2u5e2EXV3XnV5XVy94Gr25e7j8SGP8+APD/LGlW9wT9976tyumlkBC1Fd7eoBFOH2upm5fCbf719KvL4dOpWJd679P1pFiicgPT4Pjyx9hH15+8iz5/H4kMeZ3L0Gx+4cnwQ/aYVppBWloVFpGJQ4CPWp/WHOgxBt3AivvipaeFJSICFBzLfbRTPqee9RHghNTYgAbOkiz9HyCvH76GeiJ3D8qU1Zp/P2preZ9v00Fly3gE7Rnej9dm/+PPDPvDr+Vbw+0YKmUWsqjovi8+FVvGhUmup9r045bl6vaNVduFCI0bhxoiIqLRWhWOdb/8Xr61/n7QlvM7qtsPO7A98xfel0nhz6JHf2ubPWsqtxBteh1+fl3u/u5f2t7zNr+Cz25O7hq71f8eaVb3J337vrPWYADreD51c9j8PtoFd8L6b2nBrQdhVmnZFH1ED27BEtGbt2wXXXQdeuopXMZhMn5cYba9/Wp/hQ+5OJNVDkKMRqCq+9gKq7dyY3VaACfDa1WJXlHrfSuIZMaYpC5OcMbHe4HST9XxJdY7rSKaoTH2z9gMN/OkySNYl3Nr/Dvd/dy7S+04gLEa2DS1KXkFmSydo71taZw9qStYUbvriBW3veymMDZlFYCFkFhfzh6ysY3LkDL415kdavt8ZqsFaUnVWSRZmnjPRH0k9rtKh1X8+E8uPz3MrnWJm2ErvbzuNDHmdipwaG42dxrVyQS76oSHQAKywUPUNbtRICZLOJPh51oVapuerTifxw8AfenfguRq14g+lDSx4iPiSeXUZr3Tte0wmqz7upSn3LTy2/vguinv9uVCJ0EWLSmZjWdxrPrXqO9Rnrua7rdSRZxYNm9/S9hxOlJ3j2t2f55sZvmLdjHqn5qaz+4+p6E+l9Evpg1pl5ec3L/HBQ5DILywo55NrPS50eJSE0gSk9pvDBtg+YPW42DreDad9P4+H+D9cvQnBOKopnhj9z1mWcKRfEI/LjdosnmW02MW02iyEWwsLq3m7F0RVc+t9LibXE0iO2B4cKDnG08CjvTnyXu/o01uRKA2msnkdjtSsQztD2E6UneORH8XjFY0Meo1d8r2rLH/v5MX4+/DNen5d3Jr7DwFYDAyr3g60fcOe3d3Jn7zu5ssOV3Pb1bUSZo0h9KBWNWsOek3vo/kZ3pg+cTqmrlA+2fkDqw6m0Dm/dIPuDxllcKxdUiM6Gvu/05XjxcY49coyhHw7laOFR0qanVXhITZFbvrwFl9fFF3/4omLe7LWz+fHQj7w94e16k4QXhKYmRHV4pAX2/IrHZIKB0+Mk8bVE2kW249mRzzJ+/nheHfcqfx7054p1Jnw6gdXpq3H73EzsOJEF1y8Imr0XkiYzZvUjAx/hhO0ETy17ig3HN3Bfv/uatAiBeE3Qwj0LmbV8FnPXz2Xu+rnMXjubwwWHG4cINUFG/3cU+r/rOFpwhEJHAYWOAvq81ZuwF0LRa/T1F3AeMWgNTOs3jd8zfmfGzzMI1Yee5tE/MfQJEq2JtI1oy4zBM4Jk6YWnyXhEbq+bNq+34XjJcYxaI2nT04i1NO2R6zYc38CA9wZg0BiINEVid9spchYxa/gsnr302WCbJ2hiHtEnOz5hyldTTpt/V++7ePeqd4NgUXWyS7NJ/r9kXF4XD/d/mNcvfz3YJjUKmowQAfx29Dd25eyiVVgrru58dbDNOSd0+ncnHG4HadPTuO/7+3h789scePAAHaLO5+A3DaCJCVGZp4yEVxOItcTy+fWfM3vtbD7Z+Qnr7lwXcC7nfGN32/H6vJh0psB6x18ENJnQDGBE6xE80P+BZiNCAFN6TOFY8TFWpa9i0d5FDGg5oPGIUBPEqDVyc/ebOZB3AIvOwqr0VXSN6dpoRAjEs3OhhlApQlVoUkLUHJmSMgUVKh5e8jC59lympjSsI5jkdPyd/+77/j7Si9K5s/ed9WwhCTZNKjRrrgz9YChrjq1Bp9aR+Wgm0eboYJt01j3pg03vt3uzLXsbOrWO438+TowlJtgmSepA+oaNgDnj57Dh+AZiLbGNQ4SaAf++/N9sytxEfEi8FKEmgPSIJDXTxD0iSdNCekSSmpFiI7mAyGS1RCIJOlKIJBJJ0JFCJJFIgo4UIolEEnSkEEkkkqAjhUgikQQdKUQSiSToSCGSSCRBRwqRRCIJOv8PwIhDao861OsAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 300x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tangermeme.saturation_mutagenesis import saturation_mutagenesis\n",
    "\n",
    "y_before, y_after = marginalize(ProfileWrapper(model), X, \"ATGATGTCAT\", func=saturation_mutagenesis,\n",
    "    additional_func_kwargs={'start': 1040, 'end': 1075})\n",
    "\n",
    "yb = y_before.mean(dim=0)\n",
    "ya = y_after.mean(dim=0)\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(3, 2))\n",
    "\n",
    "plt.subplot(211)\n",
    "plot_logo(yb)\n",
    "plt.ylim(ya.min(), ya.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.subplot(212)\n",
    "plot_logo(ya)\n",
    "plt.ylim(ya.min(), ya.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-marginalization-ism.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72ff3832-b459-4d5c-9e34-1b359784f6cd",
   "metadata": {},
   "source": [
    "Now, we consider ablations. In this case we begin with a sequence where the AP-1 motif has been substituted into the middle and we ablate it out using a dinucleotide shuffle.\n",
    "\n",
    "Here are the predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "feee7020-c340-4042-87e8-ea80f51cccd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 250x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tangermeme.ablate import ablate\n",
    "from tangermeme.ersatz import substitute\n",
    "\n",
    "X_ = substitute(X, \"ATGATGTCAT\")\n",
    "\n",
    "y_before, y_after = ablate(model, X_, 1030, 1075, n=1)\n",
    "\n",
    "yb = torch.nn.functional.softmax(y_before[0].mean(dim=(0, 1)), dim=-1)\n",
    "ya = torch.nn.functional.softmax(y_after[0].mean(dim=(0, 1, 2)), dim=-1)\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(2.5, 2))\n",
    "\n",
    "plt.plot(yb, c='0.6', linewidth=1)\n",
    "plt.plot(ya, c='c', linewidth=1)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-ablate-pred.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50502cb7-c67c-4ac1-b440-c0e82d63bc1d",
   "metadata": {},
   "source": [
    "Here are the DeepLIFT attributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9ee88457-0b83-4e21-8694-e69f8d6d9ce4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_before, y_after = ablate(ProfileWrapper(model), X_, 1030, 1075, func=deep_lift_shap, n=1, random_state=0)\n",
    "\n",
    "yb = y_before[:, :, 1040:1075].mean(dim=0)\n",
    "ya = y_after[:, 0, :, 1040:1075].mean(dim=0)\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(3, 2))\n",
    "\n",
    "plt.subplot(211)\n",
    "plot_logo(yb)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.subplot(212)\n",
    "plot_logo(ya)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-ablate-attr.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f6fd5a5-0d12-458d-83b9-69103c1e0e2b",
   "metadata": {},
   "source": [
    "Finally, here is the saturation mutagenesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e385ea1b-34a8-4955-9bc3-658558697161",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_before, y_after = ablate(ProfileWrapper(model), X_, 1030, 1075, func=saturation_mutagenesis, n=1, random_state=0,\n",
    "    additional_func_kwargs={'start': 1040, 'end': 1075})\n",
    "\n",
    "yb = y_before.mean(dim=0)\n",
    "ya = y_after[:, 0].mean(dim=0)\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(3, 2))\n",
    "\n",
    "plt.subplot(211)\n",
    "plot_logo(yb)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.subplot(212)\n",
    "plot_logo(ya)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-ablate-ism.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbdd9381-9157-4e92-ac8b-777e6522513d",
   "metadata": {},
   "source": [
    "Lastly, we will consider the case where the sequence operation is a substitution.\n",
    "\n",
    "First, we can get predictions from the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "798a3fd6-4112-41a7-aafd-734794596c7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 250x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tangermeme.variant_effect import substitution_effect\n",
    " \n",
    "y_before, y_after = substitution_effect(model, X_[16:17], [[0, 1054, 0]])\n",
    "\n",
    "yb = torch.nn.functional.softmax(y_before[0].mean(dim=(0, 1)), dim=-1)\n",
    "ya = torch.nn.functional.softmax(y_after[0].mean(dim=(0, 1)), dim=-1)\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(2.5, 2))\n",
    "\n",
    "#plt.subplot(211)\n",
    "plt.plot(yb, c='0.6', linewidth=1)\n",
    "\n",
    "plt.plot(ya, c='#FF6600', linewidth=1)\n",
    "plt.ylim(0, yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-ve-pred.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2c3478-7527-4425-af32-5d28c36a9e17",
   "metadata": {},
   "source": [
    "We can get DeepLIFT attributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "39a715a6-ef22-4cd7-9cb9-939dc90810a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_before, y_after = substitution_effect(ProfileWrapper(model), X_[16:17], [[0, 1054, 0]], func=deep_lift_shap, random_state=0)\n",
    "\n",
    "yb = y_before[:, :, 1040:1075].mean(dim=0)\n",
    "ya = y_after[:, :, 1040:1075].mean(dim=0)\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(3, 2))\n",
    "\n",
    "plt.subplot(211)\n",
    "plot_logo(yb)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.subplot(212)\n",
    "plot_logo(ya)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-ve-attr.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d633e6a-e1ff-4b0e-91ad-56c81dbc355a",
   "metadata": {},
   "source": [
    "And we can get saturation mutagenesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "cd94eaaa-7ce6-40b8-b042-13336bf1cbfa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASIAAAC+CAYAAACRbQI6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIVhJREFUeJzt3Xl8VNX9//HXbEkmk32FBIjsoCIoKiqgUtBKrbZYrdsDl9a61G7abxeXWtraWvT3te3DhYdWLYp83VposaKUtoqAogKCAYJsYQsJZF9nMtv9/XFyc2dIJnODkDsJn+fjkcfM3C03ycw755x7zrk2TdM0hBDCQnarT0AIISSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhGW8XrjpJkhPh3vvBenjf/KSIOqvbLaev/pSOHhMu/3hD7BoEbS0qOdPPhm9/p537uH2N29n65Gtx+EkRSKzyVizfipe2PTVn3XTfbD9UcifDhe8Bu5CU7tVVcHo0SqEdNnZsH8/pKWBpmkkPZxEMBzkjWve4OpTrz5BP4BIBFIiOhmUL4LVc2Dfa8f3uIffhbLfgxaGI6tg7TXquQkvvxwdQgD19VBbq563+FsIdpS06rx1x/OsRQJyWn0C4gSrXAHrblLPD/4dgs0w8rbO1X/b9jf+U/4fzik6h1vPvLV3x970s+jX1avh0HIo/mrcXZct63l9ZPhIEA18UiIayMJB2Hhv9LKN94CvuvPl8p3LWbB+AX8t+2vvjt28E+o+6brcdzjurm1tsHZtz9tIEJ1cJIgGsiOroGlb9LJgC7SWd76s9aq6UG1bbe+OXfHWMZ/W5s0QjqjBORxdt5EgOrlIEA1kFXHqP0BNW03Uo2m1H8ZeF+dq3saNxqZjx0JjIzz7bPQhJIhOLhJE/ZWmGV+xlh1ZFfcwnSUiby9LRPWbjefFV0L2WaZ33bXLeP7YY+DxwHe+A1dcYSyXIDq5SBANVKF2aIzof1N0OSQXdNlMLwk1+Bo6r1LFP7YPmneo59lnwbQlcMlayJlsavfDHc1IWVnwla8Yy3/8Y+O5BNHJRYJooGoqA60jWIZ9Ey76J3z5Y0jK6dwkrIWP7QPvOwJ0lLpOfwjsDnCkwOQne9xNpwfROedEtw9deCEUdGRlva8egPSk9M7nQGJ15BTHjQTRQOU9ZDw/43fq0VMCE3/XubjB10A4ot+P6XaiduOqG4VfMp7nnQf5U+PurgfRyJHRy202cLvVcz0Uh2cPlxLRSUCCaKDSL6OnjYD0iE/88Js7q2j6lTKX3RX1Ov6xj6hHdzG40qPXZYyLu7seRMOHx95GD59Tsk6hLdCGL+gzd26iX5IgGqj0IDo6GBwpkHYKYJSARmSPiHod/9gdQZQWI0l6aEgPBo3e0yNGxP4Wdd46Ul2pFHrUkJF6b33sjUW/J0E0UHWGxciYm+jBMzp3dNTruNo7ju3pIUliqK428qmwh2Fpdd46slOyyU7J7nwtBi4Z4jFQ6SWiHsJCv2Q/KntU1Ov4x9arZoN7fVpNTcZzvT2oO3XeOrLd2WSlZHW+BqJLWXrjtIzb7vekRDRQ6UGUErvYoZeARuWMinodV6BBPTpTe31agYDxPCUl9nZ13jqyUrLIdkuJ6GQgJaJE4K9XY8Ba9sCgS2Hcj8HZQ3HBjGCzeuzhOHrjtB5EpktE4Y40sfeQJDFEBlGsEpE34MUb9JKd0k2J6Ivq6RK/lKwsIyUiq3mr4N/TofxFNXq99Bfw7iwIhzo3mbt0Lqc+dSpPfmyunw5ghIWj49Me8kOwTX11rDvmEpHe8dHREUQHlsDKC9TX5gd63DUY0WcyVolI7zeU7ZY2opOFBJHVPnsgugc0QM0HEPZ3vnx/3/uU1ZSxoXKD+eN2hkVHEG38IbzhUV/bHgGMEtCgtEGkJaWZv3yvHRVyviqo+VB96T2uY51WnMGuYFwhy0o2qmZRnRrFgCNBZCV/I+xd1OMmgVCAg00HAdjbsNf8sfWwsCfH3KSmrYYkRxKprlRy3DnmS0R6FcbW+7ePM6IxoL29+2300k+3jdViQJIgslLVCqMKNfZHMOcInPu8UeUBDjQd6Oz9XF5f3s1BYtHbQmK3e9R6a8lx52Cz2chx55hvI7J3pEk4RpL0wOUynnu93W/TGUQn4vJ9vIHCwhLSWG2lhs/UY/aZcObjqiF15LcgKatzk8jwOdB0gEAogMvhIi5bx582FLtHck1bDXmpeQDkuHPYXLWZUDiEwx6jztR5bFfcY8cSGUS+GLvroZOVkiUlopOElIis1LxTPRZfEX01Z+hVnVe7yhtUEI3IHkFYC3Og6YC5Y9v1sOi+2KFpGrVtqkQEKog0NHNtMfb4IRdLckRNMW6JyJ2Ny+HC4/JIEA1wEkRWaupo2M09P+YmervQ9GHTo17HZT+q1OIuUl8dGtsbCWmhziDKdecCJq+cOVKjjz34Mpj0qKnTys83nkd2boykh05tWy2lh0vxJPU+iEpL4corYdgwOPdceOaZ6IZykVj6tGrmC/q4dNGlaGg8funjnFN8Tl9++8SjT9kaa8wWRolo+rDpvLj5RVVV62GwaCd9uo9gq3o8/RdqkOrH3waMPkR6aSPFmRK1vEcpHWni7wiHtBFQcLGJk1K3CnK7VWlo377ut9FD51vLvtW5LDM509TxQd0h5OabjeA5cAA++QSGDo2e/0gkjj4NotLDpazevxqANfvXSBDpIeHq+JAdWQXtHUGQex6kFlFeX05aUhpnFJ4BGMEUV0rHxD7eg92u1ks+r2x5hVe2vNJleY8d/3YsUI+tMZKkBzabGmO2dy/s2dP9NnW+rqWfxvZGguEgTnvPb9kjR+DOO40QmjFDlbw2bJASUSLr0yDaWGlMVryxamMPW54EwiFj4jJ9Ko3ND0BNx+0tpi2B1DnsbdhLSWYJJVklQC+qZvrQjpbugyvWFTJTV870ElGryXM5ih5E5TEyNVY1rMHX0Nm4Hsv//R+0tqrA++c/jRLQW2+pKWlFYupVEAUC8Prr8NxzsHMnZGbCJZfAfff1PJJap3fIy3XnsuFQLzrnJbhAQL3ply9XH4Jx4+CGG2DUqB52iixxxJii1RvwUtlSyaRBk8hPzSfFmWK+RKRPC9va/fax2oI6l3f2FepmYOmR1caxNa3XMyPq75UtW6KXHz4MoVDsIKrz1sUNovffV4+zZkVXwy6/vFenaKlPP4UPPlDPzzwTzjsP7AO8Ndd0EIVCcNVV6gMHqldsRQVs2wbnnw/XXhv/GBsrN1LoKWTasGksKVtCq78VT1L//je1bx9ceinsOKpD8cKFsasegOoMaHepfkSBJkjq2gayr1FVfUoyS7DZbAzLHGa+L5FeImoo7TYsYrUF9aqNKNiqpqTNPNXcOXXQg2jbNjh4EIYMUa+ffx5uvDH23ENm5iTS75f21fj3eEw4u3apn//jj6OX33UXPP20NefUV0zn7MsvqxCy2eCJJ9RN8lpa4C9/gdzc+Pv7Q35Kj5RyRuEZTCyciIbG5sOb4++Y4G6+WYVQfj689JL6b7Z4MUycaGJnvUFZH81+7jMwzEh0PXSGZAwhFA4xNGMolS2VeAMxrntH0tuIfFVQ+3GX1XFLRD2JnIS//MX42x+luNh4/utfq8eqKnVHD+i5RNSTUEi1ER39PfoDvx9mz1YhVFgIv/+9ej/dfnvsbg4DiekS0auvqsdrroHvfU89T0qCW24xt/+26m34Q34mFk5k4iD1Kd1YuZELhl7Qm/NNKLt3w6qOO/YsXqyqqQCTJsF115k4QPpoNV1HwxbImgCZp0XN8aO3Bz347oM8+O6Dncv3N+5nbN7Yno8deSXu03tg5mqj3xJfsI0oKVuFqL8OPv+jmjGgckX8/TpMmmQ8f+459T5asQIaGiAYDtLY3kh2SjZTh6n5r/c17KP0SGncIIoc2Z/a+xlKLLVihSoRORzqPTW24887d66q7g90poNozRr1OGvWsX0jvU1o4qCJnVeAejWIMwH9+9/qMSOj6+/FVJ0+bTRUr1E3Kzzl+i6rY7UHlTeUmwiikeD0qOpTzYfwtyx1l9cOesnntatfo8BTQCgcYtaiWeZKRDYbZE2EI++qwbnv9u5NcVbELdA0DZ56ynjd5G8AYMqQKbx5/ZsAvPzZy8xdOjduECUnq7FswSDU9PJ+kVbTmzymTzdCSHcyNLKbrprpxcOMjGP7RvoVs88Of8bynctx2BxRV9H6I71DXl7eMd7JJl1N0cr+N6DjAxgpZhCZaSey2SFrkvE6IoTAKPnMHjWbi0+5mJkjZqoR+GbHm+WYv6Hi0YYMiV11amg3xpnpzA7zsNng9NPV888+O+bTs4QenP2tSnm8mA6ioUPVY48NsD3QL9c/9sFj3L38bkJaiK1HtvbruzMMGqQeDx2KrhaYlt9RLfVVqVLFjieh8p3O1eX15dhtdi4suZALSy7kzEFnquVmr5wNil1SqWmrwWV3kZaU1rmsVyPwC4+xaIwKjMi7ukbqLoh6M/B1uuqAzquvRo/uDwZVO1Siyuu4GFhRYe15HDMtDK0H1B2A6zaoSf7C5j8UpoPo619Xj3/+s2qo1gWDRgNhLMFwkM1VXRumQ1qI0sOlZk8h4cyerer0Pp9qtI9Ub2b6nLypxtWtug2w4fvQtL1z9d6GvQzNGMqqW1ax6pZVLLl2SedyU4pjfNrTRneOM7NFFOVy3bnUeeui7nUWU8FF4Ezrujx7kqlTu+aa7pe3ho1xZp2H1KeL7aaj49Euu0w9HjwIX/sarF8P//mPurK5fr2pU7OEHsyrV8P27dHrWlq6bp8wtDBs+jksHQwf3QoHl0LVv2Hn07D1d/H372A6iG6/XdXBy8tVHf+RR2DePNXw+O67Pe+7vWY73qCXGyfcSMt9LbTc18KCy1Xv3P7cTpSXpy63grrE+t3vwoIF8IMfqB69cdmdMO5/ul3V7Ein1lvb2ZERoDi9GLvNbr5ElDNZNSRHyj4Tbeg11LTVdI4z69zcnUNYC9Pga4h/bKcbxt4Tvcw9GMb8wNSpzZjRtV3tiisA97FXzUD9c9BLRStWqLvJzpoV/z1qtUsvhdGj1ZW/iy5Sn6+FC+E73zEuDiWkyn9B2XxIHQIzVqppjtsOqHGIkTfijMN0EI0fD0uXqira55/D/ffDr34FZWWQk9Pzvnpb0OTBk/EkefAkeTi76Oyodf3V008bYbRggQqjJ56Inu6iR+PuhVF3Gq/tLjj3z5Q71CXykkwjiFwOF0XpRb2bl2jSY8bkaCmFMPV1WoJeAuEAuanR/S70YDI9U+P4/zEG0jo9cMGrXW+4GIPNBo8/bjTEFhaqRuvIkfe63lTNbDbV6fbofkSDBsXpYGqxpCR4+22YMkXVMO6/H269VV1V7KvG6oNNB9lctZlNVZvM30cufyrkXQCNpbD1Yaj9BIZcBftfh51Pxd+/g03TzM0I9dBDD7Fp0yY0zU519SRaWwfjdLaRl1eK2220Kyx7U13puDKiEaDOU0e9p55BjYPwtKvfasgWYm/+XtwBN0X1RdTXj6GpaTh+fwZ2ezs2m4am2cnJ2UZ2trrsrGk2Kiqm09w8DLe7lqKi97HZoKJiGn5/Bnl5W0hObgD0qoWN9oJtVGZXUlRfRFZrFgCN7kYqcisobCgkpyWHoCNI2BbGrtkJ28LYsOEIO0CDHUU7cPvdDK82LofvLtiN3+ln7KGx2Duy3OvNpbr6LEKhJDyeCvLytmC3Gz2mu/u9GDTOLT5MVko7GysLqGlz05bURmVWJZltmeS1GL2JD+YcpN3ZzogjI7BhroV8aEYz4/Lq+biikMb2ZIL2IPvy9pHqT2Vwg9Fd4EjGEZpTmimuKyYlaG5i/KyUdqYUV7GpKo/Drb3/xLS1FVJdPYnCwo9JSamnPrWeurQ6ChsLSWs3qn67C3aTFEpiaO1Q08eurR1PU9MIkpPrKSjYgNNpfiK3urrxVFdPIhx2kJlZTmHhxzgcqs0jHLZTVXU+jY3DcTj85OaWkptbFrX/oUMX0NQ0HI+nkqKi93E4onvPHz58Nk1NwykpeYekpOaodY2Nw6mvVzfGzMzcQ1bW5wScflqTW/E7/SQHk/E7/djDdlL9qbj97s73Qnfvs5q0Gg5nHaa4tpgsbxagPn/bi7bj8XsYXDeYuvQ6gvYgGd4Mgo4grcmtuP1usluycWrGxfXu38caxektjMxpJD0pgM2m0eJP4lCzh//3l9XmfuHa8abPd9cLN9+sdrnqKk1rbY1e5/Opx+3bNW3SpMjp9DQtJ0fTdu5U++zfr2llZZq2a5em7d5tfAVCAW32y7M15qFd/9frtZuW3qQxD23Gwhlae7A97rnd8eYdmm2eTZv10ixt1kuztBkLZ2jMQ/vZyp/16mc8lt+L6HuHDmnalCnR7zPQtMsvV+vXrNG04uKu6594Qq2vqVHbRq477TS1XPfss8a6ceM0rbn5OP4A3bzPVu5e2eU9+8H+DzTmoX1/+fe/8PGPB9MlohNpzx7VvX/rVjjtNNVT2+lU9eXJk+GCC+CMM1Q18GirVsGFF/Z8/BZ/CxctvIiwFibFmUJzezNrv7WWzJT4U0tUt1Yz+onRjM8fzxvXvMHsxbOpaathx/d2kJ5srhoCyM0A+4mLLlLj1TIyVNvMqFGwbh3s3w+LFqlxhLW16jL7nXeqKtXf/67at+67D66+Gv72t67HXb9evZebmtQxqyOaT376U5g//zj9AN28z1r9rWTNz2JY5jCuGKNKMtuqt7Fyz0pev/p1rjktxpUDk8c/Lo57tJ0AixYZQTx3rirpfPihps2cqWmrVpk7RmVzpbbgkwXagk8WaAcaD/Tq+//vB/+rMQ/th2//UGMe2vMbn+/9DyElooS3bZvxZ3r77eh1tbWa9tRTap3Ho0pOkSoqNG3TJmN/l0vTrr3WKF2tX6+2++1vu5amBg06jj9EjPfZOc+eozGPLl+VzZXH5fhfVL/4ZNx0k/rZTz1V00IhY3kgoN4gJ5o/6NdOf/p0zf2wW5vy5ylaKByKv9PRJIgS3vz56k90yindr//yl9X6W27pfv2DD6r1drumvfuusfzxxzVtwwb1/KyzugZRbu5x/CFivM/ueecejXloty+7XZu/Zr6W/JtkbeSfRh63439R/WJyAX14yQ03RA+dcDrjX7E7HlwOF6V3ldL2QBvrbluH/RhuoyMS38GOOeSGx5gBU59RcvTo7tdv6OiJcsklcPHFxvJ77lFNC1VValC0FfSphicUTuC606+jPdTO9JLp1pxMNxL+Lh5er9GbW+++L8SJoN95NtZc2vo92WLdj00Pou6mo3U64aOPrGsinDZsGgAfHvyQAo/qGqKHUyJI+H/tkb1KIydeF+J4u6BjxM3Wrd2PFpgwQT1u7KbrW0ODsc+YMd0fP7I0lJ2tOr72RYkeIN+Tz7i8caw7uI4PD3wISBD1SmTHwMihJf2CzWZ89bRMJITLLoP0dDVk5667jIGoe/bAH/8Ic+ao12+9Fd1Tu7YW3nvPeB1rfq7NEaOcHn4Y/vQn+Mc/+u6tMH3YdPbU7+GfO/9JoaeQ0bkx6pgWSPggyshQd32AxB60KPq/lBTVK95mgyVL1CX6ggIYOVIFxte+poY0aRrMnKm+LrsMSkqMqV0h+t5tkfQBrYMHqyFTANOmqeP2Bb0EtKtuV0K1D0E/CCK7XY0XAnjnnZ63TThdL5DILY4T3M03q0GyV1yh3nv19XD22UafoRUr1KR3Dgf897/qtcMR3X5ZF2MkyuHD6vFLXzLamwDuuOPE/TyR9HYigGlDp/WwZd9LiA6N8Tz4IPz2t6pktH49nNoxRfLq1arEZGpaViGOQax7A1RVqbYkt1tNcO9yqXu2tberO4lc33WeO9xuVe175BH4+c9P0AnH6XD4SukrBMNBZo2YxeD0wd1u80WOf6z6RRCVlan/OOGwmgL0uutUw+Dbb6v/SvF6VgvRF845R/2jvO02NV1OpKYmddcbUHMlmbnZxDE50T34T9DxE75qBmrkv/4fpK0NXnhBTa0ZCll7XkJEmjxZPf7jH9FXe/fsUXea1Z1ySp+eVr/QL4IIVNXs1VeNP2JODjzwgLrnkxCJQJ+DqrramAPpL3+BqVPVDSV1EkRd9Yuq2dFaW1UVTa6Ai0QSCKgrbAcOdF332GPwk5+o5z5f7CtrX5hUzfqOxyMhJBKPy6WaDY6+lVHksCSb7QSGUD/WL4NIiEQ1a5bqQT1zpurYeP75qtuJPiogxdx8cyedhB9rJkR/M2aMcc873XPPqcd+GUTdVT+OcxVNgkiIPqDfbkofJXDcHR0Wka/7QTOwVM2E6AMyQWfPJIiE6AP64G1f/72f6AklVTMh+oA+tky/dXu/0gfFOAkiIfqAXiKKNanaF9bP63xSNROiD+g3SdQ0qZ51R4JIiD4QObtoQ4Nlp5GwJIiE6AOFhcbzyHFnQpEgEqIPFBQYz8vLrTuPRCVBJEQfSE83OjNKEHUlQSREH9FLRZ99Fr08cr7rk5UEkRB9RG8n+u9/we83lj/zjDXnk0gkiIToI0OGqMfqanjySfV85UpYvty6c0oUEkRC9JHImzzMmwe33grf+Ea/74t4XEgQCdFHzjzTeN7cDAsXqkchQSREnznvPJlZNBYJIiH6SH6+cbNQEU2CSIg+dPXVXZfJHNYSREL0qbvvhqKi6GXf/rY155JIJIiE6EOpqfDoo0Zb0aRJcN99lp5SQuiX9zUTQgwsUiISQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQlhOgkgIYTkJIiGE5SSIhBCWkyASQljOafUJiJNXayvU10NLCyQnw6BB4HZbfVbimARaoPlz8DeAFgRXFqSNgJR8U7vbNE3TTugJChFB0+DRR2HhQkhKgjlzoKAA2tth/3544AHIy7P6LBNTW6CNmS/NZEftDprbm/nX3H9x8SkXW3tSgRZYNxcqV8CoOyF3CjiSob0WbA4YcYupw5gOogULYOlS9SaZMQPS0sBmg2AQpk6F4cOP/WfRNKiogKoq9V/S5VLH1jQYNgyGDAG/H+rqwOdT39Nuh5QUyM9X2/ckrIV54dMXWHdwHQ6bg4mDJnLH5Dtw2B2d22yu2kxFcwU2bEwvmU5aUprp829vh6YmdY7hMDid4PFARsax/kYGrl27YMwY9bf96CM499yu22iaxuLSxbyy5RUGpw3G4/Lw8JceJj05/YSfXyik3meRf0+XC7KzYcsWeOMNtXzqVEhPV+/DcBhOPVV9xRIIwJo18PnnKoAHDwZHx9vPbodZs+KcVzjEN17/Bv/a/S+WXb+M+Wvn80nFJ6z91lpOKzjN2NBmU48nqnxx9PEPvwf/nQGZp8Nln0LIB1t+DVUrIeSFr243dVjTVTO7XX0dfR7665gnCviCPsqqy9hdvxun3UmqK5U6bx1DMoYwoWACb7ycyfPPq1C56y71Abbb1SHa2uDnP4e33oIpU+Dyy40PeEsLTJgAu3fD4cNQUgI5Oca+mgbuoj3cvfxuGn2N3DjhRpx2J4tLF7OkbAlPfeUpmtqbeGTNIzT4Grhhwg2sP7SeX773S64//XpuO+s2AFwOFynOlM6fxxvwEgwHqdyXxv332ygrg1tvVR+wlBT1pguF4More/iFahoEGiHYpv6D2JNUkTYcBC2E5srGq4Vo9bcS0kIkO5JpD7XjtDtJT0onyZGErcsv39AWaCOshaMCNRgO4g14SXYmEwwH0TQNt8uoC/mCPjRNw5Pk6eHEO4RDEPaDFor+29uTwB77P8OoUbByJbz0EvzoR3DaaZCaqnZtb4cf3l/Nrz7+AWXVZVx/+vUMyRjCa1tf47znz+OZrz7DtGHTor+f/rvseFi1CrZuhcxMGDlSfehtNhUWI0eqQOluX4B16+AXv1DVxTvugBEjVAj5/eqfZEUF7N2r/slE/upjfea9XvX9HQ4oL1f/zHfvhu9+t+uP8NFH8MILKgQvuQRyc9V+4TAUFcGy1l/w3t73+OVFv2Rn7U6uGncVbYE2vvnXb/Leze+R74ldBQprYXxBH+3Bdmw2G3abnWA4iMvuwu1yEwwHqWqpotHXSKorFX/IT1gLk5uaS4GnAKe9h5govBjOXwz7X4f3ZkPa8I73cgDcRbH3O4rpEtFDDz3Epk2bTB94oDiYfZDPiz8nzZtGcV0xB3MP0pbcxviK8QxuGGz16cW0dsxa6tLrmP3pbJxh9Ubam7eX0pJSJuybQElNCe3OdgLOAM6Qk6AjiCvkIimQhD3iGsayN98E4Morruhc5nEFyHH7CIbtNPiSsNsgyREixRmiNeCkqT25x/0Hqra2fPbs+TpHjpyFpjlISalF0xyEQslMnjyftLRDVp9in1u2bJmp7aSNyIRWfyuLPluEL+gjLSmNuWfMJdmZHH9HC93x5h08u/FZ1n9nPZOLJgNw74p7+cO6P7DqllVcWHKhuQOd6KL+AOHzqdLdnj3wm9+oti79VxcOqxJyvCaEk5lcNTPBk+ThzrPvtPo0emV8/ngAPjn0CcUZxQBsrd6q1uWNN38gCSBT2trgUEeBZ9Kk6Kqb3qwhYpMS0QC1YtcKLlt8WZflue5can5aY8EZDXxLl8KPfww1NXDttao9zO+HbdvgoYdgfC/y/2QjJaIBSi8RmV0uvrg5c9TXjh2qK0J9vbp4MWcOjB1r9dklNgmiAWpoxlA8Lg/eoJccdw7BcJAGX0PvqmXimIwZo76EeVJzHaBsNhtj88aS6kql+ifVvPj1FwEYlzfO4jMToisJogFsfN54WvwtHGo+xM7anZ3LhEg0EkQDmB46O2p3sKN2h1ombUQiAUkQDWB66Oyo3cGOuh2kulIpySyx+KyE6EqCaAA7ukQ0Nndsj8NChLCKBNEANipnFE67k0+rPuVQ8yGplomEJUE0gLkcLkZmj2T1vtUAjMuVK2YiMUkQDXDj88cTCAc6nwuRiCSIBrjIy/Vy6V4kKgmiAU4PH4fNwejc0RafjRDdk0GvA1yLv4XddWpCuqiZ/IRIIBJEQgjLSdVMCGE5CSIhhOUkiIQQlpMgEkJYToJICGE5CSIhhOUkiIQQlpMgEkJYToJICGE5CSIhhOUkiIQQlpMgEkJYToJICGE5CSIhhOUkiIQQlpMgEkJYToJICGE5CSIhhOUkiIQQlpMgEkJYToJICGE5CSIhhOUkiIQQlpMgEkJYToJICGE5CSIhhOUkiIQQlpMgEkJYToJICGE5CSIhhOUkiIQQlvv/Cce5BnS0wKQAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 300x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_before, y_after = substitution_effect(ProfileWrapper(model), X_[16:17], [[0, 1054, 0]], func=saturation_mutagenesis)\n",
    "\n",
    "yb = y_before[:, :, 1040:1075].mean(dim=0)\n",
    "ya = y_after[:, :, 1040:1075].mean(dim=0)\n",
    "\n",
    "###\n",
    "\n",
    "plt.figure(figsize=(3, 2))\n",
    "\n",
    "plt.subplot(211)\n",
    "plot_logo(yb)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.subplot(212)\n",
    "plot_logo(ya)\n",
    "plt.ylim(yb.min(), yb.max())\n",
    "plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('tangermeme-fig1-ve-ism.pdf')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tangermeme]",
   "language": "python",
   "name": "conda-env-tangermeme-py"
  },
  "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}