discovering_DNA_motifs_using_convnets_classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Discovering-DNA-motifs-using-convolutional-neural-networks\" data-toc-modified-id=\"Discovering-DNA-motifs-using-convolutional-neural-networks-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Discovering DNA motifs using convolutional neural networks</a></span></li><li><span><a href=\"#EWSR1-motif\" data-toc-modified-id=\"EWSR1-motif-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>EWSR1 motif</a></span></li><li><span><a href=\"#Generating-training-examples\" data-toc-modified-id=\"Generating-training-examples-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Generating training examples</a></span></li><li><span><a href=\"#Preprocessing-the-data:-one-hot-encoding\" data-toc-modified-id=\"Preprocessing-the-data:-one-hot-encoding-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Preprocessing the data: one-hot encoding</a></span></li><li><span><a href=\"#Building-a-convolution-neural-network\" data-toc-modified-id=\"Building-a-convolution-neural-network-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Building a convolution neural network</a></span></li><li><span><a href=\"#Training-and-evaluting-the-network\" data-toc-modified-id=\"Training-and-evaluting-the-network-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Training and evaluting the network</a></span></li><li><span><a href=\"#Interrogating-the-learned-convolution-filter\" data-toc-modified-id=\"Interrogating-the-learned-convolution-filter-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Interrogating the learned convolution filter</a></span></li><li><span><a href=\"#Two-ways-to-achieve-high-performance\" data-toc-modified-id=\"Two-ways-to-achieve-high-performance-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Two ways to achieve high performance</a></span></li><li><span><a href=\"#A-second-pass-at-interrogating-the-convolution-filter\" data-toc-modified-id=\"A-second-pass-at-interrogating-the-convolution-filter-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>A second pass at interrogating the convolution filter</a></span></li><li><span><a href=\"#Learning-part-of-a-motif-can-be--sufficient-for-high-performance\" data-toc-modified-id=\"Learning-part-of-a-motif-can-be--sufficient-for-high-performance-10\"><span class=\"toc-item-num\">10&nbsp;&nbsp;</span>Learning part of a motif can be  sufficient for high performance</a></span></li><li><span><a href=\"#Other-things-to-explore\" data-toc-modified-id=\"Other-things-to-explore-11\"><span class=\"toc-item-num\">11&nbsp;&nbsp;</span>Other things to explore</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based upon [Gökçen Eraslan's PyCon talk](https://github.com/gokceneraslan/dnaconvnet-notebook)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discovering DNA motifs using convolutional neural networks\n",
    "\n",
    "The goal is to train a convolutional neural network to predict whether a given input sequence contains a given DNA-binding motif. We will do this by generating synthetic training examples (sequences) that have been labeled according to whether they contain a given motif or not. The hope is that the trained network can be used to recover, somehow, the injected motif. \n",
    "\n",
    "## EWSR1 motif \n",
    "\n",
    "We fetch the following motif from [JASPAR](http://jaspar.genereg.net/cgi-bin/jaspar_db.pl?ID=MA0149.1&rm=present&collection=CORE):\n",
    "![title](http://jaspar.genereg.net/static/logos/MA0149.1.BIG.png)\n",
    "\n",
    "\n",
    "This motif is a visualization of the \"frequency matrix\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "motif = np.array([[   0,   2, 104, 104,   1,   2, 103, 102,   0,   0,  99, 105,   0,   0, 100, 102,   5,   3],\n",
    "                  [   0,   0,   0,   0,   0,   0,   0,   0,   0,   2,   4,   0,   0,   2,   3,   0,   0,   3],\n",
    "                  [ 105, 103,   1,   1, 104, 102,   2,   3, 104, 103,   2,   0, 105, 103,   0,   2,  97,  97],\n",
    "                  [   0,   0,   0,   0,   0,   1,   0,   0,   1,   0,   0,   0,   0,   0,   2,   1,   3,   2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each row in this matrix corresponds to one of the four possible nucleotides and the columns correspond to  positions within the binding site of the transcription factor. The matrix elements indicate the frequency with which the corresponding nucleotide was observed at the corresponding position in the binding site. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Generating training examples \n",
    "\n",
    "We wish to create a set of \"positive\" training examples in which the motif is embedded. We can do this by drawing nucleotides at random with probabilities proporitional to the frequency matrix, and then extending the sequence so generated upstream and downstream by drawing nucleotides at random with equal probability: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence_length = 30\n",
    "motif_plus_background = np.hstack([np.ones((4, (sequence_length-motif.shape[1])//2)), \n",
    "                                   motif,\n",
    "                                   np.ones((4, (sequence_length-motif.shape[1])//2))])\n",
    "\n",
    "number_training_examples = 10000\n",
    "training_examples_positive = \\\n",
    "np.array([np.random.choice(['A', 'C', 'G', 'T'], \n",
    "                           size=number_training_examples//2, \n",
    "                           p=motif_plus_background[:,position]/float(np.sum(motif_plus_background[:,position]))) \n",
    "          for position in range(sequence_length)]).transpose()\n",
    "\n",
    "sequences_positive = []\n",
    "for training_example_positive in training_examples_positive: \n",
    "    sequences_positive.append(''.join(training_example_positive))\n",
    "    \n",
    "labels_positive = np.ones(shape=len(sequences_positive), dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's produce the negative training examples by sampling nucleotides with equal frequency, regardless of their position in the sequence: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "training_examples_negative = \\\n",
    "np.array([np.random.choice(['A', 'C', 'G', 'T'], \n",
    "                           size=number_training_examples//2, \n",
    "                           p=np.array([1,1,1,1])/4.0) \n",
    "          for position in range(sequence_length)]).transpose()\n",
    "\n",
    "sequences_negative = []\n",
    "for training_example_negative in training_examples_negative: \n",
    "    sequences_negative.append(''.join(training_example_negative))\n",
    "\n",
    "labels_negative = np.zeros(shape=len(sequences_negative), dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wrap the examples up in a dataframe to visualize the positive examples..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>sequence</th>\n",
       "      <th>observed_label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AACCCTGGAAAGAAGGAAGGAAGGTAGCAT</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>GCGCTCGGAAGGAAGGAAGGAAGGCGAGTT</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ACGTGGGGAAGGAAGGAAGGAAGGGCGTAC</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>GGTTCTGGAAGGAAGGAAGGAAGGAAGTCT</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CCACGGGGAAGGAAGGAAGGCAGGCGGTAA</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         sequence  observed_label\n",
       "0  AACCCTGGAAAGAAGGAAGGAAGGTAGCAT               1\n",
       "1  GCGCTCGGAAGGAAGGAAGGAAGGCGAGTT               1\n",
       "2  ACGTGGGGAAGGAAGGAAGGAAGGGCGTAC               1\n",
       "3  GGTTCTGGAAGGAAGGAAGGAAGGAAGTCT               1\n",
       "4  CCACGGGGAAGGAAGGAAGGCAGGCGGTAA               1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from collections import OrderedDict\n",
    "df_training = pd.DataFrame(OrderedDict([('sequence', np.concatenate((sequences_positive, sequences_negative))),\n",
    "                                        ('observed_label', np.concatenate((labels_positive, labels_negative)))]))\n",
    "df_training[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and the negative examples: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>sequence</th>\n",
       "      <th>observed_label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5000</th>\n",
       "      <td>TTCGCATACCGTCATTTCTTAACCAGGAAG</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5001</th>\n",
       "      <td>CTGACAATTGAGTCTAGCTGCTGGAGCGGT</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5002</th>\n",
       "      <td>AACCTGAGGCGTGTTATAGTCAATCTGGAT</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5003</th>\n",
       "      <td>TGCGTTTAGATTACTACCCTGGTTATCTGG</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5004</th>\n",
       "      <td>AGCATGAAATTATAAATATGATACCTCTAG</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                            sequence  observed_label\n",
       "5000  TTCGCATACCGTCATTTCTTAACCAGGAAG               0\n",
       "5001  CTGACAATTGAGTCTAGCTGCTGGAGCGGT               0\n",
       "5002  AACCTGAGGCGTGTTATAGTCAATCTGGAT               0\n",
       "5003  TGCGTTTAGATTACTACCCTGGTTATCTGG               0\n",
       "5004  AGCATGAAATTATAAATATGATACCTCTAG               0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "half_way = len(df_training)//2\n",
    "df_training[half_way:half_way+5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing the data: one-hot encoding\n",
    "\n",
    "Since the sequences are categorical data, we must encode them as numbers before passing them into a function that maps them to class labels. We use \"one-hot encoding\", creating a tensor with dimensions `(number_examples, sequence_length, number_channels)` where `number_channels = 4`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "encoded_sequences.shape:  (10000, 30, 4)\n",
      "observed_labels.shape: (10000, 1)\n"
     ]
    }
   ],
   "source": [
    "from load_preprocess_data import _one_hot_encode_conv1d\n",
    "\n",
    "encoded_sequences = []\n",
    "observed_labels = []\n",
    "for sequence, observed_label in zip(df_training['sequence'], df_training['observed_label']):\n",
    "    encoded_sequences.append(_one_hot_encode_conv1d(sequence))\n",
    "    observed_labels.append([observed_label])\n",
    "encoded_sequences = np.array(encoded_sequences)\n",
    "observed_labels = np.array(observed_labels)\n",
    "print('encoded_sequences.shape: ', encoded_sequences.shape)\n",
    "print('observed_labels.shape:', observed_labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the positive examples appear at the head of the list of examples, and the negative examples at the tail, there is a danger that the network will be influenced by  this artifact. This is combatted by shuffling the data before splitting it into training and validation sets. [Keras will not shuffle before splitting](https://keras.io/getting-started/faq/#how-is-the-validation-split-computed), so we must shuffle the data ourselves. (Keras will however shuffle the training data at each epoch: [see here](https://keras.io/getting-started/faq/#is-the-data-shuffled-during-training).) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "permutation = np.random.permutation(len(observed_labels))\n",
    "\n",
    "encoded_sequences = encoded_sequences[permutation, :, :]\n",
    "observed_labels = observed_labels[permutation, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we hold out some data for testing later: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_set_size = min(1000, int(0.1*len(encoded_sequences)))\n",
    "\n",
    "encoded_sequences_test = encoded_sequences[:test_set_size, :, :]\n",
    "encoded_sequences = encoded_sequences[test_set_size:, :, :]\n",
    "\n",
    "observed_labels_test = observed_labels[:test_set_size, :]\n",
    "observed_labels = observed_labels[test_set_size:, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building a convolution neural network \n",
    "\n",
    "Next, we set up a convolution neural network to map sequence to labels: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv filter has dimension kernel_size X number_input_channels X number_output_channels\n",
      "shape of conv filter (18, 4, 1)\n",
      "\n",
      "model.inputs [<tf.Tensor 'conv1d_1_input:0' shape=(?, 30, 4) dtype=float32>]\n",
      "model.outputs [<tf.Tensor 'dense_1/Sigmoid:0' shape=(?, 1) dtype=float32>]\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv1d_1 (Conv1D)            (None, 13, 1)             72        \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 13, 1)             0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 13)                0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 1)                 14        \n",
      "=================================================================\n",
      "Total params: 86\n",
      "Trainable params: 86\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# https://github.com/keras-team/keras/issues/2102#issuecomment-233773649\n",
    "import keras.backend as K\n",
    "K.clear_session()\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Conv1D, Dense, Flatten, Dropout\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Conv1D(filters=1, \n",
    "                 kernel_size=motif.shape[1], \n",
    "                 input_shape=(sequence_length, 4), \n",
    "                 use_bias=False,\n",
    "                 padding='valid',\n",
    "                 activation='relu'))\n",
    "\n",
    "print('conv filter has dimension kernel_size X number_input_channels X number_output_channels')\n",
    "print('shape of conv filter', model.layers[0].get_weights()[0].shape)\n",
    "print('')\n",
    "\n",
    "# INVERTED DROPOUT\n",
    "# \"Dropout\" gets applied to the output of preceding layer (at training time only):\n",
    "# https://keras.io/layers/core/#dropout\n",
    "# weights are scaled by inverse of dropout rate (at training time only):\n",
    "# see: line 2277 of /anaconda2/envs/tensorflow3/lib/python3.5/site-packages/tensorflow/python/ops/nn_ops.py\n",
    "# also see: https://github.com/keras-team/keras/issues/3305#issuecomment-235359883\n",
    "# also see: https://www.coursera.org/lecture/deep-neural-network/dropout-regularization-eM33A\n",
    "model.add(Dropout(rate=0.5)) # including dropout moves the converged values of loss and accuracy into a \"reasonable\" range\n",
    "\n",
    "model.add(Flatten())\n",
    "model.add(Dense(units=1, activation='sigmoid'))\n",
    "\n",
    "model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['acc']) \n",
    "# \"acc\" is an alias for \"binary_accuracy\" when \"loss\" is \"binary_crossentropy\":\n",
    "# https://github.com/keras-team/keras/blob/351e7a992d8f948e373e321252a35824da77ac35/keras/engine/training.py#L383\n",
    "# https://github.com/keras-team/keras/blob/cd44c6e0aaff4bb52a060d778025b32dbde09b44/keras/metrics.py#L26 \n",
    "\n",
    "print('model.inputs', model.inputs)\n",
    "print('model.outputs', model.outputs)\n",
    "model.summary()\n",
    "\n",
    "# save model summary to disk\n",
    "from contextlib import redirect_stdout\n",
    "with open('model.summary.txt', 'w') as f:\n",
    "    with redirect_stdout(f):\n",
    "        model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training and evaluting the network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's train the network we have built: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.callbacks import ModelCheckpoint\n",
    "checkpoint = ModelCheckpoint(filepath=\"model.best.hdf5\", \n",
    "                             save_weights_only=False,\n",
    "                             monitor='val_acc', \n",
    "                             verbose=0,\n",
    "                             save_best_only=True,\n",
    "                             period=2)\n",
    "\n",
    "from keras.callbacks import TensorBoard\n",
    "tensorboard = TensorBoard(log_dir='./logs', \n",
    "                          histogram_freq=1, \n",
    "                          write_graph=False, \n",
    "                          write_grads=True, \n",
    "                          write_images=True) # visualize model weights as images\n",
    "\n",
    "history = model.fit(x=encoded_sequences, \n",
    "                    y=observed_labels, \n",
    "                    validation_split=0.2, \n",
    "                    epochs=int(200*(10000/number_training_examples)),\n",
    "                    verbose=0,\n",
    "                    callbacks=[checkpoint, tensorboard]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and monitor it's performance during the training process: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "def plot_history(histories, key='loss', ymin=None, ymax=None):\n",
    "    plt.figure(figsize=(10,5))    \n",
    "    for name, history in histories:\n",
    "        validation_plot = plt.plot(history.epoch, \n",
    "                                   history.history['val_' + key], \n",
    "                                   '--', \n",
    "                                   label=name + ' validation ' + key)\n",
    "        plt.plot(history.epoch, \n",
    "                 history.history[key], \n",
    "                 color=validation_plot[0].get_color(),\n",
    "                 label=name + ' train ' + key)\n",
    "        plt.xlabel('epochs')\n",
    "        plt.legend()\n",
    "        plt.xlim([0, max(history.epoch)])\n",
    "        if ymin is not None:\n",
    "            plt.ylim(bottom=ymin)\n",
    "        if ymax is not None:\n",
    "            plt.ylim(top=ymax)\n",
    "    \n",
    "plot_history([('conv1d', history)], key='loss', ymin=0, ymax=0.1)\n",
    "plot_history([('conv1d', history)], key='acc', ymin=0.95, ymax=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After convergence, the model performs very well! It's accuracy is far greater than 50%, which is the baseline accuracy associated with randomly predicting labels when the classes are \"balanced\" (the number of positive and negative examples are equal). \n",
    "\n",
    "Note: Training and validation losses (as computed above) may differ for the reasons below. These confounding factors may be controlled for by making predictions in exactly the same way for training, validation and test sets, e.g. using `model.predict` in Keras.\n",
    "\n",
    "* regularization (see [here](https://keras.io/getting-started/faq/#why-is-the-training-loss-much-higher-than-the-testing-loss) and [\"because [this] penalty is only added at training time, the loss for this network will be much higher at training than at test time\"](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit#add_weight_regularization)\n",
    ")\n",
    "* the time during training at which the loss is evaluated (see [here](https://keras.io/getting-started/faq/#why-is-the-training-loss-much-higher-than-the-testing-loss)) \n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The high performance indicated by the classification accuracy is confirmed by examining the confusion matrix (for a given threshold on the probability output of the network) and the ROC (which exhaustively varies that threshold): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix (threshold = 0.5):\n",
      " [[4502    0]\n",
      " [   0 4498]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "predicted_probabilities = model.predict(encoded_sequences)\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "threshold = 0.5\n",
    "cm = confusion_matrix(y_true=observed_labels, \n",
    "                      y_pred=predicted_probabilities>threshold)\n",
    "print('Confusion matrix (threshold = {}):\\n'.format(threshold), cm)\n",
    "\n",
    "from sklearn.metrics import roc_curve\n",
    "fpr, tpr, thresholds = roc_curve(observed_labels, predicted_probabilities)\n",
    "plt.plot(fpr, tpr, '.', ms=10)\n",
    "_ = plt.xlabel('false positive rate')\n",
    "_ = plt.ylabel('true positive rate')\n",
    "_ = plt.xlim([-0.01, 1.01])\n",
    "_ = plt.ylim([-0.01, 1.01])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interrogating the learned convolution filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does the network perform so well because the convolution filter it learns matches the motif that was injected into the positive examples? The simplest way to approach this question is to compare the matrices representing the original motif and the learned convolution filter: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(2, 1, 1)\n",
    "plt.imshow(motif)\n",
    "_ = plt.xticks(np.arange(0, 18, step=2))\n",
    "_ = plt.title('original motif')\n",
    "\n",
    "convolution_filter = model.layers[0].get_weights()[0].squeeze().transpose()\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.imshow(convolution_filter)\n",
    "_ = plt.xticks(np.arange(0, 18, step=2))\n",
    "_ = plt.title('convolution filter')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Are these matrices similar in any respect? Perhaps, but clearly this approach to interrogating the filter needs to be refined if we are to come away with some intuition about the origin of the high performance of the neural network.\n",
    "\n",
    "In particular, should we expect that, at each position (the x-axes in the images above), the value of the convolution filter is largest at the nucleotide (y-axis) at which the PWM of the motif is maximal in value? Or should we expect the opposite, namely that the filter is smallest where the motif is largest? The answer to this question depends upon how the network uses the convolution filter to make predictions, which we consider next. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two ways to achieve high performance \n",
    "\n",
    "Our network implements a sequence of functional transformations that convert the input sequence $s$ into a probability, $p$, that the sequence belongs to the positive class. This probability is computed as:\n",
    "\n",
    "\\begin{equation} \n",
    "p = \\sigma \\left( \\, \\Sigma_i a_i w_i + b \\, \\right) \n",
    "\\end{equation} \n",
    "\n",
    "where $\\sigma$ is the sigmoid activation function, $w_i$ and $b$ are trainable parameters and $a_i$ is the activation of the $i$th hidden neuron. That activation is in turn computed as \n",
    "\n",
    "\\begin{equation} \n",
    "a_i = r(\\, (s*f)_i \\, ) \n",
    "\\end{equation} \n",
    "\n",
    "where $r$ is the ReLU activation function, $s$ is the input sequence (one-hot-encoded), $f$ is the convolution filter, and `*` represents the convolution operation. \n",
    "\n",
    "With this notation in hand, we may depict schematically one possible way in which the network could correctly predict class labels (below, the positive class is labeled \"1\" and the negative class is labeled \"0\"): \n",
    "\n",
    "<table>\n",
    "    <caption>Schema #1</caption>\n",
    "    <tr>\n",
    "        <th>class</th> <th>s*f</th> <th>a</th> <th>w</th> <th>b</th> <th>p</th>     \n",
    "    </tr> \n",
    "    <tr> \n",
    "        <td>1</td> <td>-</td> <td>0</td> <td rowspan=\"2\">-</td> <td rowspan=\"2\">+</td> <td>1</td>\n",
    "    </tr> \n",
    "    <tr> \n",
    "        <td>0</td> <td>+</td> <td>+</td> <td>0</td>\n",
    "    </tr> \n",
    "</table> \n",
    "\n",
    "For example, if the input sequence is in the positive class, then this table conveys that convolving with the filter yields large negative numbers, which when passed through ReLU give zeroes, which when multiplied by negative weights $w$ and added to a positive bias $b$ yields a positive number, which gets mapped to a number $p$ close to one after passing through the sigmoid function. \n",
    "\n",
    "The alternate way to correctly predict classes is to reverse the sign of the convolution $s*f$ on positive and negative examples (and simultaneously reverse the signs of the weights and biases, $w$ and $b$):\n",
    "\n",
    "\n",
    "<table>\n",
    "    <caption>Schema #2</caption>\n",
    "    <tr>\n",
    "        <th>class</th> <th>s*f</th> <th>a</th> <th>w</th> <th>b</th> <th>p</th>     \n",
    "    </tr> \n",
    "    <tr> \n",
    "        <td>1</td> <td>+</td> <td>+</td> <td rowspan=\"2\">+</td> <td rowspan=\"2\">-</td> <td>1</td>\n",
    "    </tr> \n",
    "    <tr> \n",
    "        <td>0</td> <td>-</td> <td>0</td> <td>0</td>\n",
    "    </tr> \n",
    "</table>\n",
    "\n",
    "My experiments show that the training process always converges on a high-performance predictor that can be described using one of the two schema above (though the convolution filter that evolves varies). \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, here are the activations $a_i$ of the convolution layer and the weights $w_i$ that multiply them for a particular example and for the network we trained in this notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Schema #1 (see table above)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from keras.models import Model\n",
    "conv_layer_model = Model(inputs=model.input,\n",
    "                         outputs=model.layers[0].output)\n",
    "\n",
    "positive_example_index = next(index for index, label in enumerate(observed_labels_test.squeeze()) if label == 1)\n",
    "negative_example_index = next(index for index, label in enumerate(observed_labels_test.squeeze()) if label == 0)\n",
    "\n",
    "activations_positive_example = conv_layer_model.predict(np.array([encoded_sequences_test[positive_example_index]])).squeeze()\n",
    "activations_negative_example = conv_layer_model.predict(np.array([encoded_sequences_test[negative_example_index]])).squeeze()\n",
    "\n",
    "weights = model.layers[3].get_weights()[0].squeeze()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.plot(activations_positive_example, 's')\n",
    "plt.title('activations, $a_i$, for positive example')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.plot(activations_negative_example, 's')\n",
    "plt.title('activations, $a_i$, for negative example')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "_ = plt.plot(weights, 's')\n",
    "_ = plt.xlabel('neuron index, i, in conv layer')\n",
    "_ = plt.title('weights, $w_i$')\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "bias = float(model.layers[3].get_weights()[1])\n",
    "print('Schema #{} (see table above)'.format(1 if bias > 0 else 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A second pass at interrogating the convolution filter \n",
    "\n",
    "Now that we have classified the networks that evolve during training, we can return to the question of how to interrogate the convolution filter. \n",
    "\n",
    "In Schema #1, what drives the network to correctly predict the label of positive examples are negative values of the convolution filter (look at the second column of the table and remember that $s$ is one-hot-encoded and therefore always positive). This suggests that, when the network belongs to Schema #1, we should extract a \"consensus sequence\" from the convolution filter by picking out the nucleotides at each position that are **most negative.** \n",
    "\n",
    "In contrast, in Schema #2, correct predictions on positive examples result from positive values of the convolution filter (again see the second column of the corresponding table), implying that, when the network belongs to Schema #2,  the consensus sequence should be obtained by finding the nucleotides at each position at which the filter is **most positive.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "motif consensus sequence: GGAAGGAAGGAAGGAAGG\n",
      "convolution filter consensus sequence: AAGGAGGGAAGGAGGAAG\n"
     ]
    }
   ],
   "source": [
    "def consensus_sequence(matrix, model=None): \n",
    "    nucleotides = ['A','C','G','T']\n",
    "    if model: \n",
    "        # use bias to determine which schema the network belongs to:\n",
    "        bias = float(model.layers[3].get_weights()[1]) \n",
    "        arg = np.argmin if bias > 0.0 else np.argmax\n",
    "    else: \n",
    "        arg = np.argmax\n",
    "    return ''.join([nucleotides[arg(matrix[:, position])] \n",
    "                    for position in range(matrix.shape[1])])\n",
    "\n",
    "consensus_sequence_motif = consensus_sequence(motif)\n",
    "consensus_sequence_filter = consensus_sequence(convolution_filter, model=model)\n",
    "\n",
    "print('motif consensus sequence:', consensus_sequence_motif)\n",
    "print('convolution filter consensus sequence:', consensus_sequence_filter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are getting somewhere! Clearly the consensus sequence of the filter is similar to that of the original motif. In particular, the filter sequence is closer to the motif sequence than any random sequence is: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alignment score of filter sequence to motif sequence: 13.0\n",
      "\n",
      "alignments of filter sequence to motif sequence:\n",
      "\n",
      "--AAGGAGGGAAGGAGGAAG\n",
      "--|||||X|||||||X|X--\n",
      "GGAAGGAAGGAAGGAAGG--\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEKCAYAAAAFJbKyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAH2xJREFUeJzt3Xu0HFWZ/vHvk4AQAYGYwMRAPKDxAg5GzCAKYgS5CCoqKjgKAdE4CgRFl0ZxJD9YzIqDouIFDRKJiCCCQAQEInIZZIAQjCEBY/KDCJEMAYGAMgaSvPPH3k2KQ3ef6qTrdJ+c57NWr1O1u7rqre46/XbtXbW3IgIzM7OyhnQ6ADMzG1icOMzMrCVOHGZm1hInDjMza4kTh5mZtcSJw8zMWuLEYWZmLXHiMDOzljhxmJlZSzbpdABVGDFiRPT09HQ6DDOzAWXu3LmPRsTIvpbbKBNHT08Pd955Z6fDMDMbUCT9ucxyrqoyM7OWOHGYmVlLnDjMzKwlThxmZtYSJw4zM2uJE4eZmbXEicPMzFrixGFmZi1x4jAzs5ZslHeO2+DTM+WquuVLpx3Sz5GYbfx8xmFmZi1x4jAzs5Y4cZiZWUucOMzMrCVOHGZm1hInDjMza4kTh5mZtcSJw8zMWuLEYWZmLXHiMDOzllSWOCTtKOkGSfdKWijpxFw+VdJfJM3Lj4MLr/mSpCWSFkk6sFB+UC5bImlKVTGbmVnfquyrajXwuYi4S9JWwFxJs/Nz34yIrxcXlrQLcASwK/Ay4DeSXpWf/h6wP7AMmCNpVkTcU2HsZmbWQGWJIyKWA8vz9FOS7gVGN3nJocBFEbEKuF/SEmCP/NySiLgPQNJFeVknDjOzDuiXNg5JPcAbgNtz0fGS5kuaIWnbXDYaeLDwsmW5rFG5mZl1QOWJQ9KWwKXAZyLiSeBs4BXAONIZyTdqi9Z5eTQp772dSZLulHTnI4880pbYzczshSpNHJI2JSWNCyLilwAR8XBErImItcA5rKuOWgbsWHj5DsBDTcqfJyKmR8T4iBg/cuTI9u+MmZkB1V5VJeBc4N6IOLNQPqqw2PuABXl6FnCEpM0k7QSMBe4A5gBjJe0k6UWkBvRZVcVtZmbNVXlV1V7AkcDdkublsi8DH5Y0jlTdtBT4JEBELJR0ManRezVwXESsAZB0PHAtMBSYERELK4zbzMyaqPKqqluo3z5xdZPXnA6cXqf86mavMzOz/uM7x83MrCVOHGZm1hInDjMza4kTh5mZtaTPxCHpFZI2y9MTJE2WtE31oZmZWTcqc8ZxKbBG0itJ92XsBPys0qjMzKxrlUkcayNiNelmvW9FxGeBUX28xszMNlJlEsezkj4MTASuzGWbVheSmZl1szKJ4xjgzcDpEXF/7g7kp9WGZWZm3arPO8cj4h5JXwTG5Pn7gWlVB2ZmZt2pzFVV7wbmAdfk+XGS3MmgmdkgVaaqaiqp6/MnACJiHunKKjMzG4TKdHK4OiJWpl7Sn/OCgZTMAHqmXFW3fOm0Q/o5EjOrSpnEsUDSvwJDJY0FJgO3VhuWmZl1qzJVVScAuwKrSDf+rQQ+U2VQZmbWvcpcVfU0cHJ+mJnZIFfmqqrZxb6pJG0r6dpqwzIzs25VpqpqREQ8UZuJiMeB7aoLyczMulmpvqokjanNSHo5vqrKzGzQKnNV1cnALZJuyvP7AJOqC8nMzLpZmcbxayTtDuwJCPhsRDxaeWRmZtaVypxxAGwGPJaX30USEXFzdWGZmVm36jNxSPoacDiwEFibiwNw4jAzG4TKnHG8F3h1RKyqOhgzM+t+Za6qug8P3GRmZlmZM46ngXmSrid1OwJAREyuLCozM+taZRLHrPwwMzMrdTnuTEnDgDERsagfYjIzsy7mEQDNzKwlHgHQzMxaUiZxrI6Ilb3K+uyrStKOkm6QdK+khZJOzOXDc4+7i/PfbXO5JJ0laYmk+flu9dq6JublF0ua2MoOmplZe5VJHM8bAVDSdyg3AuBq4HMR8VpSdyXHSdoFmAJcHxFjgevzPMA7gbH5MQk4G1KiAU4B3kQ68zmllmzMzKz/tToC4IXAk5QYATAilkfEXXn6KeBeYDRwKDAzLzaTdIMhufwnkdwGbCNpFHAgMDsiHstdus8GDiq5f2Zm1mb9MgKgpB7gDcDtwPYRsTyve7mk2tgeo4EHCy9blssalffexiRyr71jxozp/bSZmbVJmb6qbqBOm0ZE7FtmA5K2BC4FPhMRT0pquGidsmhS3jue6cB0gPHjx3u8EDOzipS5AfDzhenNgcNI7Rd9krQpKWlcEBG/zMUPSxqVzzZGASty+TJgx8LLdwAeyuUTepXfWGb7ZmbWfn22cUTE3MLjdxFxEqmhuimlU4tzgXsj4szCU7OA2pVRE4ErCuVH5aur9gRW5iqta4ED8ljn2wIH5DIzM+uAMlVVwwuzQ4A3Av9UYt17AUcCd0ual8u+DEwDLpZ0LPAA8MH83NXAwcASUv9YxwBExGOSTgPm5OVOjYjHSmzfrK16plxVt3zptEP6ORKzzipTVTWXdW0Nq4H7gWP7elFE3EL99gmA/eosH8BxDdY1A5hRIlYzM6tYmauqfJe4mZk9p0xV1fubPV9o9DYzs0GgTFXVscBbgN/m+beTrmpaSarCcuIwMxtEyiSOAHap3bSXL6H9XkQcU2lkZmbWlcp0OdJTSxrZw8CrKorHzMy6XJkzjhslXUvqpyqAI4AbKo3KzMy6Vpmrqo6X9D5gn1w0PSIuqzYsMzPrVmXOOADuAp6KiN9IerGkrXKPt2ZmNsiUGTr2E8AlwA9z0Wjg8iqDMjOz7lWmcfw4UvchTwJExGJgu6avMDOzjVaZxLEqIp6pzUjahBJDx5qZ2capTOK4SdKXgWGS9gd+Afyq2rDMzKxblUkcU4BHgLuBT5J6sf1KlUGZmVn3KnM57lrgHOCc3MX6DrknWzMzG4TKXFV1o6SX5KQxD/ixpDP7ep2ZmW2cylRVbR0RTwLvB34cEW8E3lFtWGZm1q3KJI5NcseGHwKurDgeMzPrcmUSx6mkMb6XRMQcSTsDi6sNy8zMulWZxvFfkC7Brc3fBxxWZVBmZta9ypxxmJmZPceJw8zMWuLEYWZmLemzjUPSNsBRQE9x+YiYXF1YZmbWrcqMx3E1cBupy5G11YZjZmbdrkzi2DwiTqo8EjMzGxDKtHGcL+kTkkZJGl57VB6ZmZl1pTJnHM8AZwAns24cjgB2riooMzPrXmUSx0nAKyPi0aqDMTOz7lemqmoh8HTVgZiZ2cBQJnGsAeZJ+qGks2qPvl4kaYakFZIWFMqmSvqLpHn5cXDhuS9JWiJpkaQDC+UH5bIlkqa0uoNmZtZeZaqqLs+PVp0HfBf4Sa/yb0bE14sFknYBjgB2BV4G/EbSq/LT3wP2B5YBcyTNioh71iMeMzNrgzKdHM6U9CKg9kW+KCKeLfG6myX1lIzjUOCiiFgF3C9pCbBHfm5J7lgRSRflZZ04zMw6pMwIgBNI3ah/D/g+8CdJ+2zANo+XND9XZW2by0YDDxaWWZbLGpWbmVmHlGnj+AZwQES8LSL2AQ4Evrme2zsbeAUwDlie1w2gOstGk/IXkDRJ0p2S7nzkkUfWMzwzM+tLmcSxaUQsqs1ExJ+ATddnYxHxcESsiYi1wDmsq45aBuxYWHQH4KEm5fXWPT0ixkfE+JEjR65PeGZmVkKZxHGnpHMlTciPc4C567OxPARtzfuA2hVXs4AjJG0maSdgLHAHMAcYK2mn3M5yRF7WzMw6pMxVVZ8CjgMmk6qObia1dTQl6UJgAjBC0jLgFGCCpHGk6qalwCcBImKhpItJjd6rgeMiYk1ez/GkoWuHAjMiYmEL+2dmZm1W5qqqVcCZ+VFaRHy4TvG5TZY/HTi9TvnVpB56zcysCzRMHJLupkFDNEBE7FZJRGZm1tWanXG8K/89Lv89P//9CO6CxMxs0GqYOCLizwCS9oqIvQpPTZH0O+DUqoMzM7PuU+aqqi0k7V2bkfQWYIvqQjIzs25W5qqqY4EZkrbO808AH6suJDMz62ZlrqqaC7xe0ksARcTK6sMyM7Nu1WfikLQZcBjQA2wipV5AIsJtHGZmg1CZqqorgJWku8VXVRuOmZl1uzKJY4eIOKjySMzMbEAoc1XVrZL+ufJIzMxsQChzxrE3cLSk+0lVVQLCd46bmQ1OZRLHOyuPwszMBowyl+PW7iDfDti88ojMzKyrlRk69j2SFgP3AzeRukP/dcVxmZlZlyrTOH4asCfwp4jYCdgP+F2lUZmZWdcqkziejYi/AkMkDYmIG0hjhpuZ2SBUpnH8CUlbkkb+u0DSCtIofWZmNgiVOeM4lDT+xmeBa4D/D7y7yqDMzKx7NT3jkDQUuCIi3gGsBWb2S1RWiZ4pVzV8bum0Q/oxEjMbyJqecUTEGuDpQpfqZmY2yJVp4/gHcLek2cDfa4URMbmyqMzMrGuVSRxX5YeZmVmpO8fdrmFmZs8pc1WVmZnZc5w4zMysJQ0Th6Tz898T+y8cMzPrds3OON4o6eXAxyRtK2l48dFfAZqZWXdp1jj+A9Kd4juTxhtX4bnI5WZmNsg0POOIiLMi4rXAjIjYOSJ2KjycNMzMBqk+G8cj4lOSXi/p+PwoNWSspBmSVkhaUCgbLmm2pMX577a5XJLOkrRE0nxJuxdeMzEvv1jSxPXZSTMza58yAzlNBi4AtsuPCySdUGLd5wEH9SqbAlwfEWOB6/M8pOFpx+bHJODsvO3hwCnAm4A9gFNqycbMzDqjzOW4HwfeFBFfjYivkgZ1+kRfL4qIm4HHehUfyrqOEmcC7y2U/ySS24BtJI0CDgRmR8RjEfE4MJsXJiMzM+tHZbocEbCmML+G5zeUt2L7iFgOEBHL8zjmAKOBBwvLLctljcrNBo1GvRq7R2PrlDKJ48fA7ZIuy/PvBc5tcxz1ElE0KX/hCqRJpGouxowZ077IzMzseco0jp8JHEOqdnocOCYivrWe23s4V0GR/67I5cuAHQvL7QA81KS8XpzTI2J8RIwfOXLkeoZnZmZ9KdXlSETclS/P/XZE/H4DtjcLqF0ZNRG4olB+VL66ak9gZa7SuhY4IN+AuC1wQC4zM7MOKVNVtV4kXQhMAEZIWka6OmoacLGkY4EHgA/mxa8GDgaWkIapPQYgIh6TdBowJy93akT0bnA3M7N+VFniiIgPN3hqvzrLBnBcg/XMAGa0MTQzM9sATauqJA2V9Jv+CsbMzLqfxxw3M7OWeMxxMzNricccNzOzlpQac1zSMGBMRCzqh5jMzKyLlenk8N3APNLYHEgaJ2lW1YGZmVl3KnMD4FRSz7RPAETEPGCnCmMyM7MuViZxrI6Ilb3K6vYXZWZmG78yjeMLJP0rMFTSWGAycGu1YZmZWbcqc8ZxArArsAq4EHgS+EyVQZmZWfcqc1XV08DJkr6WZuOp6sMyM7NuVeaqqn+RdDcwn3Qj4B8kvbH60MzMrBuVaeM4F/h0RPwXgKS9SYM77VZlYGZm1p3KtHE8VUsaABFxC+DqKjOzQarhGYek3fPkHZJ+SGoYD+Bw4MbqQzMzs27UrKrqG73mTylM+z4OM7NBqmHiiIi392cgZmY2MPTZOC5pG+AooKe4vLtVNzMbnMpcVXU1cBtwN7C22nDMzKzblUkcm0fESZVHYmZmA0KZy3HPl/QJSaMkDa89Ko/MzMy6UpkzjmeAM4CTWXc1VQA7VxWUmZl1rzKJ4yTglRHxaNXBmJlZ9ytTVbUQeLrqQMzMbGAoc8axBpgn6QZS1+qAL8c1MxusyiSOy/PDzMys1HgcM/sjEDMzGxjK3Dl+P3X6pooIX1VlZjYIlamqGl+Y3hz4IOD7OMzMBqk+r6qKiL8WHn+JiG8B+/ZDbGZm1oXKVFXtXpgdQjoD2WpDNippKWkwqDXA6ogYn+9G/zmpM8WlwIci4nFJAr4NHEy6LPjoiLhrQ7ZvZmbrr0xVVXFcjtXkL/U2bPvtvW4qnAJcHxHTJE3J818E3gmMzY83AWfnv2Zm1gFlrqrqr3E5DgUm5OmZpFEGv5jLfxIRAdwmaRtJoyJieT/FZWZmBWWqqjYDDuOF43GcugHbDeA6SQH8MCKmA9vXkkFELJe0XV52NPBg4bXLctnzEoekScAkgDFjxmxAaGZm1kyZqqorgJXAXAp3jm+gvSLioZwcZkv6Y5NlVaes3uXB04HpAOPHj/fQtmZmFSmTOHaIiIPaudGIeCj/XSHpMmAP4OFaFZSkUcCKvPgyYMdiPMBD7YzHzMzKK9PJ4a2S/rldG5S0haStatPAAcACYBYwMS82kXSmQy4/SsmewEq3b5iZdU6ZM469gaPzHeSrSFVHERG7rec2twcuS1fZsgnws4i4RtIc4GJJxwIPkG40hDR07cHAEtLluMes53bNzKwNyiSOd7ZzgxFxH/D6OuV/BfarUx7Ace2MwczM1l+Zy3H/3B+BmJnZwFCmjcPMzOw5ThxmZtaSMm0cZrYR65lyVd3ypdMO6edIbKDwGYeZmbXEicPMzFrixGFmZi1x4jAzs5Y4cZiZWUucOMzMrCVOHGZm1hLfx9EBvm7ezAYyn3GYmVlLnDjMzKwlThxmZtYSJw4zM2uJE4eZmbXEicPMzFrixGFmZi1x4jAzs5Y4cZiZWUucOMzMrCVOHGZm1hInDjMza4k7OTSzjnGHnwOTzzjMzKwlThxmZtYSJw4zM2uJE4eZmbVkwCQOSQdJWiRpiaQpnY7HzGywGhBXVUkaCnwP2B9YBsyRNCsi7qlie77Sw2zj4P/lagyUM449gCURcV9EPANcBBza4ZjMzAalAXHGAYwGHizMLwPe1KFYzMz6tDGf7SgiOh1DnyR9EDgwIj6e548E9oiIEwrLTAIm5dlXA4s2YJMjgEc34PXdzPs2cG3M++d96w4vj4iRfS00UM44lgE7FuZ3AB4qLhAR04Hp7diYpDsjYnw71tVtvG8D18a8f963gWWgtHHMAcZK2knSi4AjgFkdjsnMbFAaEGccEbFa0vHAtcBQYEZELOxwWGZmg9KASBwAEXE1cHU/ba4tVV5dyvs2cG3M++d9G0AGROO4mZl1j4HSxmFmZl3CiSOTtKOkGyTdK2mhpBM7HVO7SRoq6feSrux0LO0maRtJl0j6Y/4M39zpmNpF0mfzMblA0oWSNu90TBtC0gxJKyQtKJQNlzRb0uL8d9tOxri+GuzbGfm4nC/pMknbdDLGdnDiWGc18LmIeC2wJ3CcpF06HFO7nQjc2+kgKvJt4JqIeA3wejaS/ZQ0GpgMjI+I15EuDjmis1FtsPOAg3qVTQGuj4ixwPV5fiA6jxfu22zgdRGxG/An4Ev9HVS7OXFkEbE8Iu7K00+RvnhGdzaq9pG0A3AI8KNOx9Jukl4C7AOcCxARz0TEE52Nqq02AYZJ2gR4Mb3uYRpoIuJm4LFexYcCM/P0TOC9/RpUm9Tbt4i4LiJW59nbSPehDWhOHHVI6gHeANze2Uja6lvAF4C1nQ6kAjsDjwA/zlVxP5K0RaeDaoeI+AvwdeABYDmwMiKu62xUldg+IpZD+hEHbNfheKryMeDXnQ5iQzlx9CJpS+BS4DMR8WSn42kHSe8CVkTE3E7HUpFNgN2BsyPiDcDfGbhVHc+T6/oPBXYCXgZsIemjnY3K1oekk0lV4hd0OpYN5cRRIGlTUtK4ICJ+2el42mgv4D2SlpJ6Ft5X0k87G1JbLQOWRUTtDPESUiLZGLwDuD8iHomIZ4FfAm/pcExVeFjSKID8d0WH42krSROBdwEfiY3gHggnjkySSHXk90bEmZ2Op50i4ksRsUNE9JAaVn8bERvNr9aI+B/gQUmvzkX7AZWM1dIBDwB7SnpxPkb3YyNp+O9lFjAxT08EruhgLG0l6SDgi8B7IuLpTsfTDk4c6+wFHEn6NT4vPw7udFBW2gnABZLmA+OA/+hwPG2Rz6IuAe4C7ib9zw7oO5ElXQj8N/BqScskHQtMA/aXtJg0YNu0Tsa4vhrs23eBrYDZ+XvlBx0Nsg1857iZmbXEZxxmZtYSJw4zM2uJE4eZmbXEicPMzFrixGFmZi1x4qiYpKWSRuTpWzsdT2+Sxg2ky45zT6MLJZ1R8XYmbIy9CLdTJ44dSUdLellh/ke1zkglfTD3jHxDf8Y0GA2YEQA3BhHRjXf8jgPG0w+jK0rapNDZ2/r6JDAyIlZVvB3rW78dOwVHAwvIHT1GxMcLzx0LfDoinDiqFhF+tOEBXA7MBRYCkwrlS4ERefpv+e8Q4Pt52StJ/3gfKCz//1h3w9drcvlUUq+h1+Vl3g/8Z17mGmDTvNwbgZtyLNcCo3L5jcDXgDtIXTu/FXgR6c7kR4B5wOG99mnXvPw8YD4wNpcflef/AJyfy15O6g57fv47JpefB5wJ3AB8A9gCmAHMAX4PHFrnvRRwBukL4u5aXKS7i9c0iHUq6ca464CfAT3Af+X38S7gLXm5Cfm9uAT4I6nfoNr9TAflsluAs4Arc/nw/PnOJ/Vuulsrn0mvOCeT7mqfD1yUy+q+J8AwUhcx84GfkzrdHF88lvL0B4Dz8vRIUrc5c/Jjr0KsM/K+3wdMLry+3udZdz2F17zg2Gn0PvV63dF5mV8B9wPHAyfl/b4NGJ6XG5fn5wOXAdvm/fwbsChvc1jen/HAVwvPndFrm6OAm/NrFgBvzeUHkG7Wuwv4BbBlH8fBVODzhfUuAHry9EdZ97/yQ2Bo7XMCTs/v7W2kzhwBts/79Yf8eEuz9XTbo+MBbCyPwgE/LB9QL83zS3lh4vgAKVkMAf4JeJznJ44T8vSngR/l6an5QN6UNN7E08A783OXkbqh3hS4lfSLnPzPPCNP3wh8I08fDPwmTx8NfLfBPn2H1LcOpC+KYaRksqiwT7X9/hUwMU9/DLg8T59HSo61f6T/AD6ap7chJbEtem33MNIYBkPzP9gDrEuAf2sQ61RSshyW518MbJ6nxwJ35ukJwEpS19ZDSF8cewObAw/mZQVczLovjO8Ap+TpfYF5ZT+TOnE+BGxW2/9m7wnpC7X2+e1G6iCvr8TxM2DvPD2G1IVOLdZbgc2AEcBfc9yNPs+66+m1L0dTOHYavU91XrOEdCf1yPxZ/Ft+7pukzkUhJYy35elTgW8VjuPxhfU9N9/7ucIynwNOztND87ZHkJLJFrn8i6Tk0+w4mEqdxAG8lnT81368fR84Kk8H8O48/Z/AV/L0zwv7OhTYutl6uu3hqqr2mSzpfXl6R9KB99cGy+4N/CIi1gL/U6dOttbB4lzSr9iaX0fEs5LuJh1s1+Tyu0kH8KuB15G6NiAvs7zBentK7NN/AyfnsTx+GRGLJe0LXBIRjwJERG3sgTcXYj2f9E9S84uIWJOnDyB1uPj5PL85+YupsPzewIX5NQ9Lugn4F9IZRzOzIuJ/8/SmwHcljSOdpbyqsNwdEbEMQNI80nvxN1Jngotz+U+BSYV4Dsv7+1tJL5W0dX6ur8+kt/mkrlEuJ/3ybvae7EP6xUtEzM/dqfTlHcAu+fMHeImkrfL0VZGq+FZJWkFKyo0+z7rriTRWTSN136eIWNlruRvyep6StJL0ZQnpPdstv7fbRMRNuXwm6Yxgfc0BZuROTC+PiHmS3gbsAvwu7+OLSMf7a2h8HDSyH+lMf05e1zDWddL4DOmHE6T/u/3z9L6kMz3ycb5S0pFN1tNVnDjaQNIE0j/amyPiaUk3kv75G76kj1XW6u/X8PzPaBVARKyV9GzknyWkMTY2yetdGBGNhk1ttN66IuJnkm4nDQB1raSP522U6aemuMzfC9MCDouIRU1e29f700hxO58FHiadCQwB/lF4rtg+UnwvGu1XvXhqy/b1mfR2CCkhvAf4d0m70uA9yV8ejWIqlhePtSGk4/B/iwvnddXb70afZ9319KHZ+1RUjGNtYb7Re7ZBIuJmSfuQ3vvz84UVjwOzI+LDxWXzD41G7/lqnn9BUe19FzAzIuqN7Fc8Jvr6v2u2nq7iq6raY2vg8Zw0XkMaeraZW4DDJA2RtD2p+qQdFgEjlcfblrRp/mJq5inSqfsLSNoZuC8iziL92t+N1H7xIUkvzcsMz4vfyrohTT9C2sd6rgVOyD29IukNdZa5GThcaYz0kaQv2jv62I/etgaW57O6I0lnA838EdhJ0ivyfPEL5WbSPtV+JDwa6zFWi6QhwI6RGm+/QKqW2pLG70lxu68jvf81D0t6bV7n+wrl15HaDWrbHNdHWI0+zzLr6X3stOV9ymcoj0t6ay46ktRuV2+bfZL0ctJ4NOeQesDendTesJekV+ZlXizpVTQ/Dpbm1yJpd9IYKZDeww9I2i4/Nzxvs5nrgU/l5YcqjWK5PuvpCCeO9rgG2CRXJZxGOiibuZQ0hsQCUgPY7aS63g0SEc+Q6ru/JukPpAa2vq7kuoFUJTFP0uG9njscWJCrc14D/CQiFpIa+27K26h1QT8ZOCa/B0eSxjev5zRSNdJ8SQvyfG+Xsa6x9rfAFyJ1nd6K7wMTJd1Gqqb6e7OFI+IfpCqJqyTdAvy58PRUYHzet2ms6/67VUOBn+Zqrd8D34w0xG2j9+RsYMu83S/w/OQ5hVQF8lueXx05uRarpHuAf2sWUB+fZ1/r6X3sTKU97xP5tWdoXW/Hp+by84Af5G0OK7muCcA8Sb8nVaV9OyIeIbW3XJi3cRvpQpRmx8GlwPD8//ApUlsUEXEP8BXguryu2aQG+WZOBN6ej4W5wK7ruZ6OcO+4HSJpy4j4W/6ldwfpqpVWvxxtEMlVoJ+PiDs7Hctgkc+cPh8R7+p0LN3EbRydc6WkbUiNcqc5aZjZQOEzDjMza4nbOMzMrCVOHGZm1hInDjMza4kTh5mZtcSJw8zMWuLEYWZmLfk//9Ahiz8Q0ToAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from Bio import Align\n",
    "internal_gap_score = -100 \n",
    "\n",
    "def generate_random_alignment_scores(): \n",
    "    random_alignment_scores = []\n",
    "    for i in range(10000):\n",
    "        random_sequence = ''.join(np.random.choice(['A', 'C', 'G', 'T'], \n",
    "                                                  size=motif.shape[1], \n",
    "                                                  p=np.array([1,1,1,1])/4.0))\n",
    "        aligner = Align.PairwiseAligner()\n",
    "        aligner.internal_gap_score = internal_gap_score\n",
    "        random_alignment_scores.append(\n",
    "            aligner.align(random_sequence, consensus_sequence_motif).score)\n",
    "    return random_alignment_scores\n",
    "\n",
    "plt.hist(generate_random_alignment_scores(), bins=50)\n",
    "plt.xlabel('alignment score of random sequence to motif sequence')\n",
    "plt.ylabel('number of random sequences')\n",
    "\n",
    "aligner = Align.PairwiseAligner()\n",
    "aligner.internal_gap_score = internal_gap_score\n",
    "alignments = aligner.align(consensus_sequence_filter, consensus_sequence_motif)\n",
    "print('alignment score of filter sequence to motif sequence:', alignments.score)\n",
    "print()\n",
    "print('alignments of filter sequence to motif sequence:')\n",
    "print()\n",
    "for alignment in alignments: \n",
    "    print(alignment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning part of a motif can be  sufficient for high performance\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is commonly thought that the filters in the first convolution layer of a neural network always learn Position Weight Matrices of sequence motifs. What we have found is that though a convolution filter can be similar to the motif it is designed to discover, it is often not identical to it (look again at the alignments shown above). Why? \n",
    "\n",
    "Learning just part of the motif is sufficient for high performance because the motif is long. Thus, even part of it is long enough to be unlikely to appear by chance in a negative example. And that is all that is required: to discriminate positive and negative examples, the model only needs to learn sequences that are unique to the positive examples. Once it has learned the shortest such discriminating sequence, it's performance is maximal and so it is no longer incentivized to learn longer discriminating sequences! \n",
    "\n",
    "This observation has important implications for designing and optimizing convolution neural networks in genomics: convolution filters in early layers  don't necessarily need to be as long as the motifs they are trying to detect, but do need to be long enough that the corresponding sequences are unlikely to occur by chance in examples lacking the motif. A similar conclusion was reached by [Koo and Eddy](https://www.biorxiv.org/content/early/2018/07/08/362756).\n",
    "\n",
    "Another corollary is that the shorter the original motif is, the more frequently it will occur in negative examples, and thus the more closely the convolution filter must match the motif in order to discriminate between positive and negative examples. \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other things to explore \n",
    "\n",
    "Visually examine the examples that are mis-classified by the convnet. Do the few negative examples that are mis-classified as positive by the convnet contain the motif, or large parts of it? \n",
    "\n",
    "Can one achieve similar performance with shorter filters provided one adds conv layers that combine those filters into a complete motif? \n",
    "\n",
    "Implement other approaches to learning sequence motifs: \n",
    "\n",
    "* example-based approaches: [Shrikumar, Greenside & Kundaje](https://github.com/kundajelab/deeplift) ([this approach seems to work well when there are multiple convolutional layers](https://docs.google.com/presentation/d/14_Rz9ihNHcxAzOA0Owir28Qktbad_U9wplKoNLasFu4/edit#slide=id.g218d5865fd_0_626)); [Deep Learning in Genomics Primer](https://github.com/abidlabs/deep-learning-genomics-primer/blob/master/A_Primer_on_Deep_Learning_in_Genomics_Public.ipynb)\n",
    "* refinements of the filter-based approach: [Ploenzke and Irizarry](https://www.biorxiv.org/content/biorxiv/early/2018/09/08/411934.full.pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "270px",
    "width": "343px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}