RepeatdiffSNR.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from numpy.random import seed\n",
    "seed(1337)\n",
    "from tensorflow import set_random_seed\n",
    "set_random_seed(2674)\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib\n",
    "matplotlib.use('Qt4Agg')\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import integrate, interpolate, signal, optimize, stats\n",
    "import cPickle as pickle\n",
    "import lal\n",
    "import keras\n",
    "from keras.models import Sequential, load_model\n",
    "from keras.layers import Dense, Conv2D, MaxPool2D, Dropout, BatchNormalization, Flatten\n",
    "from keras.optimizers import Nadam, SGD\n",
    "from keras.callbacks import ModelCheckpoint\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.model_selection import train_test_split\n",
    "import pyfftw\n",
    "import progressbar\n",
    "import time\n",
    "from sklearn import metrics\n",
    "import itertools\n",
    "np.set_printoptions(edgeitems=30, linewidth=160)\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code is for reading simulated SNe waveforms\n",
    "# This code will apply shift to the waveform \n",
    "# samples so that the waveform will always be in the certre +- user customized percentage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The name of the file that contains the simulated CCSN waveforms\n",
    "filename = './Data/GWdatabase.h5'\n",
    "\n",
    "# Read the simulated CCSN waveforms\n",
    "waveformfile = h5py.File(filename, 'r')\n",
    "\n",
    "\n",
    "# The first level keys of the h5 file\n",
    "reduced_data = waveformfile.keys()[0]\n",
    "waveformfilekey = waveformfile.keys()[1]\n",
    "yeofrho = waveformfile.keys()[2]\n",
    "\n",
    "waveformfamily = []\n",
    "waveformfamily_keys = []\n",
    "\n",
    "# Since there are 1824 different simulated CCSN waveform. \n",
    "# Each of which is saved in a different waveformfile key \n",
    "# So the loop below is to retreive all the keys with which the waveform strain data is accessed,\n",
    "# and save it to waveformfamily.\n",
    "# Each waveform family has 5 different keys, so the second part is to retrieve these 5 keys, and save them\n",
    "# to waveformfamily_keys.\n",
    "\n",
    "for i, key in enumerate(waveformfile[waveformfilekey].keys()):\n",
    "    waveformfamily.append(key)\n",
    "    if i == 0:\n",
    "        for j, _ in enumerate(waveformfile[waveformfilekey][waveformfamily[i]].keys()):\n",
    "            waveformfamily_keys.append(waveformfile[waveformfilekey][waveformfamily[i]].keys()[j])\n",
    "originalSNR = np.array(waveformfile[reduced_data][u'SNR(aLIGOfrom10kpc)'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(108507, 197, 13169, 444)\n"
     ]
    }
   ],
   "source": [
    "# This is to set some parameters for the training.\n",
    "# Since the waveforms are stored in the unit of strain * distan\n",
    "# the waveform amplitudes need to be divided by a distance.\n",
    "\n",
    "# Convection factor between par sec and meters\n",
    "PctMe = lal.PC_SI\n",
    "\n",
    "# The distance the waveform will be divided by, in centimeters\n",
    "Dist = 10.0 * 1e3 * PctMe * 1e2\n",
    "\n",
    "# Since the waveform samples come in different lengths, \n",
    "# so every waveform sample will be set to the longest length.\n",
    "# findmax/findmin is a variable that saves the longest/shortest length of the waveform samples.\n",
    "# k/kmin is the index referring to the longest/shortest waveform sample.\n",
    "findmax = 0\n",
    "k = 0 \n",
    "findmin = 1e10\n",
    "kmin = 0\n",
    "#length = np.zeros(len(waveformfamily))\n",
    "#waveformfamily = [waveformfamily[0]]\n",
    "\n",
    "\n",
    "# Since the waveform contains 1824 waveforms, which are different both in the morophology and the duration,\n",
    "# training a network with all these waveforms may make it hard to debug. So one may want to limit the variation\n",
    "# in the waveform samples by limiting the number of waveform samples put in the training. \n",
    "no_waves_considered = 500#1824\n",
    "for i in range(len(waveformfamily[0:no_waves_considered])):\n",
    "    waveformnumber = i\n",
    "\n",
    "    ts = np.array(waveformfile[waveformfilekey][waveformfamily[waveformnumber]][u't-tb(s)']) \n",
    "    #waves = np.array(waveforms[waveformkey][waveformfamily[waveformnumber]][u'strain*dist(cm)']) / Dist \n",
    "    if findmax < len(ts):\n",
    "        findmax = len(ts)\n",
    "        k = i\n",
    "    if findmin > len(ts):\n",
    "        findmin = len(ts)\n",
    "        kmin = i\n",
    "\n",
    "print(findmax, k, findmin, kmin)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The simulated waveforms are sampled with a sampling rate equal to 65535 Hz, \n",
    "# coupled with the longest waveform is ~1.66s, this makes the longest waveform contains 1e5 elements. \n",
    "# Since this code will make other waveforms the same length as the longest length, this requires huge amount of memory,\n",
    "# and makes training very slow and difficult. \n",
    "# Therefore, this codes uses scipy.signal.decimate to down sample the waveforms\n",
    "\n",
    "\n",
    "def padandextractwave(waveformfile, waveformfilekey, waveformfamily, strainkey, wavemaxlength, Dist, no_waves_considered, R):\n",
    "    # Number of simulated waveforms considered\n",
    "    noofwaves = len(waveformfamily[0:no_waves_considered])\n",
    "    \n",
    "    msg = 'Reading waveforms from file and downsampling them by a factor of %s............' %(R)\n",
    "    print(msg)\n",
    "    bar = progressbar.ProgressBar(max_value = no_waves_considered)\n",
    "    \n",
    "    # downsample factor, the downsampled waveform will have length = original length / R\n",
    "    \n",
    "    # Vector used to save the downsampled waveform\n",
    "    downsampled_waveforms = np.array([np.zeros(wavemaxlength / R) for i in range(noofwaves)])\n",
    "    \n",
    "    for i, whichsimulation in enumerate(waveformfamily[0:no_waves_considered]):\n",
    "        \n",
    "        # convert the unit of the waveform from strain*distance to strain\n",
    "        wave = np.array(waveformfile[waveformfilekey][whichsimulation][strainkey]) / Dist\n",
    "        wavelength = len(wave)\n",
    "        \n",
    "        # Pad the waveform with zero so that it has the same length as the longest waveform, \n",
    "        # or whatever length is set by wavemaxlength\n",
    "        temporary = np.pad(wave, (0, wavemaxlength - wavelength), 'constant', constant_values = 0)\n",
    "        \n",
    "        # down sample\n",
    "        downsampled_waveforms[i] = signal.decimate(temporary, R, ftype='iir')\n",
    "        bar.update(i + 1)\n",
    "        \n",
    "    return downsampled_waveforms\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "                                                                               \r",
      "\r",
      "N/A% (0 of 500) |                        | Elapsed Time: 0:00:00 ETA:  --:--:--"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading waveforms from file and downsampling them by a factor of 8............\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100% (500 of 500) |######################| Elapsed Time: 0:00:52 ETA:  00:00:00"
     ]
    }
   ],
   "source": [
    "\n",
    "# Since the original longest waveform length may not be dividable by the down sample vector, \n",
    "# this is to ensure that the length will be dividable. \n",
    "R = 8\n",
    "findmax = 108512\n",
    "\n",
    "findmax = np.ceil(findmax/8.0) * 8\n",
    "\n",
    "# the assumed observation/simulation duration for every waveform \n",
    "Tobs = findmax / 65535.0\n",
    "#start = time.time()\n",
    "SNewaves = padandextractwave(waveformfile, waveformfilekey, waveformfamily, u'strain*dist(cm)', int(findmax), Dist, no_waves_considered, R)\n",
    "#elapsed = time.time() - start\n",
    "#print(elapsed)\n",
    "# Using the downsampled waveform to compute the new sampling rate\n",
    "New_sr = (len(SNewaves[0]) - 1) / Tobs\n",
    "# the new spacing in time\n",
    "New_dt = 1.0 / New_sr\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ASDtxt(x):\n",
    "    \"\"\"This function reads the following noise curves given a detector name.\"\"\"\n",
    "    return {\n",
    "        'LET':'./ASD/ET_D.txt',\n",
    "        'LCE':'./ASD/CE.txt',\n",
    "        'H1': './ASD/ligoII_NS.txt',\n",
    "        'L1': './ASD/ligoII_NS.txt',\n",
    "        'V1': './ASD/virgoII.txt',\n",
    "        'I2': './ASD/ligoII_NS.txt',\n",
    "        'KAGRA': './ASD/ligoII_NS.txt',\n",
    "        'ET_1': './ASD/ET_D.txt',\n",
    "        'ET_2': './ASD/ET_D.txt',\n",
    "        'ET_3': './ASD/ET_D.txt',\n",
    "        'A2': './ASD/ligoII_NS.txt',\n",
    "        'A2.5': './ASD/ligoII_NS.txt',\n",
    "    }[x]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readnos(detector, f_points):\n",
    "    \"\"\"This function interpolates the noise given the frequency samples.\"\"\"\n",
    "    nos_file = ASDtxt(detector)\n",
    "    f_str = []\n",
    "    ASD_str = []\n",
    "    file = open(nos_file, 'r')\n",
    "    readFile = file.readlines()\n",
    "    file.close()\n",
    "    f = []\n",
    "    ASD = []\n",
    "    \n",
    "    for line in readFile:\n",
    "        p = line.split()\n",
    "        f_str.append(float(p[0]))\n",
    "        ASD_str.append(float(p[1]))\n",
    "    f = np.log10(np.array(f_str))\n",
    "    ASD = np.log10(np.array(ASD_str))\n",
    "    nosinterpolate = interpolate.splrep(f, ASD, w=1.0*np.ones(len(ASD)), s=0)\n",
    "    \n",
    "    nos = interpolate.splev(np.log10(f_points), nosinterpolate, der = 0, ext = 3)\n",
    "    nos = 10**nos\n",
    "    \n",
    "    return nos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def noisegenerator(Tobs, det, SR, df, dt):\n",
    "    \"\"\"This function generates noise based on amplitude spectral density\"\"\"\n",
    "    \n",
    "    # The number of time stamps\n",
    "    Ns = Tobs * SR \n",
    "    \n",
    "    # The number of the frequency samples\n",
    "    Nf = int(Ns // 2 + 1)\n",
    "    \n",
    "    # The frequency sample\n",
    "    fs = np.arange(Nf) * df\n",
    "    \n",
    "    # read ASD\n",
    "    ASD = readnos(det, fs)\n",
    "    #plt.loglog(fs, ASD)\n",
    "    #plt.show()\n",
    "    #dd\n",
    "    \n",
    "    PSD = ASD ** 2\n",
    "    # scale the ASD by the observation time, and this will be the highest amplitude of the generated noise\n",
    "    Amp = np.sqrt(0.25 * Tobs * PSD)\n",
    "    \n",
    "    \n",
    "    idx = np.argwhere(PSD==0.0)\n",
    "    Amp[idx] = 0.0\n",
    "    \n",
    "    real_nos = Amp * np.random.normal(0.0, 1.0, Nf)\n",
    "    img_nos = Amp * np.random.normal(0.0, 1.0, Nf)\n",
    "    \n",
    "    # This is to ensure there is no strange behaviour from noise at low frequency.\n",
    "    # This is because the interpolation function will interpolate strange values at frequencies betweem 1 - 10Hz.\n",
    "    #low_cutoff = 20\n",
    "    #high_cutoff = 2048\n",
    "    \n",
    "    #idx_1 =  int(low_cutoff/df)\n",
    "    #real_nos[0:idx_1] = 0\n",
    "    #img_nos[0:idx_1] = 0\n",
    "    #idx_2 = int(high_cutoff/df)\n",
    "    #real_nos[idx_2:] = 0\n",
    "    #img_nos[idx_2:] = 0\n",
    "    \n",
    "    nos = real_nos + 1j * img_nos\n",
    "\n",
    "    \n",
    "    # Fourier transiform converts the generated noise to the tme domain\n",
    "    fftinput = pyfftw.empty_aligned(len(nos), dtype='complex128')\n",
    "    \n",
    "    fft_object = pyfftw.builders.irfft(fftinput)\n",
    "\n",
    "    nos_realization = Ns* fft_object(nos) * df\n",
    "\n",
    "    return ASD, nos_realization, fs\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SNR_calculator(waves_in_time_domain, dt, Det):\n",
    "    \n",
    "    length = len(waves_in_time_domain)\n",
    "    \n",
    "    df = 1.0 / (length * dt)\n",
    "    \n",
    "    Nf = int((length // 2 + 1))\n",
    "    \n",
    "    fftinput_for_snr = pyfftw.empty_aligned(length, dtype='complex128')     \n",
    "    fft_object_for_snr = pyfftw.builders.rfft(fftinput_for_snr)      \n",
    "     \n",
    "    # frequency samples\n",
    "    fs = np.arange(Nf) * df\n",
    "    \n",
    "    # Amplitude spectral density\n",
    "    ASD = readnos(Det, fs)\n",
    "        \n",
    "    temporary_wave_in_f = fft_object_for_snr(waves_in_time_domain) * dt\n",
    "    \n",
    "    snr = np.sqrt( 4.0 * sum( abs(temporary_wave_in_f) ** 2 / ASD ** 2 ) * df )\n",
    "    \n",
    "    return snr\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rescale_to_set_SNR(preset_SNR, SNewaves, dt, Det):\n",
    "    \n",
    "    df = 1.0 / (len(SNewaves[0]) * dt)\n",
    "    fftinput_for_snr = pyfftw.empty_aligned(len(SNewaves[0]), dtype='complex128')     \n",
    "    fft_object_for_snr = pyfftw.builders.rfft(fftinput_for_snr)      \n",
    "    \n",
    "    Nf = int((len(SNewaves[0]) // 2 + 1))\n",
    "    \n",
    "    # frequency samples\n",
    "    fs = np.arange(Nf) * df\n",
    "    \n",
    "    # Amplitude spectral density\n",
    "    ASD = readnos(Det, fs)\n",
    "    msg = 'Rescaling the amplitude of the waveforms so that their optimal SNR is %s.........' %(preset_SNR)\n",
    "    print(msg)\n",
    "    print(\" \")\n",
    "    bar = progressbar.ProgressBar(max_value = len(SNewaves))\n",
    "    \n",
    "    for i, wave in enumerate(SNewaves):\n",
    "        temporary_wave_in_f = fft_object_for_snr(wave) * dt\n",
    "        temporary_snr = np.sqrt( 4.0 * sum( abs(temporary_wave_in_f) ** 2 / ASD ** 2 ) * df )\n",
    "        SNR_factor = preset_SNR / temporary_snr\n",
    "    \n",
    "        SNewaves[i] = SNR_factor * wave\n",
    "        #print(temporary_snr)\n",
    "        #print(  np.sqrt(4.0 * sum(abs(fft_object_for_snr(SNewaves[i]) * dt) **2 / ASD ** 2) * df))\n",
    "        bar.update(i)\n",
    "    \n",
    "    return SNewaves\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_generator(seed, ts, dt, Sr, percentage, Det, SNewaves, N_rz, multiplication):\n",
    "    \"\"\"This function generates the data for training/validation/testing.\"\"\"\n",
    "    \n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    # The number of sample will be equal to the number of N_rz(noise realizations)\n",
    "    data = np.array([np.zeros_like(ts) for i in range(N_rz)])\n",
    "    \n",
    "    # Signal to noise ratio\n",
    "    #SNR = np.zeros(N_rz)\n",
    "    \n",
    "    # Number of time stamps\n",
    "    Ns = len(ts)\n",
    "    \n",
    "    # Number of frequency samples\n",
    "    Nf = int(Ns //2 + 1)\n",
    "    \n",
    "    # Observation time\n",
    "    Tobs = ts[-1] + dt\n",
    "    \n",
    "    # spacing in the frequency domain\n",
    "    df = 1.0/Tobs\n",
    "    # frequency samples\n",
    "    fs = np.arange(Nf) * df\n",
    "    \n",
    "    # Amplitude spectral density\n",
    "    ASD = readnos(Det, fs)\n",
    "    \n",
    "    \n",
    "    toolbar_width = N_rz\n",
    "\n",
    "    \n",
    "    \n",
    "    msg = 'Generating noise realizations.......'\n",
    "    print(msg)\n",
    "    print(\" \")\n",
    "    # setup toolbar\n",
    "    bar = progressbar.ProgressBar(max_value=toolbar_width)\n",
    "    \n",
    "\n",
    "    \n",
    "    # Generate noise\n",
    "    for i in range(N_rz):\n",
    "        #if (i+1) % 1000 == 0 & i != N_rz - 1:\n",
    "        #   msg = 'The %s th to %s th noise realizations are now being generated.' %(i+1, i+1000)\n",
    "        #    print(msg)\n",
    "        _, data[i], _ = noisegenerator(Tobs, Det, Sr, df, dt)\n",
    "        bar.update(i+1)\n",
    "\n",
    "\n",
    "\n",
    "    msg = 'Adding noise to signals and converting them back to the time domain after whitening them in the frequency domain.....'\n",
    "    print(msg)\n",
    "    print(\" \")\n",
    "    bar_2 = progressbar.ProgressBar(max_value=toolbar_width)\n",
    "    \n",
    "    \n",
    "    if ts[-1] == signal_duration:   \n",
    "\n",
    "        for i in range(multiplication):\n",
    "            for j in range(len(SNewaves)):\n",
    "\n",
    "                count = i * len(SNewaves) + j\n",
    "                #if (count + 1) % 1000 == 0 and count < 4999:\n",
    "                #    msg = 'The %s th to %s th samples of the data set are now being generated.' %(count + 1,count + 1000)\n",
    "                #    print(msg)\n",
    "                data[count] += SNewaves[j]\n",
    "\n",
    "\n",
    "                fftinput_1 = pyfftw.empty_aligned(len(data[count]), dtype='complex128')\n",
    "                fft_object_1 = pyfftw.builders.rfft(fftinput_1)\n",
    "                temporary = fft_object_1(data[count]) * 1.0/Sr\n",
    "                temporary = temporary / ASD \n",
    "\n",
    "\n",
    "                #SNR[count] = np.sqrt(4.0 * sum(abs(temporary[int(100/df): int(500/df)]) ** 2 * df))\n",
    "                #SNR_factor = SNR_set / SNR[count]\n",
    "                #temporary = temporary * SNR_factor\n",
    "                #if SNR_factor > 1:\n",
    "                #    print(SNR_factor,count) \n",
    "                #print(SNR_factor, np.sqrt(4.0 * sum(abs(temporary) ** 2 * df)))\n",
    "                fftinput_2 = pyfftw.empty_aligned(len(temporary), dtype='complex128')\n",
    "                fft_object_2 = pyfftw.builders.irfft(fftinput_2)\n",
    "                data[count] = Ns * fft_object_2(temporary) * df * np.sqrt(2.0/ Sr)\n",
    "                bar_2.update( count + 1)\n",
    "    elif ts[-1] > signal_duration:\n",
    "        for i in range(multiplication):\n",
    "            for j in range(len(SNewaves)):\n",
    "\n",
    "                count = i * len(SNewaves) + j\n",
    "                #if (count + 1) % 1000 == 0 and count < 4999:\n",
    "                #    msg = 'The %s th to %s th samples of the data set are now being generated.' %(count + 1,count + 1000)\n",
    "                #    print(msg)\n",
    "                # This is to draw a random and determine     \n",
    "                random_shift_percentage = np.random.uniform(-percentage, percentage)\n",
    "                original_starting_point = sample_length / 2 - signal_length / 2\n",
    "                shifted_starting_point = int(original_starting_point * (1 + random_shift_percentage))\n",
    "                \n",
    "                data[count][shifted_starting_point: shifted_starting_point + signal_length] = data[count][shifted_starting_point: shifted_starting_point + signal_length] + SNewaves[j]\n",
    "        \n",
    "                fftinput_1 = pyfftw.empty_aligned(len(data[count]), dtype='complex128')\n",
    "                fft_object_1 = pyfftw.builders.rfft(fftinput_1)\n",
    "                temporary = fft_object_1(data[count]) * 1.0 / Sr\n",
    "                temporary = temporary / ASD \n",
    "\n",
    "\n",
    "                #SNR[count] = np.sqrt(4.0 * sum(abs(temporary[int(100/df): int(500/df)]) ** 2 * df))\n",
    "                #SNR_factor = SNR_set / SNR[count]\n",
    "                #temporary[int(100/df): int(500/df)] = temporary[int(100/df): int(500/df)] * SNR_factor\n",
    "                \n",
    "                #if SNR_factor > 1:\n",
    "                #    print(SNR_factor,count) \n",
    "                #print(SNR_factor, np.sqrt(4.0 * sum(abs(temporary) ** 2 * df)))\n",
    "                \n",
    "                fftinput_2 = pyfftw.empty_aligned(len(temporary), dtype='complex128')\n",
    "                fft_object_2 = pyfftw.builders.irfft(fftinput_2)\n",
    "                data[count] = Ns * fft_object_2(temporary) * df * np.sqrt(2.0/ Sr)\n",
    "                bar_2.update( count + 1 )\n",
    "    else:\n",
    "        raise Exception('The sample length should be longer than or equal to the signal length') \n",
    "\n",
    "            \n",
    "    for i in range(multiplication * len(SNewaves), N_rz):\n",
    "        fftinput_1 = pyfftw.empty_aligned(len(data[i]), dtype='complex128')\n",
    "        fft_object_1 = pyfftw.builders.rfft(fftinput_1)\n",
    "        temporary = fft_object_1(data[i]) *  1.0 / Sr \n",
    "        temporary = temporary / ASD \n",
    "        \n",
    "        fftinput_2 = pyfftw.empty_aligned(len(temporary), dtype='complex128')\n",
    "        fft_object_2 = pyfftw.builders.irfft(fftinput_2)\n",
    "        data[i] = Ns * fft_object_2(temporary) * df * np.sqrt(2.0/ Sr)\n",
    "        bar_2.update(i + 1)\n",
    "            \n",
    "            \n",
    "    return data #SNR\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def whiten_data(not_whitened_data_in_time_domain, ASD, dt, SR):\n",
    "    \n",
    "    num = len(not_whitened_data_in_time_domain)\n",
    "    signal_len = len(not_whitened_data_in_time_domain[0])\n",
    "    \n",
    "    whitened_data = np.array([np.zeros(signal_len ) for i in range(num)])\n",
    "    fftinput_in_td = pyfftw.empty_aligned(signal_len, dtype='complex128')\n",
    "    fft_object_to_f = pyfftw.builders.rfft(fftinput_in_td)\n",
    "    \n",
    "    \n",
    "    fftinput_in_fd = pyfftw.empty_aligned(signal_len//2 + 1, dtype='complex128')\n",
    "    fft_object_to_t = pyfftw.builders.irfft(fftinput_in_fd)\n",
    "    \n",
    "    for i, nwd in enumerate(not_whitened_data_in_time_domain):\n",
    "        temp = fft_object_to_f(nwd) * dt / ASD\n",
    "        whitened_data[i] = fft_object_to_t(temp) * np.sqrt(2.0/ SR) / dt\n",
    "        \n",
    "    \n",
    "    return whitened_data \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the time stamps \n",
    "signal_length = len(SNewaves[0])\n",
    "signal_duration = (signal_length - 1) * New_dt\n",
    "\n",
    "# applying pad to make the sample longer. This is for the purpose of shifting the signal, so that the signal will appear to be in the centre +- user customised percentage\n",
    "# If no padding is to be applied\n",
    "sample_length = signal_length * 1.0\n",
    "\n",
    "# time stamps after pad\n",
    "ts = np.arange(sample_length) * New_dt\n",
    "sample_duration = ts[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shuffle_data(sample, label,  shuffle_times, seed):\n",
    "    np.random.seed(seed)\n",
    "    for i in range(shuffle_times):\n",
    "        state = np.random.randint(0,100)\n",
    "        sample, label = shuffle(sample, label, random_state=state)\n",
    "        \n",
    "    return sample, label\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_data(sample, label, savefortest, presence, shuffled, tv_split):\n",
    "    \n",
    "    data_size = len(sample) \n",
    "    \n",
    "    \n",
    "    if shuffled == True:\n",
    "        split_point = int((data_size - 2 * savefortest) * tv_split)\n",
    "        train_sample = sample[0 : split_point] \n",
    "        train_label = label[0 : split_point]\n",
    "        \n",
    "        val_sample = sample[split_point : data_size - 2 * savefortest]\n",
    "        val_label = label[split_point : data_size - 2 * savefortest]\n",
    "    \n",
    "        test_sample = sample[data_size - 2 * savefortest : ]\n",
    "        test_label = label[data_size - 2 * savefortest : ]\n",
    "\n",
    "    else:\n",
    "\n",
    "        nos_portion = (data_size - presence - savefortest)/2\n",
    "        nos_start = presence\n",
    "\n",
    "        \n",
    "        train_start_index_signal = 0\n",
    "        train_end_index_signal = (presence - savefortest) / 2\n",
    "\n",
    "        train_start_index_noise = nos_start\n",
    "        train_end_index_noise = nos_start + nos_portion\n",
    "\n",
    "\n",
    "        val_start_index_signal = train_end_index_signal\n",
    "        val_end_index_signal = presence - savefortest\n",
    "\n",
    "        val_start_index_noise = train_end_index_noise\n",
    "        val_end_index_noise = train_end_index_noise + nos_portion\n",
    "\n",
    "\n",
    "        test_start_index_signal = val_end_index_signal\n",
    "        test_end_index_signal =  val_end_index_signal + savefortest\n",
    "\n",
    "        test_start_index_noise = val_end_index_noise\n",
    "        test_end_index_noise =  val_end_index_noise + savefortest\n",
    "\n",
    "    \n",
    "        train_sample = np.concatenate((data[train_start_index_signal:train_end_index_signal], \n",
    "                                       data[train_start_index_noise:train_end_index_noise]))\n",
    "\n",
    "        train_label = np.concatenate((np.ones(train_end_index_signal - train_start_index_signal), \n",
    "                                      np.zeros(train_end_index_noise - train_start_index_noise)))\n",
    "\n",
    "        val_sample = np.concatenate((data[val_start_index_signal:val_end_index_signal], \n",
    "                                    data[val_start_index_noise:val_end_index_noise]))\n",
    "\n",
    "        val_label = np.concatenate((np.ones(val_end_index_signal - val_start_index_signal), \n",
    "                                    np.zeros(val_end_index_noise - val_start_index_noise)))\n",
    "\n",
    "        test_sample = np.concatenate((data[test_start_index_signal : test_end_index_signal], \n",
    "                                     data[test_start_index_noise : test_end_index_noise]))\n",
    "\n",
    "        test_label = np.concatenate((np.ones(test_end_index_signal - test_start_index_signal), \n",
    "                                    np.zeros(test_end_index_noise - test_start_index_noise)))\n",
    "        \n",
    "        #print(train_start_index_signal,train_end_index_signal, train_start_index_noise , train_end_index_noise, \n",
    "        #      val_start_index_signal, val_end_index_signal, val_start_index_noise, val_end_index_noise,\n",
    "        #      test_start_index_signal, test_end_index_signal, test_start_index_noise, test_end_index_noise)\n",
    "    return train_sample, train_label, val_sample, val_label, test_sample, test_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reshape_data(train_sample, train_label, val_sample, val_label, test_sample, test_label, num_classes):\n",
    "    \n",
    "    \n",
    "    number_of_sample_for_training = len(train_sample)\n",
    "    number_of_sample_for_testing = len(test_sample)\n",
    "    number_of_sample_for_validation = len(val_sample)\n",
    "    training_sample_length = len(train_sample[0])\n",
    "\n",
    "    train_sample = train_sample.reshape(number_of_sample_for_training, 1, training_sample_length)\n",
    "    test_sample = test_sample.reshape(number_of_sample_for_testing, 1, training_sample_length)\n",
    "    val_sample = val_sample.reshape(number_of_sample_for_validation, 1, training_sample_length)\n",
    "    \n",
    "    training_sample_length = len(train_sample[0][0])\n",
    "\n",
    "    train_sample = train_sample.reshape(-1, 1, 1, training_sample_length)\n",
    "    val_sample = val_sample.reshape(-1, 1, 1, training_sample_length)\n",
    "    test_sample = test_sample.reshape(-1, 1, 1, training_sample_length)\n",
    "\n",
    "    input_shape = train_sample.shape[1:] \n",
    "    \n",
    "    train_label = keras.utils.to_categorical(train_label , num_classes)\n",
    "    val_label = keras.utils.to_categorical(val_label, num_classes)\n",
    "    test_label = keras.utils.to_categorical(test_label, num_classes)\n",
    "    \n",
    "    return train_sample, train_label, val_sample, val_label, test_sample, test_label, input_shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.backend.set_image_data_format('channels_first')\n",
    "def make_model(input_shape, num_classes):\n",
    "    model = Sequential()    # define the type of keras model\n",
    "\n",
    "    # add the layers\n",
    "    # conv1\n",
    "    model.add(Conv2D(8, (1,64), activation='elu', input_shape=input_shape))\n",
    "    # maxpool2\n",
    "    model.add(MaxPool2D((1,8)))\n",
    "    # conv2\n",
    "    model.add(Conv2D(16, (1,16), activation='elu'))\n",
    "    # maxpool2\n",
    "    model.add(MaxPool2D((1,6)))\n",
    "    # the input the fully connected layer must be 1-D vector\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(32, activation='elu'))\n",
    "    #model.add(Dropout(0.5))\n",
    "    dol = keras.layers.Dropout(0.5, noise_shape=None, seed=10)\n",
    "\n",
    "    model.add(dol)\n",
    "    # add the output layer with softmax actiavtion for classication\n",
    "    model.add(Dense(num_classes, activation='softmax'))\n",
    "    # print a summary\n",
    "    model.summary()\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_at_SNR = [8, 9, 10]\n",
    "repeated = 20\n",
    "shift_percentage = 0.0\n",
    "Det = 'H1'\n",
    "seed = 10\n",
    "N_rz = 20000\n",
    "tv_split = 0.8\n",
    "savefortest  = 100\n",
    "batch_size = 30      # number of time series per batch\n",
    "num_classes = 2      # signal or background\n",
    "epochs = 20          # number of full passes of the dataset\n",
    "outdir = './results' # directory to store results in\n",
    "\n",
    "def mass_train(Original_waves, dt, sr, seed, ts, shift, Det, N_rz, repeated, shuffle_times, seed_s, savefortest, tv_split, train_at_SNR, num_classes):\n",
    "    presence = len(Original_waves) * repeated\n",
    "    history_saver = []\n",
    "    for train_SNR in train_at_SNR:\n",
    "        Original_waves = rescale_to_set_SNR(train_SNR, Original_waves, dt, Det)\n",
    "\n",
    "        # Number of noise realization. This will be the final number of data samples for training + validation + testing\n",
    "        data = data_generator(seed, ts, dt, sr, shift, Det, Original_waves, N_rz, repeated)\n",
    "        label = np.concatenate((np.ones(presence), np.zeros(N_rz - presence)))\n",
    "\n",
    "        sample, label = shuffle_data(data, label,  shuffle_times, seed_s)\n",
    "        train_sample, train_label, val_sample, val_label, test_sample, test_label = split_data(sample, label, savefortest, presence, True, tv_split)\n",
    "        \n",
    "\n",
    "        train_sample, train_label, val_sample, val_label, test_sample, test_label, input_shape = reshape_data(train_sample, train_label, val_sample, val_label, test_sample, test_label, num_classes)\n",
    "\n",
    "        \"\"\"Below is the CNN part of this code\"\"\" \n",
    "        if 'model' in locals():\n",
    "            del model\n",
    "        \n",
    "        model = make_model(input_shape, num_classes)\n",
    "\n",
    "\n",
    "        # compile the model\n",
    "        #adam = keras.optimizers.Adam(lr=0.01)\n",
    "        model.compile(loss='categorical_crossentropy', optimizer= Nadam(), metrics=['accuracy'])\n",
    "\n",
    "        # save the model each epoch if it is the best so far\n",
    "        filename = '{0}/best_weights_for_SNR%s.hdf5'%(train_SNR)\n",
    "        modelCheck = ModelCheckpoint(filename.format(outdir), monitor='val_acc', verbose=0, save_best_only=True,save_weights_only=True, mode='auto', period=0)\n",
    "\n",
    "        history = model.fit(train_sample, train_label, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(val_sample, val_label), callbacks = [modelCheck], shuffle = False)\n",
    "        history_saver.append(history)\n",
    "    return model, history_saver, data, train_sample, train_label, val_sample, val_label, test_sample, test_label\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  6% (30 of 500) |#                      | Elapsed Time: 0:00:00 ETA:   0:00:01"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rescaling the amplitude of the waveforms so that their optimal SNR is 8.........\n",
      " \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0% (10 of 20000) |                     | Elapsed Time: 0:00:00 ETA:   0:03:30"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating noise realizations.......\n",
      " \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0% (33 of 20000) |                     | Elapsed Time: 0:00:00 ETA:   0:01:01"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding noise to signals and converting them back to the time domain after whitening them in the frequency domain.....\n",
      " \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99% (19986 of 20000) |################# | Elapsed Time: 0:00:56 ETA:   0:00:00"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_1 (Conv2D)            (None, 8, 1, 13501)       520       \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 8, 1, 1687)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 16, 1, 1672)       2064      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_2 (MaxPooling2 (None, 16, 1, 278)        0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 4448)              0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 32)                142368    \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 2)                 66        \n",
      "=================================================================\n",
      "Total params: 145,018\n",
      "Trainable params: 145,018\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 15840 samples, validate on 3960 samples\n",
      "Epoch 1/20\n",
      "15840/15840 [==============================] - 11s 694us/step - loss: 0.6722 - acc: 0.6572 - val_loss: 0.4199 - val_acc: 0.8101\n",
      "Epoch 2/20\n",
      "15840/15840 [==============================] - 8s 532us/step - loss: 0.3905 - acc: 0.8268 - val_loss: 0.3693 - val_acc: 0.8384\n",
      "Epoch 3/20\n",
      "15840/15840 [==============================] - 8s 521us/step - loss: 0.3008 - acc: 0.8744 - val_loss: 0.3387 - val_acc: 0.8581\n",
      "Epoch 4/20\n",
      "15840/15840 [==============================] - 8s 517us/step - loss: 0.2300 - acc: 0.9049 - val_loss: 0.2891 - val_acc: 0.8773\n",
      "Epoch 5/20\n",
      "15840/15840 [==============================] - 8s 518us/step - loss: 0.1787 - acc: 0.9297 - val_loss: 0.2892 - val_acc: 0.8871\n",
      "Epoch 6/20\n",
      "15840/15840 [==============================] - 8s 518us/step - loss: 0.1443 - acc: 0.9429 - val_loss: 0.2781 - val_acc: 0.9000\n",
      "Epoch 7/20\n",
      "15840/15840 [==============================] - 8s 521us/step - loss: 0.1141 - acc: 0.9554 - val_loss: 0.2689 - val_acc: 0.9101\n",
      "Epoch 8/20\n",
      "15840/15840 [==============================] - 8s 508us/step - loss: 0.1010 - acc: 0.9636 - val_loss: 0.2259 - val_acc: 0.9265\n",
      "Epoch 9/20\n",
      "15840/15840 [==============================] - 8s 503us/step - loss: 0.0886 - acc: 0.9681 - val_loss: 0.2525 - val_acc: 0.9210\n",
      "Epoch 10/20\n",
      "15840/15840 [==============================] - 8s 503us/step - loss: 0.0798 - acc: 0.9714 - val_loss: 0.2415 - val_acc: 0.9285\n",
      "Epoch 11/20\n",
      "15840/15840 [==============================] - 8s 502us/step - loss: 0.0724 - acc: 0.9720 - val_loss: 0.2001 - val_acc: 0.9434\n",
      "Epoch 12/20\n",
      "15840/15840 [==============================] - 8s 499us/step - loss: 0.0716 - acc: 0.9745 - val_loss: 0.2216 - val_acc: 0.9391\n",
      "Epoch 13/20\n",
      "15840/15840 [==============================] - 8s 512us/step - loss: 0.0671 - acc: 0.9764 - val_loss: 0.2022 - val_acc: 0.9412\n",
      "Epoch 14/20\n",
      "15840/15840 [==============================] - 9s 547us/step - loss: 0.0593 - acc: 0.9785 - val_loss: 0.1829 - val_acc: 0.9442\n",
      "Epoch 15/20\n",
      "15840/15840 [==============================] - 8s 497us/step - loss: 0.0569 - acc: 0.9795 - val_loss: 0.2038 - val_acc: 0.9462\n",
      "Epoch 16/20\n",
      "15840/15840 [==============================] - 8s 498us/step - loss: 0.0527 - acc: 0.9818 - val_loss: 0.2296 - val_acc: 0.9508\n",
      "Epoch 17/20\n",
      "15840/15840 [==============================] - 8s 523us/step - loss: 0.0510 - acc: 0.9815 - val_loss: 0.1815 - val_acc: 0.9505\n",
      "Epoch 18/20\n",
      "15840/15840 [==============================] - 8s 495us/step - loss: 0.0502 - acc: 0.9814 - val_loss: 0.2140 - val_acc: 0.9487\n",
      "Epoch 19/20\n",
      "15840/15840 [==============================] - 8s 498us/step - loss: 0.0483 - acc: 0.9827 - val_loss: 0.2859 - val_acc: 0.9460\n",
      "Epoch 20/20\n",
      "15840/15840 [==============================] - 8s 495us/step - loss: 0.0465 - acc: 0.9849 - val_loss: 0.2688 - val_acc: 0.9343\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4% (24 of 500) |#                      | Elapsed Time: 0:00:00 ETA:   0:00:02"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rescaling the amplitude of the waveforms so that their optimal SNR is 9.........\n",
      " \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 96% (481 of 500) |##################### | Elapsed Time: 0:00:02 ETA:   0:00:00"
     ]
    }
   ],
   "source": [
    "model, history_saver, data, train_sample, train_label, val_sample, val_label, test_sample, test_label = mass_train(SNewaves, New_dt, New_sr, 150, ts, shift_percentage, 'H1', N_rz, repeated, 2, 100, savefortest, tv_split, train_at_SNR, num_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<keras.callbacks.History at 0x7f657bc028d0>,\n",
       " <keras.callbacks.History at 0x7f657aecbe50>]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_13 (Conv2D)           (None, 8, 1, 13501)       520       \n",
      "_________________________________________________________________\n",
      "max_pooling2d_13 (MaxPooling (None, 8, 1, 1687)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_14 (Conv2D)           (None, 16, 1, 1672)       2064      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_14 (MaxPooling (None, 16, 1, 278)        0         \n",
      "_________________________________________________________________\n",
      "flatten_7 (Flatten)          (None, 4448)              0         \n",
      "_________________________________________________________________\n",
      "dense_13 (Dense)             (None, 32)                142368    \n",
      "_________________________________________________________________\n",
      "dropout_7 (Dropout)          (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_14 (Dense)             (None, 2)                 66        \n",
      "=================================================================\n",
      "Total params: 145,018\n",
      "Trainable params: 145,018\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "del model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_9 (Conv2D)            (None, 16, 1, 13501)      1040      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_9 (MaxPooling2 (None, 16, 1, 1687)       0         \n",
      "_________________________________________________________________\n",
      "conv2d_10 (Conv2D)           (None, 16, 1, 1672)       4112      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_10 (MaxPooling (None, 16, 1, 278)        0         \n",
      "_________________________________________________________________\n",
      "flatten_5 (Flatten)          (None, 4448)              0         \n",
      "_________________________________________________________________\n",
      "dense_9 (Dense)              (None, 8)                 35592     \n",
      "_________________________________________________________________\n",
      "dropout_5 (Dropout)          (None, 8)                 0         \n",
      "_________________________________________________________________\n",
      "dense_10 (Dense)             (None, 2)                 18        \n",
      "=================================================================\n",
      "Total params: 40,762\n",
      "Trainable params: 40,762\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()    # define the type of keras model\n",
    "\n",
    "# add the layers\n",
    "# conv1\n",
    "model.add(Conv2D(16, (1,64), activation='elu', input_shape=input_shape))\n",
    "# maxpool2\n",
    "model.add(MaxPool2D((1,8)))\n",
    "\n",
    "\n",
    "model.add(Conv2D(16, (1,16), activation='elu'))\n",
    "# maxpool2\n",
    "model.add(MaxPool2D((1,6)))\n",
    "\n",
    "\n",
    "# the input the fully connected layer must be 1-D vector\n",
    "model.add(Flatten())\n",
    "model.add(Dense(8, activation='elu'))\n",
    "\n",
    "dol = keras.layers.Dropout(0.5, noise_shape=None, seed=10)\n",
    "\n",
    "model.add(dol)\n",
    "# add the output layer with softmax actiavtion for classication\n",
    "model.add(Dense(num_classes, activation='softmax'))\n",
    "# print a summary\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='categorical_crossentropy', optimizer= Nadam(), metrics=['accuracy'])\n",
    "# save the model each epoch if it is the best so far\n",
    "filename = '{0}/best_weights_for_SNR%s.hdf5'%(train_SNR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "modelCheck = ModelCheckpoint(filename.format(outdir), monitor='val_acc', verbose=0, save_best_only=True,save_weights_only=True, mode='auto', period=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 15840 samples, validate on 3960 samples\n",
      "Epoch 1/20\n",
      "15840/15840 [==============================] - 8s 525us/step - loss: 0.6787 - acc: 0.6692 - val_loss: 0.4294 - val_acc: 0.8078\n",
      "Epoch 2/20\n",
      "15840/15840 [==============================] - 8s 486us/step - loss: 0.3866 - acc: 0.8259 - val_loss: 0.3909 - val_acc: 0.8215\n",
      "Epoch 3/20\n",
      "15840/15840 [==============================] - 9s 543us/step - loss: 0.2783 - acc: 0.8825 - val_loss: 0.2779 - val_acc: 0.8818\n",
      "Epoch 4/20\n",
      "15840/15840 [==============================] - 8s 535us/step - loss: 0.1882 - acc: 0.9239 - val_loss: 0.2416 - val_acc: 0.9056\n",
      "Epoch 5/20\n",
      "15840/15840 [==============================] - 8s 521us/step - loss: 0.1379 - acc: 0.9472 - val_loss: 0.2501 - val_acc: 0.9131\n",
      "Epoch 6/20\n",
      "15840/15840 [==============================] - 8s 498us/step - loss: 0.1094 - acc: 0.9588 - val_loss: 0.2131 - val_acc: 0.9245\n",
      "Epoch 7/20\n",
      "15840/15840 [==============================] - 8s 503us/step - loss: 0.0863 - acc: 0.9687 - val_loss: 0.2089 - val_acc: 0.9306\n",
      "Epoch 8/20\n",
      "15840/15840 [==============================] - 8s 506us/step - loss: 0.0747 - acc: 0.9718 - val_loss: 0.2000 - val_acc: 0.9376\n",
      "Epoch 9/20\n",
      "15840/15840 [==============================] - 8s 519us/step - loss: 0.0652 - acc: 0.9768 - val_loss: 0.2274 - val_acc: 0.9381\n",
      "Epoch 10/20\n",
      "15840/15840 [==============================] - 8s 497us/step - loss: 0.0638 - acc: 0.9761 - val_loss: 0.1744 - val_acc: 0.9467\n",
      "Epoch 11/20\n",
      "15840/15840 [==============================] - 8s 493us/step - loss: 0.0557 - acc: 0.9793 - val_loss: 0.1859 - val_acc: 0.9465\n",
      "Epoch 12/20\n",
      "15840/15840 [==============================] - 8s 489us/step - loss: 0.0519 - acc: 0.9816 - val_loss: 0.1948 - val_acc: 0.9500\n",
      "Epoch 13/20\n",
      "15840/15840 [==============================] - 8s 497us/step - loss: 0.0569 - acc: 0.9801 - val_loss: 0.2060 - val_acc: 0.9465\n",
      "Epoch 14/20\n",
      "15840/15840 [==============================] - 8s 493us/step - loss: 0.0438 - acc: 0.9852 - val_loss: 0.2061 - val_acc: 0.9492\n",
      "Epoch 15/20\n",
      "15840/15840 [==============================] - 8s 478us/step - loss: 0.0470 - acc: 0.9844 - val_loss: 0.1933 - val_acc: 0.9490\n",
      "Epoch 16/20\n",
      "15840/15840 [==============================] - 8s 487us/step - loss: 0.0485 - acc: 0.9834 - val_loss: 0.1367 - val_acc: 0.9586\n",
      "Epoch 17/20\n",
      "15840/15840 [==============================] - 8s 489us/step - loss: 0.0419 - acc: 0.9849 - val_loss: 0.1391 - val_acc: 0.9596\n",
      "Epoch 18/20\n",
      "15840/15840 [==============================] - 8s 480us/step - loss: 0.0369 - acc: 0.9878 - val_loss: 0.2102 - val_acc: 0.9581\n",
      "Epoch 19/20\n",
      "15840/15840 [==============================] - 8s 482us/step - loss: 0.0329 - acc: 0.9887 - val_loss: 0.1407 - val_acc: 0.9652\n",
      "Epoch 20/20\n",
      "15840/15840 [==============================] - 8s 476us/step - loss: 0.0338 - acc: 0.9886 - val_loss: 0.1702 - val_acc: 0.9566\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(train_sample, train_label, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(val_sample, val_label), callbacks = [modelCheck], shuffle = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "history = history_saver[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200/200 [==============================] - 0s 216us/step\n",
      "('Test loss:', 0.2781937889289111)\n",
      "('Test accuracy:', 0.954999977350235)\n"
     ]
    }
   ],
   "source": [
    "# load the best model\n",
    "model.load_weights('{0}/best_weights.hdf5'.format(outdir))\n",
    "# evaluate\n",
    "eval_results = model.evaluate(test_sample, test_label,\n",
    "                              sample_weight=None,\n",
    "                              batch_size=batch_size, verbose=1)\n",
    "print('Test loss:', eval_results[0])\n",
    "print('Test accuracy:', eval_results[1])\n",
    "signal_preds = model.predict(test_sample)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "fontsize = 20\n",
    "\n",
    "fig , axs = plt.subplots(2,1, sharex = True)\n",
    "axs = axs.ravel()\n",
    "# plot history\n",
    "axs[0].plot(history.history['loss'], label = 'Loss', linewidth = 2, color = 'b')\n",
    "axs[0].plot(history.history['val_loss'], label = 'Validation Loss', linewidth = 2, color = 'r')\n",
    "axs[1].plot(history.history['acc'], label = 'Accuracy', linewidth = 2, color = 'b')\n",
    "axs[1].plot(history.history['val_acc'], label = 'Validation Accurarcy', linewidth = 2, color = 'r')\n",
    "# set labels\n",
    "axs[0].set_ylabel('Loss', fontsize = fontsize)\n",
    "axs[1].set_xlabel('Epoch', fontsize = fontsize)\n",
    "axs[1].set_ylabel('Acc', fontsize = fontsize)\n",
    "# legends\n",
    "axs[0].legend(fontsize = fontsize)\n",
    "axs[1].legend(fontsize = fontsize)\n",
    "# grids\n",
    "axs[0].grid()\n",
    "axs[1].grid()\n",
    "axs[0].set_xlim([0, epochs])\n",
    "axs[0].set_ylim(bottom = 0)\n",
    "\n",
    "axs[1].set_xlim([0, epochs])\n",
    "axs[1].set_ylim(top = 1)\n",
    "\n",
    "plt.subplots_adjust(left = 0.1, bottom = 0.1, right = 0.90, top = 0.95)\n",
    "for ax in axs:\n",
    "    for tick in ax.xaxis.get_major_ticks():\n",
    "        tick.label1.set_fontsize(fontsize)\n",
    "        tick.label1.set_fontweight('normal')\n",
    "    for tick in ax.yaxis.get_major_ticks():\n",
    "        tick.label1.set_fontsize(fontsize)\n",
    "        tick.label1.set_fontweight('normal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "fa, ta, _ = metrics.roc_curve(test_label[:,1], signal_preds[:,1])\n",
    "fig = plt.figure()\n",
    "plt.plot(fa, ta, linewidth = 2, color = 'b')\n",
    "plt.xlabel('False alarm probability',fontsize = fontsize)\n",
    "plt.ylabel('True alarm probability',fontsize = fontsize)\n",
    "plt.title('ROC curve for SNR %s'%(SNR_set), fontsize = fontsize)\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.subplots_adjust(left = 0.1, bottom = 0.1, right = 0.90, top = 0.95)\n",
    "\n",
    "plt.grid()\n",
    "ax = plt.gca()\n",
    "for tick in ax.xaxis.get_major_ticks():\n",
    "    tick.label1.set_fontsize(fontsize)\n",
    "    tick.label1.set_fontweight('normal')\n",
    "for tick in ax.yaxis.get_major_ticks():\n",
    "    tick.label1.set_fontsize(fontsize)\n",
    "    tick.label1.set_fontweight('normal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}