diff --git a/intro_data_processing_numpy_neural_networks.ipynb b/intro_data_processing_numpy_neural_networks.ipynb new file mode 100644 index 0000000..d63d742 --- /dev/null +++ b/intro_data_processing_numpy_neural_networks.ipynb @@ -0,0 +1,1037 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction to NumPy and CNNs with ENCODE data\n", + "\n", + "In this tutorial, we will download ENCODE data file, examine it's contents, and do a quick sanity check with NumPy and plotting library. This is normally the initial step before starting to preprocess the data. This notebook can be run on an instance of [AWS Deep Learning AMI](https://docs.aws.amazon.com/dlami/latest/devguide/what-is-dlami.html)\n", + "\n", + "For this, we will pick experiment [ENCSR057BWO](https://www.encodeproject.org/experiments/ENCSR057BWO/). It's a ChIP-seq on H3K4me3 from GM12878 cell line. We know from PREDICTD paper that H3K4me3 was the most informative of all histone modifications. The file we are interested in is ENCFF565YYD, a bigWig of signal p-value. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use [pyBigWig](https://github.com/deeptools/pyBigWig) python module that's specifically designed to work with bigWigs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pyBigWig\n", + "from sklearn.model_selection import train_test_split\n", + "import numpy as np\n", + "import h5py\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "from keras.layers import Conv1D, Dense, MaxPooling1D, Flatten, Dropout\n", + "from keras.models import Sequential\n", + "from keras import backend as K\n", + "from keras.layers.normalization import BatchNormalization\n", + "import tensorflow as tf\n", + "import os\n", + "import random\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = random.choice(['0','1'])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'chrUn_KI270748v1': 93321,\n", + " 'chrUn_KI270337v1': 1121,\n", + " 'chrUn_KI270749v1': 158759,\n", + " 'chr1_KI270713v1_random': 40745,\n", + " 'chrUn_KI270418v1': 2145,\n", + " 'chr13': 114364328,\n", + " 'chr12': 133275309,\n", + " 'chr11': 135086622,\n", + " 'chr10': 133797422,\n", + " 'chr17': 83257441,\n", + " 'chr16': 90338345,\n", + " 'chr15': 101991189,\n", + " 'chr14': 107043718,\n", + " 'chrUn_GL000218v1': 161147,\n", + " 'chr19': 58617616,\n", + " 'chr18': 80373285,\n", + " 'chrUn_KI270320v1': 4416,\n", + " 'chrUn_GL000219v1': 179198,\n", + " 'chrUn_KI270518v1': 2186,\n", + " 'chr3_GL000221v1_random': 155397,\n", + " 'chrUn_GL000213v1': 164239,\n", + " 'chrUn_KI270746v1': 66486,\n", + " 'chrUn_KI270516v1': 1300,\n", + " 'chr16_KI270728v1_random': 1872759,\n", + " 'chrUn_KI270521v1': 7642,\n", + " 'chrUn_GL000214v1': 137718,\n", + " 'chr9_KI270720v1_random': 39050,\n", + " 'chrUn_KI270593v1': 3041,\n", + " 'chrUn_KI270538v1': 91309,\n", + " 'chr22_KI270731v1_random': 150754,\n", + " 'chr1_KI270707v1_random': 32032,\n", + " 'chrUn_KI270322v1': 21476,\n", + " 'chrUn_KI270579v1': 31033,\n", + " 'chr1_KI270708v1_random': 127682,\n", + " 'chrUn_KI270378v1': 1048,\n", + " 'chrEBV': 171823,\n", + " 'chr15_KI270727v1_random': 448248,\n", + " 'chrUn_KI270333v1': 2699,\n", + " 'chrUn_KI270435v1': 92983,\n", + " 'chrUn_KI270741v1': 157432,\n", + " 'chrUn_KI270302v1': 2274,\n", + " 'chrUn_KI270743v1': 210658,\n", + " 'chrUn_KI270744v1': 168472,\n", + " 'chrUn_KI270745v1': 41891,\n", + " 'chr22_KI270732v1_random': 41543,\n", + " 'chrUn_GL000216v2': 176608,\n", + " 'chrUn_GL000195v1': 182896,\n", + " 'chrUn_KI270742v1': 186739,\n", + " 'chr14_GL000194v1_random': 191469,\n", + " 'chrUn_KI270590v1': 4685,\n", + " 'chrUn_KI270751v1': 150742,\n", + " 'chrUn_KI270750v1': 148850,\n", + " 'chr9_KI270719v1_random': 176845,\n", + " 'chrUn_KI270311v1': 12399,\n", + " 'chr22_KI270737v1_random': 103838,\n", + " 'chrUn_KI270362v1': 3530,\n", + " 'chrUn_KI270363v1': 1803,\n", + " 'chrUn_KI270508v1': 1951,\n", + " 'chr17_GL000205v2_random': 185591,\n", + " 'chrUn_KI270509v1': 2318,\n", + " 'chrUn_KI270512v1': 22689,\n", + " 'chr4_GL000008v2_random': 209709,\n", + " 'chrUn_KI270753v1': 62944,\n", + " 'chr17_KI270730v1_random': 112551,\n", + " 'chrUn_KI270755v1': 36723,\n", + " 'chr22_KI270734v1_random': 165050,\n", + " 'chr22_KI270736v1_random': 181920,\n", + " 'chrUn_KI270417v1': 2043,\n", + " 'chr1_KI270711v1_random': 42210,\n", + " 'chr14_KI270726v1_random': 43739,\n", + " 'chrUn_KI270420v1': 2321,\n", + " 'chr11_KI270721v1_random': 100316,\n", + " 'chrUn_KI270424v1': 2140,\n", + " 'chrUn_KI270588v1': 6158,\n", + " 'chr22_KI270739v1_random': 73985,\n", + " 'chr14_KI270723v1_random': 38115,\n", + " 'chrUn_KI270522v1': 5674,\n", + " 'chrUn_KI270754v1': 40191,\n", + " 'chr14_GL000009v2_random': 201709,\n", + " 'chr14_KI270724v1_random': 39555,\n", + " 'chrUn_KI270517v1': 3253,\n", + " 'chrUn_KI270429v1': 1361,\n", + " 'chr1_KI270709v1_random': 66860,\n", + " 'chrUn_KI270580v1': 1553,\n", + " 'chr2_KI270715v1_random': 161471,\n", + " 'chrUn_KI270756v1': 79590,\n", + " 'chr1_KI270706v1_random': 175055,\n", + " 'chr21': 46709983,\n", + " 'chrUn_KI270584v1': 4513,\n", + " 'chrUn_KI270336v1': 1026,\n", + " 'chrUn_KI270747v1': 198735,\n", + " 'chrUn_KI270419v1': 1029,\n", + " 'chr14_KI270722v1_random': 194050,\n", + " 'chrUn_KI270519v1': 138126,\n", + " 'chr1_KI270712v1_random': 176043,\n", + " 'chrUn_KI270442v1': 392061,\n", + " 'chr22_KI270733v1_random': 179772,\n", + " 'chrUn_KI270366v1': 8320,\n", + " 'chr9_KI270718v1_random': 38054,\n", + " 'chrUn_KI270587v1': 2969,\n", + " 'chrUn_KI270515v1': 6361,\n", + " 'chrUn_KI270582v1': 6504,\n", + " 'chrUn_KI270411v1': 2646,\n", + " 'chrUn_KI270583v1': 1400,\n", + " 'chrUn_KI270330v1': 1652,\n", + " 'chrUn_KI270511v1': 8127,\n", + " 'chr4': 190214555,\n", + " 'chr9_KI270717v1_random': 40062,\n", + " 'chr17_KI270729v1_random': 280839,\n", + " 'chr2': 242193529,\n", + " 'chr5_GL000208v1_random': 92689,\n", + " 'chr1_KI270710v1_random': 40176,\n", + " 'chrUn_KI270438v1': 112505,\n", + " 'chrUn_KI270591v1': 5796,\n", + " 'chrUn_KI270382v1': 4215,\n", + " 'chr1_KI270714v1_random': 41717,\n", + " 'chrUn_KI270391v1': 1484,\n", + " 'chr14_KI270725v1_random': 172810,\n", + " 'chrUn_KI270390v1': 2387,\n", + " 'chr14_GL000225v1_random': 211173,\n", + " 'chrUn_KI270310v1': 1201,\n", + " 'chrY': 57227415,\n", + " 'chrX': 156040895,\n", + " 'chrUn_GL000220v1': 161802,\n", + " 'chrM': 16569,\n", + " 'chrUn_GL000224v1': 179693,\n", + " 'chr22_KI270738v1_random': 99375,\n", + " 'chrUn_KI270467v1': 3920,\n", + " 'chrUn_KI270757v1': 71251,\n", + " 'chr22_KI270735v1_random': 42811,\n", + " 'chr22': 50818468,\n", + " 'chr20': 64444167,\n", + " 'chrUn_KI270448v1': 7992,\n", + " 'chr2_KI270716v1_random': 153799,\n", + " 'chrUn_KI270468v1': 4055,\n", + " 'chr7': 159345973,\n", + " 'chr6': 170805979,\n", + " 'chr5': 181538259,\n", + " 'chrUn_KI270507v1': 5353,\n", + " 'chr3': 198295559,\n", + " 'chrUn_KI270589v1': 44474,\n", + " 'chr1': 248956422,\n", + " 'chrUn_KI270510v1': 2415,\n", + " 'chrUn_KI270466v1': 1233,\n", + " 'chr9': 138394717,\n", + " 'chr8': 145138636,\n", + " 'chrUn_KI270465v1': 1774}" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw = pyBigWig.open('https://encode-public.s3.amazonaws.com/2016/11/14/fa0368ac-fae9-405e-9844-190631339d29/ENCFF565YYD.bigWig')\n", + "bw.chroms() # returns dictionary with chromosomes as key and number of entries as values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's useful because we then can use these values" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "248956422" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw.chroms()['chr1'] # number of entries" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.05996999889612198, 0.05996999889612198, 0.05996999889612198]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bw.values(\"chr1\", 0, 3) # Three values from chromosome 1 at positions from 0 to 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "248956422 values are too many for pyplot module to handle, so we bin the data by averaging values over 50pb. " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "chrom1_number_of_bins = int(bw.chroms()['chr1'] / 50) # Calculate how many bins we should have\n", + "chrom1_binned_values = bw.stats('chr1', type='mean', nBins=chrom1_number_of_bins) # This takes some time " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since it takes too long to load the data, we want to save the binned values so next time notebook restarts, we won't have to wait for it to be binned again. For this, we use HDF5 format and h5py python module. We first clean up the data from missing values. " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "chrom1_numpy = np.array(chrom1_binned_values, dtype=float) # We are converting the values into float format\n", + "chrom1_clean_binned = np.nan_to_num(chrom1_numpy) # Converting missing values into 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now save the array into HDF5 formatted file. " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "f = h5py.File('/data/chr1_binned_values', 'r+')\n", + "f.create_dataset('chrom1_50_binned', data=chrom1_clean_binned)\n", + "f.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now get our data from the file that holds our processed data" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "f = h5py.File('/data/chr1_binned_values', 'r') # Opening file in read-only mode\n", + "chrom1_clean_50_binned = f.get('chrom1_50_binned')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "get method of the module returns a class that wraps around the data, but we need numpy array. So:" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "chrom1_clean_50_binned = np.array(chrom1_clean_50_binned) # Converting to numpy array" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(chrom1_clean_50_binned)\n", + "plt.title('Chromosome 1 signal p-value, binned 50pb')\n", + "plt.xlabel('50bp regions')\n", + "plt.ylabel('signal p-value averaged over 50bp')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is great, but what can we do with it? The whole point of converting genomic data to numpy array was so that we could run some statistical analysis on it. Since neural networks are so in these days, let's try it out." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Naive Introduction to Neural Networks with ENCODE data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Suppose we want to predict chromatin state from just the *H3K4me3* data. That's somewhat a difficult task, but we could start by asking whether *H3K4me3* can predict *H3K27ac*. In this case, *H3K4me3* data will be our input and *H3K27ac* our preduction output. Lucky for us, the same lab that produced the *H3K4me3* data also produced *H3K27ac* data from the same cell line. This will allow us to more accurately compare the prediction output of our model to the ground truth. Let's start beating *H3K27ac* data into a shape we like. The experiment we will train our model on is [ENCSR000AKC](https://www.encodeproject.org/experiments/ENCSR000AKC/)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "bw_ac = pyBigWig.open(\"https://encode-public.s3.amazonaws.com/2017/01/05/6a02cb91-351e-44af-8b47-9ca0c4692231/ENCFF659ZJE.bigWig\")\n", + "\n", + "chrom1_bins_ac = int(bw_ac.chroms()['chr1'] / 50)\n", + "chrom1_binned_values_ac = bw_ac.stats('chr1', type='mean', nBins=chrom1_bins_ac)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "chrom1_numpy_ac = np.array(chrom1_binned_values_ac, dtype=float) # We are converting the values into float format\n", + "chrom1_clean_binned_ac = np.nan_to_num(chrom1_numpy_ac) # Converting missing values into 0\n", + "f = h5py.File('/data/chr1_binned_values_ac', 'w')\n", + "f.create_dataset('chrom1_50_binned_ac', data=chrom1_clean_binned_ac)\n", + "f.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "f_ac = h5py.File('/data/chr17_binned_values_ac', 'r') # Opening file in read-only mode\n", + "chrom17_clean_50_binned_ac = f_ac.get('chrom17_50_binned_ac')\n", + "chrom17_clean_50_binned_ac = np.array(chrom17_clean_50_binned_ac)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "f_ac = h5py.File('/data/chr1_binned_values_ac', 'r') # Opening file in read-only mode\n", + "chrom1_clean_50_binned_ac = f_ac.get('chrom1_50_binned_ac')\n", + "chrom1_clean_50_binned_ac = np.array(chrom1_clean_50_binned_ac)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to a couple of checks to see if our *H3K27ac* data lines up with the methylation data, such as making sure we have equal number of bins covering almost all of the chromosome 17:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "assert len(chrom1_clean_50_binned_ac) == len(chrom1_clean_50_binned)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how our training data looks" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20,5))\n", + "plt.plot(chrom1_clean_50_binned_ac)\n", + "plt.title('H3K27ac')\n", + "plt.show()\n", + "plt.figure(figsize=(20,5))\n", + "plt.plot(chrom1_clean_50_binned) # Plotting H3K4me3 again so we can compare inputs and outputs together\n", + "plt.title('H3K4me3')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks pretty good, somewhat correlated. We zoom a bit:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20,5))\n", + "plt.plot(chrom1_clean_50_binned_ac[880000:1000000])\n", + "plt.title('H3K27ac')\n", + "plt.show()\n", + "plt.figure(figsize=(20,5))\n", + "plt.plot(chrom1_clean_50_binned[880000:1000000]) # Plotting H3K4me3 again so we can compare inputs and outputs together\n", + "plt.title('H3K4me3')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that it's not identical but there is a strong correlation between the signal profiles. Now, onto building our Convolutional Neural Network (CNN) model. CNNs have been quite useful for biological applications, easier to train than Dense Neural Networks (DNN), and do comparably well when it comes to accuracy. One of the main feature of CNNs is that, neurons in a layer connect to few of the nearby neurons in preceeding layer. (DNN neurons connect to all of the neurons in preceeding layer) More on CNNs: http://cs231n.github.io/convolutional-networks/" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Neural network can't take an input size that's too large. For that reason, we have to divide up our entire dataset into samples. Each sample will be a slice of the chromosome representing gene region of fixed size. Suppose we want input and output samples to cover 5000bp, this means we need to slice the entire range into slices of size 1000 elements. (1000 x 50 = 5000pb since each element is averaged signal p-value over 50pb) Here is the current shape of our data." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(4979128,)\n" + ] + } + ], + "source": [ + "print(chrom1_clean_50_binned.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Shape after slicing it up into samples:" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "gene_region_size = 1000" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4979000\n", + "4979000\n", + "Input shape (4979, 1000)\n", + "Output shape (4979, 1000)\n", + "4979 samples of size 1000 each\n" + ] + } + ], + "source": [ + "# Using array slice operator to get the elements that is evenly divisible by 1000\n", + "inputs = chrom1_clean_50_binned[:(-(len(chrom1_clean_50_binned) % gene_region_size))]\n", + "print(len(inputs))\n", + "\n", + "outputs = chrom1_clean_50_binned_ac[:(-(len(chrom1_clean_50_binned_ac) % gene_region_size))]\n", + "print(len(outputs))\n", + "\n", + "\n", + "\n", + "input_samples = inputs.reshape(-1, gene_region_size) \n", + "output_samples = outputs.reshape(-1, gene_region_size)\n", + "\n", + "print('Input shape ', input_samples.shape) \n", + "print('Output shape ', output_samples.shape)\n", + "print('{} samples of size {} each'.format(input_samples.shape[0], input_samples.shape[1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will split the data into training and test sets. Holding out some of the data as a test set allows us to check the accuracy of the model that's trained on the training set. Test set is a holdout, model never sees it. If the model can predict the outputs of the test set based on the inputs of the test set after it has been trained, this could mean that model has the predictive potential for a general dataset of this kind. " + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "# Features are inputs from which we predict the output labels\n", + "train_features, test_features, train_labels, test_labels = train_test_split(\n", + " input_samples, output_samples, test_size=0.25, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [], + "source": [ + "# Sorting samples so that high signal regions influence the model parameters early on\n", + "train_labels_mean = np.mean(train_labels, axis=1)\n", + "sorted_indices = train_labels_mean.argsort()[::-1]\n", + "train_features = train_features[sorted_indices]\n", + "train_labels = train_labels[sorted_indices]\n", + "\n", + "# Extra dimension is so keras library won't complain, data is same\n", + "train_features = train_features.reshape(-1, gene_region_size, 1)\n", + "test_features = test_features.reshape(-1, gene_region_size, 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model layers:" + ] + }, + { + "cell_type": "code", + "execution_count": 238, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "conv1d_195 (Conv1D) (None, 1000, 16) 80 \n", + "_________________________________________________________________\n", + "batch_normalization_60 (Batc (None, 1000, 16) 4000 \n", + "_________________________________________________________________\n", + "max_pooling1d_98 (MaxPooling (None, 500, 16) 0 \n", + "_________________________________________________________________\n", + "conv1d_196 (Conv1D) (None, 500, 16) 1040 \n", + "_________________________________________________________________\n", + "batch_normalization_61 (Batc (None, 500, 16) 2000 \n", + "_________________________________________________________________\n", + "max_pooling1d_99 (MaxPooling (None, 250, 16) 0 \n", + "_________________________________________________________________\n", + "conv1d_197 (Conv1D) (None, 250, 16) 1040 \n", + "_________________________________________________________________\n", + "batch_normalization_62 (Batc (None, 250, 16) 1000 \n", + "_________________________________________________________________\n", + "max_pooling1d_100 (MaxPoolin (None, 125, 16) 0 \n", + "_________________________________________________________________\n", + "conv1d_198 (Conv1D) (None, 125, 16) 1040 \n", + "_________________________________________________________________\n", + "batch_normalization_63 (Batc (None, 125, 16) 500 \n", + "_________________________________________________________________\n", + "max_pooling1d_101 (MaxPoolin (None, 62, 16) 0 \n", + "_________________________________________________________________\n", + "conv1d_199 (Conv1D) (None, 62, 16) 1040 \n", + "_________________________________________________________________\n", + "batch_normalization_64 (Batc (None, 62, 16) 248 \n", + "_________________________________________________________________\n", + "max_pooling1d_102 (MaxPoolin (None, 31, 16) 0 \n", + "_________________________________________________________________\n", + "conv1d_200 (Conv1D) (None, 31, 16) 1040 \n", + "_________________________________________________________________\n", + "flatten_32 (Flatten) (None, 496) 0 \n", + "_________________________________________________________________\n", + "dense_32 (Dense) (None, 1000) 497000 \n", + "=================================================================\n", + "Total params: 510,028\n", + "Trainable params: 506,154\n", + "Non-trainable params: 3,874\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "filter_size = 16\n", + "kernel_size = 4\n", + "\n", + "model = Sequential()\n", + "\n", + "# Initial CNN layer, 25 neurons, each connecting to 4 previous\n", + "model.add(Conv1D(filters=filter_size, \n", + " kernel_size=kernel_size, \n", + " activation='relu', \n", + " input_shape=(train_features.shape[1], train_features.shape[2]), padding='same'))\n", + "model.add(BatchNormalization(axis=1))\n", + "model.add(MaxPooling1D(pool_size=2)) # https://www.quora.com/What-is-max-pooling-in-convolutional-neural-networks\n", + "model.add(Conv1D(filters=filter_size, kernel_size=kernel_size, activation='relu', padding='same'))\n", + "model.add(BatchNormalization(axis=1))\n", + "model.add(MaxPooling1D(pool_size=2))\n", + "model.add(Conv1D(filters=filter_size, kernel_size=kernel_size, activation='relu', dilation_rate=2, padding='same'))\n", + "model.add(BatchNormalization(axis=1))\n", + "model.add(MaxPooling1D(pool_size=2))\n", + "model.add(Conv1D(filters=filter_size, kernel_size=kernel_size, activation='relu', dilation_rate=4, padding='same'))\n", + "model.add(BatchNormalization(axis=1))\n", + "model.add(MaxPooling1D(pool_size=2))\n", + "model.add(Conv1D(filters=filter_size, kernel_size=kernel_size, activation='relu', dilation_rate=8, padding='same'))\n", + "model.add(BatchNormalization(axis=1))\n", + "model.add(MaxPooling1D(pool_size=2))\n", + "model.add(Conv1D(filters=filter_size, kernel_size=kernel_size, activation='relu', dilation_rate=16, padding='same'))\n", + "model.add(Flatten()) # We flatten the dimensions so the data eventually gets in to the same shape as the labels\n", + "model.add(Dense(train_labels.shape[1], activation='relu')) # Final dense layer is for capturing distal effects\n", + "\n", + "#model.compile(loss=correlation_coefficient_loss, optimizer='adam', metrics=['poisson', 'acc'])\n", + "model.compile(loss='mean_squared_error', optimizer='adam', metrics=['poisson', 'acc'])\n", + "\n", + "\n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 239, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train on 2987 samples, validate on 747 samples\n", + "Epoch 1/50\n", + "2987/2987 [==============================] - 20s 7ms/step - loss: 6.7657 - poisson: 1.7136 - acc: 0.0027 - val_loss: 0.0935 - val_poisson: 1.0907 - val_acc: 0.0040\n", + "Epoch 2/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 6.2602 - poisson: 1.3648 - acc: 0.0030 - val_loss: 0.0643 - val_poisson: 0.8403 - val_acc: 0.0000e+00\n", + "Epoch 3/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 5.9728 - poisson: 1.3504 - acc: 0.0090 - val_loss: 0.0767 - val_poisson: 0.8531 - val_acc: 0.0013\n", + "Epoch 4/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 5.8402 - poisson: 1.5518 - acc: 0.0067 - val_loss: 0.0765 - val_poisson: 0.8878 - val_acc: 0.0000e+00\n", + "Epoch 5/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 5.4804 - poisson: 1.7222 - acc: 0.0094 - val_loss: 0.1069 - val_poisson: 0.9250 - val_acc: 0.0000e+00\n", + "Epoch 6/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 5.4752 - poisson: 1.9497 - acc: 0.0127 - val_loss: 0.3322 - val_poisson: 1.6023 - val_acc: 0.0013\n", + "Epoch 7/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 5.2130 - poisson: 2.1364 - acc: 0.0177 - val_loss: 0.1064 - val_poisson: 1.1767 - val_acc: 0.0013\n", + "Epoch 8/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 5.0287 - poisson: 2.2403 - acc: 0.0167 - val_loss: 0.4948 - val_poisson: 2.5313 - val_acc: 0.0000e+00\n", + "Epoch 9/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 4.7944 - poisson: 2.5012 - acc: 0.0238 - val_loss: 1.7868 - val_poisson: 3.0484 - val_acc: 0.0027\n", + "Epoch 10/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 4.5382 - poisson: 2.7915 - acc: 0.0285 - val_loss: 0.2346 - val_poisson: 1.8838 - val_acc: 0.0000e+00\n", + "Epoch 11/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 4.2559 - poisson: 2.7298 - acc: 0.0301 - val_loss: 0.5828 - val_poisson: 2.8502 - val_acc: 0.0013\n", + "Epoch 12/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 4.0717 - poisson: 2.8642 - acc: 0.0358 - val_loss: 4.4998 - val_poisson: 3.6791 - val_acc: 0.0027\n", + "Epoch 13/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 3.7693 - poisson: 3.0202 - acc: 0.0405 - val_loss: 1.7515 - val_poisson: 3.7543 - val_acc: 0.0013\n", + "Epoch 14/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 3.4634 - poisson: 3.2766 - acc: 0.0388 - val_loss: 1.3254 - val_poisson: 3.7532 - val_acc: 0.0013\n", + "Epoch 15/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 3.2488 - poisson: 3.3785 - acc: 0.0392 - val_loss: 1.4156 - val_poisson: 3.8169 - val_acc: 0.0013\n", + "Epoch 16/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 3.0459 - poisson: 3.4518 - acc: 0.0489 - val_loss: 1.2112 - val_poisson: 4.0130 - val_acc: 0.0013\n", + "Epoch 17/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 2.8332 - poisson: 3.5221 - acc: 0.0532 - val_loss: 2.1277 - val_poisson: 4.5347 - val_acc: 0.0013\n", + "Epoch 18/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 2.7538 - poisson: 3.7854 - acc: 0.0546 - val_loss: 2.8794 - val_poisson: 4.5355 - val_acc: 0.0013\n", + "Epoch 19/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 2.5490 - poisson: 3.7662 - acc: 0.0666 - val_loss: 0.6016 - val_poisson: 3.9641 - val_acc: 0.0054\n", + "Epoch 20/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 2.3928 - poisson: 3.8467 - acc: 0.0693 - val_loss: 1.1992 - val_poisson: 4.4208 - val_acc: 0.0013\n", + "Epoch 21/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 2.2902 - poisson: 4.0394 - acc: 0.0693 - val_loss: 0.8247 - val_poisson: 4.4380 - val_acc: 0.0013\n", + "Epoch 22/50\n", + "2987/2987 [==============================] - 5s 2ms/step - loss: 2.2396 - poisson: 4.1794 - acc: 0.0680 - val_loss: 1.1179 - val_poisson: 4.4261 - val_acc: 0.0027\n" + ] + } + ], + "source": [ + "# We are again splitting the training set into two sets: train and validation sets\n", + "# Validation set is withheld from each training epoch\n", + "# At the end of each epoch, loss for validation set is calculated\n", + "# For model to be generizeable, losses for validation and training should go down together\n", + "# If loss for traning goes down but validation loss goes up, then we have overfitting problem\n", + "# Overfitting means that model only does well for the data it's trained on\n", + "# We usually stop training when overfitting starts to occur. \n", + "from keras.callbacks import EarlyStopping\n", + "callbacks = [EarlyStopping(monitor='val_loss', patience=20)]\n", + "\n", + "history = model.fit(train_features, train_labels, \n", + " epochs=50, verbose=1, validation_split=0.2, callbacks=callbacks)" + ] + }, + { + "cell_type": "code", + "execution_count": 240, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl8VPW9//HXh2wQlkSSoIQQAwRkkwAGcMO6VItbccMCtlWLolXrrXrb2sVea5f7U6vYW5crrSiuaLEquFH3lQJBdhAIEUgIQiAkIASyfX5/ZPTGmJABEmYy834+Hnlk5pzvmfnMYfKeL9/5nnPM3RERkejQLtQFiIjI4aPQFxGJIgp9EZEootAXEYkiCn0RkSii0BcRiSIKfRGRKKLQFxGJIgp9EZEoEhvqAhpKTU31rKysUJchItKmLFy4cJu7pzXXLuxCPysri7y8vFCXISLSppjZhmDaaXhHRCSKKPRFRKKIQl9EJIoEFfpmNsbMVptZvpnd2sj6BDN7NrB+npllBZZfZmaL6/3UmtnQln0JIiISrGZD38xigAeAs4GBwAQzG9ig2SRgh7tnA1OAOwHc/Sl3H+ruQ4EfAOvdfXFLvgAREQleMD39kUC+uxe4eyUwAxjboM1YYHrg9kzgDDOzBm0mAM8cSrEiInJoggn9HkBhvftFgWWNtnH3aqAcSGnQ5ns0EfpmNtnM8swsr6SkJJi6RUTkIAQzT79hjx2g4TUW99vGzEYBe9x9eWNP4O5TgakAubm5un6jiIRMTa0ze0kxBSVfHNT2CXExjMjqyrDMZOJiwm+uTDChXwT0rHc/Ayhuok2RmcUCSUBpvfXj0dCOiIQxd+fd1SX892urWLOlLvC/MUgd1OPU/e6UEMvxvVM4pV8qp/RN4+iURL456n34BRP6C4C+ZtYL2ERdgE9s0GYWcDkwF7gEeNsDV1w3s3bAOOCUlipaRKQlLSsq50+vrmJuwXayUhJ58LLhnD34qIMK6fKKKuau284Ha0t4f20Jb67aAkDPrh0Y3TeNU/qmckKfVJI6xLX0ywhKs6Hv7tVmdgMwB4gBprn7CjO7A8hz91nAI8ATZpZPXQ9/fL2HOAUocveCli9fROTgFZbu4c//Ws1Li4vp2jGe3313EBNGZhIfe/DDMkkd4hgz+CjGDD4KgA3bd/P+mhLeX7uNWYuLeXreRmLaGUN7JjO6byqj+6aRk5FE7GEaCjL38BpCz83NdZ17R0RaU9meSh54J5/pH2/ADK4a3YtrvtWHLu1bt/ddVVPL4sIyPgh8CCwpKsMdOreP5aQ+qZw7pDvn56Qf1GOb2UJ3z22uXdidcE1EpLXsrarh8bnruf/tfHbtq+aS4RncfFY/uid1OCzPHxfTjhFZXRmR1ZWbzzqGsj2VfJQfGApaU0JyYtxBh36wFPoiEvFqa51ZS4q5e85qNpVVcOoxadx6dn/6H9UlpHUlJ8Zz7pDunDukO+7O3qraVn9Ohb6IRLSP87fxp9dWsXzTTgald+GuS4ZwUnZqqMv6BjOjQ3xMqz+PQl9EIlLZnkpuenYx76wuoUdyB+773lC+m5NOu3ahnzYZSgp9EYlIj3z4Ge+uKeGXZ/fn8hOzaB/X+r3otkChLyIRp6qmlhkLCjntmG5c860+oS4nrITfMcIiIoforVVbKNm1j8tGZYa6lLCj0BeRiPPUvI2kJ7Xn1GO6hbqUsKPQF5GIsn7bbj5Yu40JIzOJifIvbRuj0BeRiPLM/LrTHFw6omfzjaOQQl9EIsa+6hr+sbCIMwccyZFd2oe6nLCk0BeRiPH68s8p3V3JZcfrC9ymKPRFJGI8NW8jR6ckclKf8DviNlwo9EUkIqzdsov5n5UyYWRm1B91uz8KfRGJCE/P30hcjDHuuIxQlxLWFPoi0uZVVNbw/MIizh7cnZROCaEuJ6wp9EWkzXt5aTE791brCNwgKPRFpM17ev5Gsrt1YmSvrqEuJewp9EWkTVtRXM6ijWVMHJl5UBcyjzYKfRFp056et5GE2HZcPFxf4AYjqNA3szFmttrM8s3s1kbWJ5jZs4H188wsq966IWY218xWmNkyM9NhciLSIr7YV82LizZxfk46SYmte1HzSNFs6JtZDPAAcDYwEJhgZgMbNJsE7HD3bGAKcGdg21jgSeBadx8EnApUtVj1IhLVZi0uZndlDRP1BW7QgunpjwTy3b3A3SuBGcDYBm3GAtMDt2cCZ1jd4NpZwFJ3XwLg7tvdvaZlSheRaObuPDVvAwO6d2FYz+RQl9NmBBP6PYDCeveLAssabePu1UA5kAL0A9zM5pjZJ2b280MvWUQElhSVs6J4J5eN0he4ByKYyyU2tjc9yDaxwMnACGAP8JaZLXT3t762sdlkYDJAZqb+myYizXvq3xtIjI9h7ND0UJfSpgTT0y8C6p+YOgMobqpNYBw/CSgNLH/P3be5+x7gVWB4wydw96nunuvuuWlpaQf+KkQkqpRXVDF7aTFjh/agc3t9gXsgggn9BUBfM+tlZvHAeGBWgzazgMsDty8B3nZ3B+YAQ8wsMfBh8C1gZcuULiLR6oVPithbVasjcA9Cs8M77l5tZjdQF+AxwDR3X2FmdwB57j4LeAR4wszyqevhjw9su8PM7qXug8OBV939lVZ6LSISBeq+wN1ITs9kBvdICnU5bU4wY/q4+6vUDc3UX/bberf3AuOa2PZJ6qZtiogcsgXrd7B26xfcdfGQUJfSJumIXBFpU56et4HO7WM5L6d7qEtpkxT6ItJmlO6u5NVln3Px8AwS44MaqJAGFPoi0mbMXFhIZU2tjsA9BAp9EWkTamudp+dtZETWEfQ7snOoy2mzFPoi0ibMLdjO+u17uGzU0aEupU1T6ItIm/DUvA0ckRjHmMFHhbqUNk2hLyJhb+vOvfxrxRbG5fakfVxMqMtp0xT6IhL2nssrpLrWmTBSX+AeKoW+iIS1mlrnmfmFnJSdQq/UjqEup81T6ItIWHt/TQmbyir0BW4L0dENIhJ23J38rV/w/tptPD1vA2mdEzhz4JGhLisiKPRFJCyU7q7ko/xtvL+mhA/WbuPznXsB6J3Wkd99dxBxMRqYaAkKfREJicrqWj7ZuIMP1taF/LJN5bhDl/axnNw3lVP6pnFy31QyjkgMdakRRaEvIoeFu/PZtt18sHYbH6wtYe667eyurCGmnTGsZzI3fbsfo/umMiQjmZh2uvxha1Hoi0ir+2BtCb96YRmFpRUAZHZN5MLhPRjdN40T+qTQRVe/OmwU+iLSqv75SRE/n7mUXqkd+f0FgzmlbypHp2jqZago9EWkVbg7//teAXe+/ikn9E7h4R8epx59GFDoi0iLq6l17pi9gulzN3B+Tjp/HjeEhFidPiEcKPRFpEXtrarhpzMW8/qKz7l6dC9+efYA2umL2bCh0BeRFlO2p5KrH88jb8MObjtvIJNO7hXqkqQBhb6ItIhNZRVcPm0+G7fv4a8ThnHekPRQlySNCOoQNzMbY2arzSzfzG5tZH2CmT0bWD/PzLICy7PMrMLMFgd+/rdlyxeRcLBq804uevAjtuzcy/QfjVTgh7Fme/pmFgM8AJwJFAELzGyWu6+s12wSsMPds81sPHAn8L3AunXuPrSF6xaRMPFx/jaueWIhHRNimXntiRxzlC5lGM6C6emPBPLdvcDdK4EZwNgGbcYC0wO3ZwJnmJm+uRGJcLOWFHP5o/Ppntyef16nwG8Lggn9HkBhvftFgWWNtnH3aqAcSAms62Vmi8zsPTMbfYj1ikiY+Nv7Bdz4zCKGZR7BP645kfTkDqEuSYIQzBe5jfXYPcg2m4FMd99uZscBL5rZIHff+bWNzSYDkwEyM3VlHJFwVlvr/PHVVTzy4Wece2x37rk0R5cwbEOC6ekXAT3r3c8AiptqY2axQBJQ6u773H07gLsvBNYB/Ro+gbtPdfdcd89NS0s78FchIofFvuoafjJjEY98+BlXnpTFXycMU+C3McGE/gKgr5n1MrN4YDwwq0GbWcDlgduXAG+7u5tZWuCLYMysN9AXKGiZ0kXkcLvxmUW8snQzvzqnP789b6AOumqDmh3ecfdqM7sBmAPEANPcfYWZ3QHkufss4BHgCTPLB0qp+2AAOAW4w8yqgRrgWncvbY0XIiKtK299KXNWbOE/z+rH5FP6hLocOUhBHZzl7q8CrzZY9tt6t/cC4xrZ7nng+UOsUUTCwJQ315DaKZ5JJ/cOdSlyCHT9MRFp1vzPSvkofzvXfqsPHeI1ht+WKfRFpFn3vbmG1E4JXDbq6FCXIodIoS8i+zWvYDsfr9vOj09VLz8SKPRFZL+mvLmGbp0TuGyUjqGJBAp9EWnS3HXb+XdBKT8+tY/m40cIhb6INMrdv+rlTxipXn6kUOiLSKPmFmxn/melXKdefkRR6IvIN7g7972xlqO6tGe8evkRRaEvIt/w8brtzF9fynWnqZcfaRT6IvI17s6UN9ZwVJf2fG9Ez+Y3kDZFoS8iX/Nh/jbyNuzg+tP6kBCrXn6kUeiLyFfcnfveXEt6UnsuVS8/Iin0ReQrH6zdxsINO7jutGz18iOUQl9EgP+bl98juQOX5qqXH6kU+iICwHtrSli0sYzrT8smPlbREKn0LysigV7+Wnokd+CS4zJCXY60IoW+iPDu6hKWFJZxw+nq5Uc6/euKRLm6GTtryDhCvfxooNAXiXLvrN7KkqJyfnJ6NnExioRIp39hkSj25bz8nl07cNFw9fKjgUJfJIq9tWorS4vK+clpfdXLjxJB/Sub2RgzW21m+WZ2ayPrE8zs2cD6eWaW1WB9ppl9YWb/2TJli0SOfdU1IXled+e+t9aQ2TWRC4f3CEkNcvg1G/pmFgM8AJwNDAQmmNnABs0mATvcPRuYAtzZYP0U4LVDL1cksvz9gwIG3PY6Fz/0MY999Blbd+09bM/9xsotLN+0U2P5USaYf+mRQL67F7h7JTADGNugzVhgeuD2TOAMMzMAM7sAKABWtEzJIm2fu/M/b63lD6+sYlSvFHbvq+b22SsZ9ae3mDD13zw9byOluytb9fnve3MtWSmJXDhMvfxoEhtEmx5AYb37RcCoptq4e7WZlQMpZlYB/AI4E2hyaMfMJgOTATIzdcEGiWzuzl1zVvPQu+u4aHgP7rp4CLEx7cjfuovZSzYze0kxv3phGb99aTknZadyfk46Zw06ki7t41qshn+t3MLKzTu5Z1wOserlR5VgQt8aWeZBtvkdMMXdvwh0/Bvl7lOBqQC5ubkNH1skYtTWOne8vJLHPl7PxFGZ/GHsYNq1q/vbyO7WmZvO7MxPv92XlZt3MnvJZl5eWsx//mMJ8f9sx6nHpHFeTjrfHtCNxPhg/nS/yd2pqKrhvjfX0iu1I2OHprfky5M2IJh3ThFQ/+xLGUBxE22KzCwWSAJKqfsfwSVmdheQDNSa2V53v/+QKxdpY2pqnV+/sIwZCwqZdHIvfnPuABrrDJkZg9KTGJSexC/GHMPiwrKvPgD+tXILHeJiOGNAN84bkk52t06UV1RRXlFJeUUVZXuqvvq9s6KKsoov71dSXlFNeUUlVTV1/ap7L1UvPxqZ+/471oEQXwOcAWwCFgAT3X1FvTbXA8e6+7VmNh64yN0vbfA4twNfuPuf9/d8ubm5npeXdzCvRSRsVdfUcss/lvDS4mJ+cno2N5/Zr9HA35+aWmfB+lJeXlrMq8s+3++Yf+eEWJIS40hOjCOpQxzJHeLp0qHufnKHOI5O6ch3Bh15wDVI+DKzhe6e21y7Znv6gTH6G4A5QAwwzd1XmNkdQJ67zwIeAZ4ws3zqevjjD618kchRWV3Ljc8s4vUVn/Oz7xzD9adlH9TjxLQzju+dwvG9U7j9/EH8u6CUbV/sqwv3DnEkJ8aT1CGOLu1j1YOXJjXb0z/c1NOXSLK3qoYfP7mQd1aX8NvzBvKjk3uFuiSJUC3W0xeRg7N7XzVXP57H3ILt/OnCY5k4SjPTJPQU+iKtYOfeKq58dAGLNu7g3ktzuHCYzmsj4UGhL9LCduyu5IfT5rNq807unzicc47tHuqSRL6i0BdpQSW79vH9v8/js+27mfrD4zi9/5GhLknkaxT6Ii1kc3kFl/1tHpvL9/LoFSM4KTs11CWJfINCX6QFFJbuYeLf/82O3VU8PmkkI7K6hrokkUYp9EUO0bYv9jHx7/9mZ0U1T101ipyeyaEuSaRJOoJD5BDsrarh6sfzKNm1j8d/NFKBL2FPPX2Rg1Rb69zy3BIWF5bx0GXHKfClTVBPX+Qg3f2v1byybDO/OnsAYwYfFepyRIKi0Bc5CDPmb+Shd9dx2ahMrhqtUytI26HQFzlAH67dxm9eXM4p/dL43XcH6UyV0qYo9EUOwJotu/jxkwvJ7taJByYO09kspc3RO1YkSCW79nHlowtoHx/DI1eMoHMLXr5Q5HBR6IsEoaKyhqsez6N0dyXTLh9Bj+QOoS5J5KBoyqZIM2prnZufW8zSojIe/v5xHJuRFOqSRA6aevoizbhzzqe8tvxzfn3OAM4apKmZ0rYp9EX245n5G3n4vQJ+cPzRTNJVryQCKPRFmvDB2hJ+8+JyTj0mjf86f6CmZkpEUOiLNGL157u47slP6NutE3+doKmZEjmCeieb2RgzW21m+WZ2ayPrE8zs2cD6eWaWFVg+0swWB36WmNmFLVu+SMvbumsvP3psAR3iY5imqZkSYZoNfTOLAR4AzgYGAhPMbGCDZpOAHe6eDUwB7gwsXw7kuvtQYAzwsJlpxpCErYrKGq6eXjc185HLR5CuqZkSYYLp6Y8E8t29wN0rgRnA2AZtxgLTA7dnAmeYmbn7HnevDixvD3hLFC3SGvZUVvPTZxexdFM5/zNhmKZmSkQKptfdAyisd78IGNVUG3evNrNyIAXYZmajgGnA0cAP6n0IiITc3qoa3ltTwuwlxby1aisVVTXcdt5Azhyoa9tKZAom9BubstCwx95kG3efBwwyswHAdDN7zd33fm1js8nAZIDMzMwgShI5eFU1tXyYv43ZS4p5Y8UWdu2rpmvHeC4a3oOxQ3swspcudSiRK5jQLwJ61rufARQ30aYoMGafBJTWb+Duq8xsNzAYyGuwbiowFSA3N1dDQNLiamqdeQXbmb10M68t30zZnio6t49lzOCjOD8nnRP7pGiGjkSFYEJ/AdDXzHoBm4DxwMQGbWYBlwNzgUuAt93dA9sUBoZ8jgaOAda3VPEi+1Nb63yycQcvL93MK8s2U7JrH4nxMZw58EjOH5LO6H6pJMTGhLpMkcOq2dAPBPYNwBwgBpjm7ivM7A4gz91nAY8AT5hZPnU9/PGBzU8GbjWzKqAWuM7dt7XGCxH5UkHJF8xYUMjLS4opLt9LfGw7zujfjfOGpHN6/250iFfQS/Qy9/AaTcnNzfW8vLzmG4o0YsH6Uq58dAH7qmsY3TeN83O68+0BR2quvUQ8M1vo7rnNtdOceYkYH+Vv46rpeXRPbs+Tk0Zpjr1IIxT6EhHe/nQL1z75Cb1TO/LEpFGkdU4IdUkiYUmhL23ea8s2c+OMRQzo3oXpV47kiI7xoS5JJGxpjpq0aS8sKuL6pz8hJyOZJ68apcAXaYZ6+tJmPTN/I796YRkn9E7hbz/MpWOC3s4izdFfibRJ0z78jDteXslpx6Tx0PePo32cpmGKBEOhL23OA+/kc/ec1YwZdBT/M2EY8bEapRQJlkJf2gx359431vDXt/O5YGg6fx6Xo1MniBwghb60Ce7OH15ZxSMffsb4ET3544XHEtNOly8UOVAKfQl7tbXObS8t56l5G7nixCxdr1bkECj0JaxV19Tyi+eX8fwnRfz41D78/DvHKPBFDoFCX8JWVU0tP312Ma8s3cwtZ/bjhtOzFfgih0ihL2GpsrqW655ayJurtvKbcwdw1ejeoS5JJCIo9CUs3fPGat5ctZXfjx3ED07ICnU5IhFD890k7Mwr2M7U9wuYOCpTgS/SwhT6ElZ27a3i5ueWcHTXRH59zoBQlyMScTS8I2Hld7NXsrm8gpk/PlHn0hFpBerpS9h4fflmZi4s4vrTshmeeUSoyxGJSAp9CQtbd+3ll/9cxrE9krjxjL6hLkckYin0JeTcnV/MXMqeyhqmfC+HOJ1PR6TV6K9LQu7p+Rt5Z3UJvzy7P9ndOoe6HJGIFlTom9kYM1ttZvlmdmsj6xPM7NnA+nlmlhVYfqaZLTSzZYHfp7ds+dLWrd+2mz+8vIrRfVP5oaZnirS6ZkPfzGKAB4CzgYHABDMb2KDZJGCHu2cDU4A7A8u3Aee7+7HA5cATLVW4tH3VNbXc9Nxi4mPbcfclObTTWTNFWl0wPf2RQL67F7h7JTADGNugzVhgeuD2TOAMMzN3X+TuxYHlK4D2ZpbQEoVL2/fQu+tYtLGMP1wwmKOS2oe6HJGoEEzo9wAK690vCixrtI27VwPlQEqDNhcDi9x938GVKpFkaVEZf3lrLd/NSef8nPRQlyMSNYI5+qWx/3P7gbQxs0HUDfmc1egTmE0GJgNkZmYGUZK0ZRWVNdz07GJSOyXw+7GDQ12OSFQJpqdfBPSsdz8DKG6qjZnFAklAaeB+BvAC8EN3X9fYE7j7VHfPdffctLS0A3sF0ubc+fqnrCvZzZ/H5ZCUGBfqckSiSjChvwDoa2a9zCweGA/MatBmFnVf1AJcArzt7m5mycArwC/d/aOWKlrarvfXlPDYx+u58qQsTu6bGupyRKJOs6EfGKO/AZgDrAKec/cVZnaHmX030OwRIMXM8oGbgS+ndd4AZAO3mdniwE+3Fn8V0iaU7ankZzOXkN2tE78Y0z/U5YhEJXNvODwfWrm5uZ6XlxfqMqQV/OSZRby2bDMvXn8Sg3skhbockYhiZgvdPbe5djqNoTRr594qnltQSFrnBIZkJJOVknjAly18afEmZi8p5mffOUaBLxJCCn3Zry/2VXPFtPl8srHsq2Vd2scyJCOZYzOSyMlIYkhGMt2T2jf5QVBcVsFtLy7nuKOP4JpTdNlDkVBS6EuT9lRW86PHFrCkqJwHJg4nKzWRpUXlgZ8y/vZ+AdW1dcODqZ0SGJKRVO8nmdROCdTWOj+buYTqWufeS3OI1cnUREJKoS+N2ltVw1XT88hbX8pfxg/j3CHdARiUnsSEkf/XZtXmnV/7IHhn9Va+/JqoR3IH0pPbs2D9Dv77omM5OqVjiF6NiHxJoS/fsK+6hmueWMjcgu3cMy6nySNm28fFMCzzCIbVu+DJ7n3VLN9UzrJN5SwpKmdZURkXDE1n/IiejT6GiBxeCn35msrqWq5/6hPeW1PCnRcfy0XDMw5o+44JsYzqncKo3g3PwiEi4UADrPKV6ppa/mPGIt5ctZXfjx3E90bolBgikUahLwDU1Do3PbeE15Z/zm3nDeQHOre9SERS6Au1tc7PZy5l9pJifjGmP5NO7hXqkkSklSj0o1xtrfPrF5fx/CdF3PTtfvz41D6hLklEWpFCP4q5O7fPXsEz8wu5/rQ+3HhGdqhLEpFWptCPUu7OH19ZxeNzN3D16F7851nHHPCpFUSk7VHoRyF35+45q/n7h59xxYlZ/OqcAQp8kSih0I9Cf3lrLQ++u44JIzP5r/MHKvBFoohCP8o8+G4+9725lkuOy+CPFwxW4ItEGR2RGyVqap0H3snn3jfWMHZoOndePIR27RT4ItFGoR8FCkv3cMtzS5i/vpSxQ9O5Z1wOMQp8kaik0I9g7s6zCwr5/csraWfGn8flcPHwHhrSEYliCv0ItXXnXm795zLe/nQrJ/ZJ4e5xOfRI7hDqskQkxBT6EejlpcX85sXlVFTWcPv5A/nhCVkavxcRQKEfUcr2VHLbSyuYvaSYnJ7J3DMuh+xunUJdloiEkaCmbJrZGDNbbWb5ZnZrI+sTzOzZwPp5ZpYVWJ5iZu+Y2Rdmdn/Lli71vbt6K2dNeZ/Xlm3mljP78fy1JyjwReQbmu3pm1kM8ABwJlAELDCzWe6+sl6zScAOd882s/HAncD3gL3AbcDgwI+0sN37qvnjq6t4et5G+h3ZiWlXjGBwj6RQlyUiYSqY4Z2RQL67FwCY2QxgLFA/9McCtwduzwTuNzNz993Ah2amM3m1ggXrS7nluSUU7tjDNaf05qYz+9E+LibUZYlIGAsm9HsAhfXuFwGjmmrj7tVmVg6kANuCKcLMJgOTATIzdbWm5uyrruHeN9Yw9f0CMo7owLOTT2Bkr66hLktE2oBgQr+xaR9+EG2a5O5TgakAubm5QW8Xjeau287ts1awessuJozM5NfnDqBTgr6PF5HgBJMWRUDPevczgOIm2hSZWSyQBJS2SIVhbMvOvdw9ZzWn9+/GmEFHteq0yDVbdvH/XvuUtz/dSnpSex69YgSn9e/Was8nIpEpmNBfAPQ1s17AJmA8MLFBm1nA5cBc4BLgbXeP6B773qoarnliIYsLy5i5sIg+aR257tRsvjs0nbiYljuP3Zade5nyxhqeyyukY0Ist57dnytOzNLYvYgclGZDPzBGfwMwB4gBprn7CjO7A8hz91nAI8ATZpZPXQ9//Jfbm9l6oAsQb2YXAGc1mPnT5rg7v3lxOYsLy3hg4nBq3HnwnXxu+ccSpry5hmu/1YdLjss4pGD+Yl81D7+3jr99UEBNrXPFib34yenZHNExvgVfiYhEGwu3Dnlubq7n5eWFuoz9evSjz/jd7JXceEZfbj6zH1D3QfDWqq3c/04+iwvL6NY5gatH92biqEw6HsCYe1VNLTPmb+S+N9eyfXcl5+ek87OzjiEzJbG1Xo6IRAAzW+juuc22U+gfmI/zt/GDafM5vX83Hv7+cd8Yx3d3Pl63nfvfzmduwXaOSIzjypN6cfkJWSQlxjX5uO7OnBVbuOv1TynYtptRvbryq3MGkNMzubVfkohEAIV+Kygs3cP5939IWqcEXrj+pGZnzSzcsIMH38nnrU+30ikhlu8ffzSTTu5FWueEBu1K+dOrn7Jwww6yu3Xil2f35/T+3XQ2TBEJmkK/he3eV83FD31McVkFs244mazUjkFvu7J4Jw+8m8+ryzYTH9OOCSMzmXxKb/ZV13LX65/y2vLPSeucwM1n9mNjUv2GAAAGEklEQVTccRnEtuAXwSISHRT6Lcjdue6pT5iz4nMeu3Ikp/RLO6jHKSj5gofeXccLizZhBu6QENuOa77Vh6tG9yIxXvPtReTgBBv6Spkg3P92Pq8t/5xfnzPgoAMfoHdaJ+4el8N/fLsvj360HgOu+Vafbwz3iIi0FoV+M95YuYV73ljDhcN6cNXoXi3ymBlHJHLbeQNb5LFERA6EBo/3I3/rLm56djHH9kjivy86Vl+sikibp9BvQvmeKq5+fCHt49rx8A+O0xGwIhIRNLzTiJpa58YZiyjasYenrz6edF1bVkQihEK/EXfN+ZT31pTwpwuPZUSWTlksIpFDwzsNvLR4Ew+/V8D3j89k4iid219EIotCv55lReX8fOZSRmZ15bfnDQp1OSIiLU6hH7Dti31c80QeKR3jefD7w4mP1a4RkcijMX2gsrqW6578hNI9lcy89kRSO+lgKRGJTBEZ+u5ORVUN5RVVlO2pqve78uvLKqrYWVHFprIKCkp285fxQxncIynU5YuItJqICf2VxTu5ccYiyvbUBXllTW2TbWPaGUkd4kjuEEeXDnFkdk3kRyf1YuzQHoexYhGRwy9iQr9z+1j6HdmJpA5xJHWIrwv1xLivhfuX9zslxOroWhGJShET+j27JvLgZceFugwRkbCmKSoiIlFEoS8iEkWCCn0zG2Nmq80s38xubWR9gpk9G1g/z8yy6q37ZWD5ajP7TsuVLiIiB6rZ0DezGOAB4GxgIDDBzBqeDH4SsMPds4EpwJ2BbQcC44FBwBjgwcDjiYhICATT0x8J5Lt7gbtXAjOAsQ3ajAWmB27PBM6wuukxY4EZ7r7P3T8D8gOPJyIiIRBM6PcACuvdLwosa7SNu1cD5UBKkNuKiMhhEkzoNzahveHV1JtqE8y2mNlkM8szs7ySkpIgShIRkYMRTOgXAT3r3c8AiptqY2axQBJQGuS2uPtUd89199y0tIO/8LiIiOyfuX+j4/31BnUhvgY4A9gELAAmuvuKem2uB45192vNbDxwkbtfamaDgKepG8dPB94C+rp7zX6erwTYcAivKRXYdgjbRzrtn/3T/mme9tH+hWr/HO3uzfaamz0i192rzewGYA4QA0xz9xVmdgeQ5+6zgEeAJ8wsn7oe/vjAtivM7DlgJVANXL+/wA9sc0hdfTPLc/fcQ3mMSKb9s3/aP83TPtq/cN8/zfb025pw3+Ghpv2zf9o/zdM+2r9w3z86IldEJIpEYuhPDXUBYU77Z/+0f5qnfbR/Yb1/Im54R0REmhaJPX0REWlCxIR+cyeFEzCz9Wa2zMwWm1leqOsJNTObZmZbzWx5vWVdzewNM1sb+H1EKGsMtSb20e1mtinwPlpsZueEssZQMrOeZvaOma0ysxVm9h+B5WH7PoqI0A/ypHBS5zR3HxrOswsOo8eoOxFgfbcCb7l7X+qOK4n2DsRjfHMfAUwJvI+Guvurh7mmcFIN3OLuA4DjgesD2RO276OICH2COymcyNe4+/vUHVdSX/2TB04HLjisRYWZJvaRBLj7Znf/JHB7F7CKuvOLhe37KFJCXyd2C44D/zKzhWY2OdTFhKkj3X0z1P1BA91CXE+4usHMlgaGf8Jm6CKUAtcRGQbMI4zfR5ES+kGd2E04yd2HUzcMdr2ZnRLqgqRNegjoAwwFNgP3hLac0DOzTsDzwE/dfWeo69mfSAn9oE7sFu3cvTjweyvwArq2QWO2mFl3gMDvrSGuJ+y4+xZ3r3H3WuBvRPn7yMziqAv8p9z9n4HFYfs+ipTQXwD0NbNeZhZP3bl/ZoW4prBiZh3NrPOXt4GzgOX73yoqzQIuD9y+HHgphLWEpS/DLOBCovh9FLhY1CPAKne/t96qsH0fRczBWYFpY/fxfyeF+2OISworZtabut491J1o7+lo30dm9gxwKnVnRdwC/BfwIvAckAlsBMa5e9R+kdnEPjqVuqEdB9YD13w5fh1tzOxk4ANgGVAbWPwr6sb1w/J9FDGhLyIizYuU4R0REQmCQl9EJIoo9EVEoohCX0Qkiij0RUSiiEJfRCSKKPRFRKKIQl9EJIr8f6VG9fEiRPb0AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.figure()\n", + "plt.plot(history.history['loss'])\n", + "plt.plot(history.history['val_loss'])\n", + "plt.title('model loss')\n", + "plt.ylabel('loss')\n", + "plt.xlabel('epoch')\n", + "plt.legend(['train', 'validation'])\n", + "plt.show()\n", + "# Accuracy increased a bit, and then started decreasing\n", + "plt.plot(history.history['acc'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Accuracy here is based on number of times model exactly predicted the target labels. It's impossible to come up with exact signal p-values as a prediction even if our models weren't bad and not hastily put together. Important question to ask is whether the model is prediction peaks at places where there are real peaks. Remember the test data set we withheld and never let the model see it? Test data set had both methylation inputs and acetylation outputs for the exact gene regions. Lets see what model predicts for the inputs and compare the prediction to true output:" + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "metadata": {}, + "outputs": [], + "source": [ + "prediction = model.predict(test_features).flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": 236, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20,5))\n", + "plt.plot(prediction.flatten())\n", + "plt.title('Predicted Acetylation')\n", + "plt.show()\n", + "\n", + "# Now true acetylation\n", + "plt.figure(figsize=(19,5))\n", + "plt.plot(test_labels.flatten())\n", + "plt.title('True Acetylation')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hard to see the correlation... Let's zoom in" + ] + }, + { + "cell_type": "code", + "execution_count": 237, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20,5))\n", + "plt.plot(prediction.flatten()[160000:190000])\n", + "plt.title('Predicted Acetylation')\n", + "plt.show()\n", + "\n", + "# Now true acetylation\n", + "plt.figure(figsize=(19,5))\n", + "plt.plot(test_labels.flatten()[160000:190000])\n", + "plt.title('True Acetylation')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model learnt something, but not very well. It's lacking precision and we could have normalized the values. It's bad but not too bad given that we had very small data (chrom1) to train and test with. Normally, we would train on at least three chromosomes, and use two other chromosomes for validation and testing. Here are some interesting questions after this exercise:\n", + "\n", + "- Which chromosomes we should train the model with?\n", + "- What other CNN model structure we could try?\n", + "- Is maxpooling making the model loose resolution?\n", + "- Would more layers help?\n", + "- Would normalizing the data help?\n", + "- What other loss functions can we try? How about metrics?\n", + "- Would data from another histone modification as a joint input help the model performance?\n", + "- Would the sequence data from the refence assembly help the model learn better?\n", + "- We converted the missing values to zeros. Does that mean that there is no signal in truth?\n", + "- How does many zeros affect neural networks or any statistical models trained with mean squared error loss function?\n", + "- What other interesting questions would you add here?\n" + ] + }, + { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}