6 Pretrained Models with CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "# from memory_profiler import memory_usage\n",
    "import os\n",
    "import pandas as pd\n",
    "from glob import glob\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import layers\n",
    "from keras import models\n",
    "from keras.layers.advanced_activations import LeakyReLU\n",
    "from keras.optimizers import Adam\n",
    "import keras.backend as K\n",
    "import librosa\n",
    "import librosa.display\n",
    "import pylab\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import figure\n",
    "import gc\n",
    "# from path import Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import IPython.display as ipd\n",
    "# % pylab inline\n",
    "import os\n",
    "import pandas as pd\n",
    "import librosa\n",
    "import glob \n",
    "import librosa.display\n",
    "import random\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from keras.utils.np_utils import to_categorical\n",
    "\n",
    "import numpy as np\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Activation, Flatten\n",
    "from keras.layers import Convolution2D, MaxPooling2D\n",
    "from keras.optimizers import Adam\n",
    "from keras.utils import np_utils\n",
    "from sklearn import metrics \n",
    "\n",
    "from sklearn.datasets import make_regression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn import metrics\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Dropout \n",
    "from tensorflow.keras.wrappers.scikit_learn import KerasRegressor\n",
    "from keras.models import load_model\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Activation, Flatten\n",
    "from keras.layers import Conv1D, GlobalAveragePooling1D, MaxPooling1D\n",
    "from keras_preprocessing.image import ImageDataGenerator\n",
    "from keras.layers import Dense, Activation, Flatten, Dropout, BatchNormalization\n",
    "from keras.models import Sequential, Model\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "from keras import regularizers, optimizers\n",
    "\n",
    "from keras.callbacks import EarlyStopping\n",
    "\n",
    "from keras import regularizers\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "import os\n",
    "from glob import glob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### First step is to create a picture from the audio file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('./dataset_minor_3000.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename= 'C:/Users/Deepa Kapoor/Data Science/New Project/train_3000_examples/neg16kHz/0RHdUsu2qFMmG4dhpJd1NqM5ZTC2_heavy_1.wav'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" >\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# i = random.choice(data.filename)\n",
    "ipd.Audio(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualizing the melspectrogram "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X, sample_rate = librosa.load(filename, sr=None, res_type='kaiser_fast')\n",
    "S = librosa.feature.melspectrogram(y=X, sr=sample_rate)\n",
    "librosa.display.specshow(librosa.power_to_db(S, ref=np.max), y_axis='linear')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using a function to generate and save the melspectrogram for each audio file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Although this function was modified and many parameteres were explored with, most of it \n",
    "# came from Source 18 (sources in the READ.ME)\n",
    "\n",
    "def images(file):\n",
    "    \n",
    "    # We define the audiofile from the rows of the dataframe when we iterate through\n",
    "    # every row of our dataframe for train, val and test\n",
    "    if(file.corona_test == 'negative'):\n",
    "        audiofile = os.path.join(os.path.abspath('train_3000_examples/neg16kHz')+'/'+str(file.cough_filename))\n",
    "    else:\n",
    "        audiofile = os.path.join(os.path.abspath('train_3000_examples/pos16kHz')+'/'+str(file.cough_filename))\n",
    "    \n",
    "    \n",
    "    # Loading the image with no sample rate to use the original sample rate and\n",
    "    # kaiser_fast to make the speed faster according to a blog post about it (on references)\n",
    "    X, sample_rate = librosa.load(audiofile, sr=None, res_type='kaiser_fast')\n",
    "   \n",
    "    # Setting the size of the image\n",
    "    fig = plt.figure(figsize=[1,1])\n",
    "    \n",
    "    # This is to get rid of the axes and only get the picture \n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.axes.get_xaxis().set_visible(False)\n",
    "    ax.axes.get_yaxis().set_visible(False)\n",
    "    ax.set_frame_on(False)\n",
    "    \n",
    "    # This is the melspectrogram from the decibels with a linear relationship\n",
    "    S = librosa.feature.melspectrogram(y=X, sr=sample_rate)\n",
    "    librosa.display.specshow(librosa.power_to_db(S, ref=np.max), y_axis='linear')\n",
    "    \n",
    "    # Here we choose the path and the name to save the file, we will change the path when\n",
    "    # using the function for train, val and test to make the function easy to use and output\n",
    "    # the images in different folders to use later with a generator\n",
    "    name = file.cough_filename\n",
    "    file  = 'train3000_images/' + str(name) + '.jpg'\n",
    "    \n",
    "    # Here we finally save the image file choosing the resolution \n",
    "    plt.savefig(file, dpi=500, bbox_inches='tight',pad_inches=0)\n",
    "    \n",
    "    # Here we close the image because otherwise we get a warning saying that the image stays\n",
    "    # open and consumes memory\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Although this function was modified and many parameteres were explored with, most of it \n",
    "# came from Source 18 (sources in the READ.ME)\n",
    "\n",
    "def test_images(file):\n",
    "    \n",
    "    # We define the audiofile from the rows of the dataframe when we iterate through\n",
    "    # every row of our dataframe for train, val and test\n",
    "    if(file.corona_test == 'negative'):\n",
    "        audiofile = os.path.join(os.path.abspath('train_3000_examples/neg16kHz')+'/'+str(file.cough_filename))\n",
    "    else:\n",
    "        audiofile = os.path.join(os.path.abspath('train_3000_examples/pos16kHz')+'/'+str(file.cough_filename))\n",
    "    \n",
    "    \n",
    "    # Loading the image with no sample rate to use the original sample rate and\n",
    "    # kaiser_fast to make the speed faster according to a blog post about it (on references)\n",
    "    X, sample_rate = librosa.load(audiofile, sr=None, res_type='kaiser_fast')\n",
    "   \n",
    "    # Setting the size of the image\n",
    "    fig = plt.figure(figsize=[1,1])\n",
    "    \n",
    "    # This is to get rid of the axes and only get the picture \n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.axes.get_xaxis().set_visible(False)\n",
    "    ax.axes.get_yaxis().set_visible(False)\n",
    "    ax.set_frame_on(False)\n",
    "    \n",
    "    # This is the melspectrogram from the decibels with a linear relationship\n",
    "    S = librosa.feature.melspectrogram(y=X, sr=sample_rate)\n",
    "    librosa.display.specshow(librosa.power_to_db(S, ref=np.max), y_axis='linear')\n",
    "    \n",
    "    # Here we choose the path and the name to save the file, we will change the path when\n",
    "    # using the function for train, val and test to make the function easy to use and output\n",
    "    # the images in different folders to use later with a generator\n",
    "    name = file.cough_filename\n",
    "    file  = 'test3000_images/' + str(name) + '.jpg'\n",
    "    \n",
    "    # Here we finally save the image file choosing the resolution \n",
    "    plt.savefig(file, dpi=500, bbox_inches='tight',pad_inches=0)\n",
    "    \n",
    "    # Here we close the image because otherwise we get a warning saying that the image stays\n",
    "    # open and consumes memory\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Although this function was modified and many parameteres were explored with, most of it \n",
    "# came from Source 18 (sources in the READ.ME)\n",
    "\n",
    "def val_images(file):\n",
    "    \n",
    "    # We define the audiofile from the rows of the dataframe when we iterate through\n",
    "    # every row of our dataframe for train, val and test\n",
    "    if(file.corona_test == 'negative'):\n",
    "        audiofile = os.path.join(os.path.abspath('train_3000_examples/neg16kHz')+'/'+str(file.cough_filename))\n",
    "    else:\n",
    "        audiofile = os.path.join(os.path.abspath('train_3000_examples/pos16kHz')+'/'+str(file.cough_filename))\n",
    "    \n",
    "    \n",
    "    # Loading the image with no sample rate to use the original sample rate and\n",
    "    # kaiser_fast to make the speed faster according to a blog post about it (on references)\n",
    "    X, sample_rate = librosa.load(audiofile, sr=None, res_type='kaiser_fast')\n",
    "   \n",
    "    # Setting the size of the image\n",
    "    fig = plt.figure(figsize=[1,1])\n",
    "    \n",
    "    # This is to get rid of the axes and only get the picture \n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.axes.get_xaxis().set_visible(False)\n",
    "    ax.axes.get_yaxis().set_visible(False)\n",
    "    ax.set_frame_on(False)\n",
    "    \n",
    "    # This is the melspectrogram from the decibels with a linear relationship\n",
    "    S = librosa.feature.melspectrogram(y=X, sr=sample_rate)\n",
    "    librosa.display.specshow(librosa.power_to_db(S, ref=np.max), y_axis='linear')\n",
    "    \n",
    "    # Here we choose the path and the name to save the file, we will change the path when\n",
    "    # using the function for train, val and test to make the function easy to use and output\n",
    "    # the images in different folders to use later with a generator\n",
    "    name = file.cough_filename\n",
    "    file  = 'val3000_images/' + str(name) + '.jpg'\n",
    "    \n",
    "    # Here we finally save the image file choosing the resolution \n",
    "    plt.savefig(file, dpi=500, bbox_inches='tight',pad_inches=0)\n",
    "    \n",
    "    # Here we close the image because otherwise we get a warning saying that the image stays\n",
    "    # open and consumes memory\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we load the dataframe and slice the data into train, validation and testing data like before. Again, 3435 for training, 1000 for validation and 1000 for testing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('./dataset_minor_3000.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>corona_test</th>\n",
       "      <th>cough_filename</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>negative</td>\n",
       "      <td>01OCEf1yB4czsq8ygRoT51s96Ba2_heavy_1.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>negative</td>\n",
       "      <td>01OCEf1yB4czsq8ygRoT51s96Ba2_heavy_2.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>negative</td>\n",
       "      <td>01OCEf1yB4czsq8ygRoT51s96Ba2_shallow_1.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>negative</td>\n",
       "      <td>01OCEf1yB4czsq8ygRoT51s96Ba2_shallow_3.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>negative</td>\n",
       "      <td>0c00ybTdnIRUTXeg20bZjJOzhKv1_heavy_1.wav</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  corona_test                              cough_filename\n",
       "0    negative    01OCEf1yB4czsq8ygRoT51s96Ba2_heavy_1.wav\n",
       "1    negative    01OCEf1yB4czsq8ygRoT51s96Ba2_heavy_2.wav\n",
       "2    negative  01OCEf1yB4czsq8ygRoT51s96Ba2_shallow_1.wav\n",
       "3    negative  01OCEf1yB4czsq8ygRoT51s96Ba2_shallow_3.wav\n",
       "4    negative    0c00ybTdnIRUTXeg20bZjJOzhKv1_heavy_1.wav"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train = data[:300] \n",
    "# val = data[301:351] + data[475:525]\n",
    "# test = data[352:402] + data[424:474]\n",
    "X_train,X_test,Y_train,Y_test = train_test_split(data['corona_test'],data['cough_filename'],test_size=0.2,random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the function to create all the images from train, val and test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2370    positive\n",
       "1774    positive\n",
       "731     negative\n",
       "271     negative\n",
       "1077    negative\n",
       "Name: corona_test, dtype: object"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2370                           wavegan_pos_486.wav\n",
       "1774    s1x2Ze9iVZNf6oFZDAZ4S9x3Cky2_shallow_1.wav\n",
       "731                            wavegan_neg_356.wav\n",
       "271     Sy1VK1UgX0ZMcMJitgPal1sp8jj2_shallow_2.wav\n",
       "1077                           wavegan_neg_668.wav\n",
       "Name: cough_filename, dtype: object"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames= [X_train,Y_train]\n",
    "train=pd.concat(frames,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>corona_test</th>\n",
       "      <th>cough_filename</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>763</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_385.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>835</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_45.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1653</th>\n",
       "      <td>positive</td>\n",
       "      <td>IFMid2LmeCTSQAFaL8wTSUg20No2_shallow_1.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2607</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_7.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2732</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_811.wav</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     corona_test                              cough_filename\n",
       "763     negative                         wavegan_neg_385.wav\n",
       "835     negative                          wavegan_neg_45.wav\n",
       "1653    positive  IFMid2LmeCTSQAFaL8wTSUg20No2_shallow_1.wav\n",
       "2607    positive                           wavegan_pos_7.wav\n",
       "2732    positive                         wavegan_pos_811.wav"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test1,X_val,Y_test1,Y_val = train_test_split(X_test,Y_test,test_size=0.5,random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames2= [X_test1,Y_test1]\n",
    "test=pd.concat(frames2,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>corona_test</th>\n",
       "      <th>cough_filename</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2272</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_398.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2624</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_714.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>485</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_134.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1334</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_9.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2906</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_969.wav</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     corona_test       cough_filename\n",
       "2272    positive  wavegan_pos_398.wav\n",
       "2624    positive  wavegan_pos_714.wav\n",
       "485     negative  wavegan_neg_134.wav\n",
       "1334    negative    wavegan_neg_9.wav\n",
       "2906    positive  wavegan_pos_969.wav"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames3= [X_val,Y_val]\n",
    "val=pd.concat(frames3,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>corona_test</th>\n",
       "      <th>cough_filename</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>890</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_5.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2229</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_359.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2350</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_468.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1695</th>\n",
       "      <td>positive</td>\n",
       "      <td>nC130uADRFZF5vae8qZt2qmpbpi1_shallow_3.wav</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1465</th>\n",
       "      <td>negative</td>\n",
       "      <td>XzIjEtRHHPci6Zq0zb9Lx0d6zEr2_shallow_5.wav</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     corona_test                              cough_filename\n",
       "890     negative                           wavegan_neg_5.wav\n",
       "2229    positive                         wavegan_pos_359.wav\n",
       "2350    positive                         wavegan_pos_468.wav\n",
       "1695    positive  nC130uADRFZF5vae8qZt2qmpbpi1_shallow_3.wav\n",
       "1465    negative  XzIjEtRHHPci6Zq0zb9Lx0d6zEr2_shallow_5.wav"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Deepa Kapoor\\anaconda364\\lib\\site-packages\\librosa\\core\\spectrum.py:222: UserWarning: n_fft=2048 is too small for input signal of length=1904\n",
      "  warnings.warn(\n",
      "C:\\Users\\Deepa Kapoor\\anaconda364\\lib\\site-packages\\librosa\\core\\spectrum.py:222: UserWarning: n_fft=2048 is too small for input signal of length=384\n",
      "  warnings.warn(\n",
      "C:\\Users\\Deepa Kapoor\\anaconda364\\lib\\site-packages\\librosa\\core\\spectrum.py:222: UserWarning: n_fft=2048 is too small for input signal of length=1664\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "train.apply(images, axis=1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.apply(test_images, axis=1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "val.apply(val_images, axis=1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close('all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.system('say -v Juan ya acabé');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use the datagen.flow_from_dataframe from the keras documentation to use with the CNN\n",
    "https://keras.io/preprocessing/image/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![keras](img/keras.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('dataset_minor_3000.csv',dtype=str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train = data[:3435]\n",
    "# val = data[3435:4435]\n",
    "# test = data[4435:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to change the file names to the image names to use them later \n",
    "def make_jpg(files):\n",
    "    return str(files)+'.jpg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train['cough_filename'] = train[\"cough_filename\"].apply(make_jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "val['cough_filename'] = val[\"cough_filename\"].apply(make_jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "test['cough_filename'] = test[\"cough_filename\"].apply(make_jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rescaling the images as usual to feed into the CNN\n",
    "datagen=ImageDataGenerator(rescale=1./255.)\n",
    "# datagen=ImageDataGenerator(rescale = 1./255,\n",
    "#                                    shear_range = 0.2,\n",
    "#                                    zoom_range = 0.2,\n",
    "#                                    horizontal_flip = True,\n",
    "#                                    width_shift_range=0.2,\n",
    "#                                    height_shift_range=0.2,\n",
    "#                                    rotation_range=15,\n",
    "#                                    vertical_flip=True,\n",
    "#                                    fill_mode='reflect',\n",
    "#                                    data_format='channels_last',\n",
    "#                                    brightness_range=[0.5, 1.5],\n",
    "#                                    featurewise_center=True,\n",
    "#                                    featurewise_std_normalization=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>corona_test</th>\n",
       "      <th>cough_filename</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2370</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_486.wav.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1774</th>\n",
       "      <td>positive</td>\n",
       "      <td>s1x2Ze9iVZNf6oFZDAZ4S9x3Cky2_shallow_1.wav.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>731</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_356.wav.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>271</th>\n",
       "      <td>negative</td>\n",
       "      <td>Sy1VK1UgX0ZMcMJitgPal1sp8jj2_shallow_2.wav.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1077</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_668.wav.jpg</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     corona_test                                  cough_filename\n",
       "2370    positive                         wavegan_pos_486.wav.jpg\n",
       "1774    positive  s1x2Ze9iVZNf6oFZDAZ4S9x3Cky2_shallow_1.wav.jpg\n",
       "731     negative                         wavegan_neg_356.wav.jpg\n",
       "271     negative  Sy1VK1UgX0ZMcMJitgPal1sp8jj2_shallow_2.wav.jpg\n",
       "1077    negative                         wavegan_neg_668.wav.jpg"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cough_filename</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>corona_test</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>negative</th>\n",
       "      <td>1157</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>positive</th>\n",
       "      <td>1243</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             cough_filename\n",
       "corona_test                \n",
       "negative               1157\n",
       "positive               1243"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.groupby('corona_test').count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 2400 validated image filenames belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "train_generator=datagen.flow_from_dataframe(\n",
    "    dataframe=train,\n",
    "    directory=\"train3000_images\",\n",
    "    x_col=\"cough_filename\",\n",
    "    y_col=\"corona_test\",\n",
    "    batch_size=16,\n",
    "    shuffle=False,\n",
    "    class_mode=\"binary\",\n",
    "    target_size=(64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(16, 64, 64, 3)\n",
      "(16,)\n"
     ]
    }
   ],
   "source": [
    "for x,y in train_generator:\n",
    "  print(x.shape)\n",
    "  print(y.shape)\n",
    "  break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 300 validated image filenames belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "val_generator=datagen.flow_from_dataframe(\n",
    "    dataframe=val,\n",
    "    directory=\"val3000_images\",\n",
    "    x_col=\"cough_filename\",\n",
    "    y_col=\"corona_test\",\n",
    "    batch_size=16,\n",
    "    shuffle=False,\n",
    "    class_mode=\"binary\",\n",
    "    target_size=(64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 300 validated image filenames belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "test_generator=datagen.flow_from_dataframe(\n",
    "    dataframe=test,\n",
    "    directory=\"test3000_images\",\n",
    "    x_col=\"cough_filename\",\n",
    "    y_col=\"corona_test\",\n",
    "    batch_size=16,\n",
    "    shuffle=False,\n",
    "    class_mode=\"binary\",\n",
    "    target_size=(64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close('all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import os\n",
    "os.system('say -v Juan ya acabé');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Now we finally can build the CNN model and fit it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Pretrained Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### EfficentNet by Google"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import efficientnet.keras as efn\n",
    "# base_model = efn.EfficientNetB0(input_shape = (64,64, 3), include_top = False, weights = 'imagenet')\n",
    "\n",
    "# for layer in base_model.layers:\n",
    "#     layer.trainable = False\n",
    "    \n",
    "# x = model.output\n",
    "# x = Flatten()(x)\n",
    "# x = Dense(1024, activation=\"relu\")(x)\n",
    "# x = Dropout(0.5)(x)\n",
    "# predictions = Dense(1, activation=\"sigmoid\")(x)\n",
    "# model_final = Model(model.input, predictions)\n",
    "\n",
    "# model_final.compile(optimizers.RMSprop(lr=0.0001, decay=1e-6),loss='binary_crossentropy',metrics=['accuracy'])\n",
    "\n",
    "# eff_history = model_final.fit_generator(train_generator, validation_data = test_generator, steps_per_epoch =6 , epochs = 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### ResNet50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ## Resnet 50\n",
    "# import tensorflow as tf\n",
    "# from tensorflow.keras.applications import ResNet50\n",
    "\n",
    "# base_model = ResNet50(input_shape=(64,64,3), include_top=False, weights=\"imagenet\")\n",
    "\n",
    "# for layer in base_model.layers:\n",
    "#     layer.trainable = False\n",
    "    \n",
    "# from tensorflow.keras.applications import ResNet50\n",
    "# from tensorflow.python.keras.models import Sequential\n",
    "# from tensorflow.python.keras.layers import Dense, Flatten, GlobalAveragePooling2D\n",
    "\n",
    "# base_model = Sequential()\n",
    "# base_model.add(ResNet50(include_top=False, weights='imagenet', pooling='max'))\n",
    "# base_model.add(Dense(1, activation='sigmoid'))\n",
    "\n",
    "\n",
    "# base_model.compile(optimizer = tf.keras.optimizers.SGD(lr=0.0001), loss = 'binary_crossentropy', metrics = ['acc'])\n",
    "\n",
    "# resnet_history = base_model.fit(train_generator, validation_data = test_generator, steps_per_epoch = 6, epochs = 10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### VGG16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "## VGG16\n",
    "# Accuracy - train- 70 and test - 60\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.applications.vgg16 import VGG16\n",
    "\n",
    "base_model = VGG16(input_shape = (64,64, 3), # Shape of our images\n",
    "include_top = False, # Leave out the last fully connected layer\n",
    "weights = 'imagenet')\n",
    "\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = False\n",
    "    \n",
    "x = layers.Flatten()(base_model.output)\n",
    "\n",
    "# Add a fully connected layer with 512 hidden units and ReLU activation\n",
    "x = layers.Dense(512, activation='relu')(x)\n",
    "\n",
    "# Add a dropout rate of 0.5\n",
    "x = layers.Dropout(0.5)(x)\n",
    "\n",
    "# Add a final sigmoid layer for classification\n",
    "x = layers.Dense(1, activation='sigmoid')(x)\n",
    "\n",
    "model = tf.keras.models.Model(base_model.input, x)\n",
    "\n",
    "model.compile(optimizer = tf.keras.optimizers.RMSprop(lr=0.0001), loss = 'binary_crossentropy',metrics = ['acc'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Basic CNN Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Basic CNN Model with Accuracy -: Test- 60 and Train- 90\n",
    "# # Building our model \n",
    "# model = Sequential()\n",
    "\n",
    "# model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu', input_shape=(64,64,3)))\n",
    "# model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "# model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))\n",
    "# model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# model.add(Dropout(0.5))\n",
    "\n",
    "# model.add(Conv2D(filters=128, kernel_size=(3, 3), activation='relu'))\n",
    "# model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# model.add(Dropout(0.5))\n",
    "\n",
    "# # model.add(Conv2D(filters=128, kernel_size=(3, 3), activation='relu'))\n",
    "# # model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# # model.add(Dropout(0.5))\n",
    "\n",
    "# model.add(Flatten())\n",
    "# model.add(Dense(512, activation='relu'))\n",
    "# model.add(Dropout(0.5))\n",
    "\n",
    "# model.add(Dense(128, activation='relu'))\n",
    "# model.add(Dropout(0.5))\n",
    "\n",
    "# model.add(Dense(1, activation='softmax'))\n",
    "\n",
    "# model.compile(loss='categorical_crossentropy',\n",
    "#                   optimizer='adam',\n",
    "#                   metrics=['accuracy'])\n",
    "\n",
    "# history = model.fit(x=train_generator,\n",
    "#                     steps_per_epoch=6,\n",
    "#                     validation_data=test_generator,\n",
    "#                     validation_steps=1,\n",
    "#                     epochs=10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### AlexNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #Alexnet \n",
    "\n",
    "# model = Sequential()\n",
    "\n",
    "# # 1st Convolutional Layer\n",
    "# model.add(Conv2D(filters=32, input_shape=(64,64,3), kernel_size=(11,11), strides=(4,4), padding=\"valid\"))\n",
    "# model.add(Activation('relu'))\n",
    "# # Max Pooling\n",
    "# model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='valid'))\n",
    "\n",
    "# # 2nd Convolutional Layer\n",
    "# model.add(Conv2D(filters=64, kernel_size=(2,2), strides=(1,1), padding='valid'))\n",
    "# model.add(Activation('relu'))\n",
    "# # Max Pooling\n",
    "# model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='valid'))\n",
    "\n",
    "# # 3rd Convolutional Layer\n",
    "# model.add(Conv2D(filters=64, kernel_size=(1,1), strides=(1,1), padding='valid'))\n",
    "# model.add(Activation('relu'))\n",
    "\n",
    "# # 4th Convolutional Layer\n",
    "# model.add(Conv2D(filters=128, kernel_size=(1,1), strides=(1,1), padding='valid'))\n",
    "# model.add(Activation('relu'))\n",
    "\n",
    "# # 5th Convolutional Layer\n",
    "# model.add(Conv2D(filters=256, kernel_size=(3,3), strides=(1,1), padding='valid'))\n",
    "# model.add(Activation('relu'))\n",
    "# # Max Pooling\n",
    "# model.add(MaxPooling2D(pool_size=(1,1), strides=(2,2), padding='valid'))\n",
    "\n",
    "# # Passing it to a Fully Connected layer\n",
    "# model.add(Flatten())\n",
    "# # 1st Fully Connected Layer\n",
    "# model.add(Dense(200, input_shape=(64,64,3,)))\n",
    "# model.add(Activation('relu'))\n",
    "# # Add Dropout to prevent overfitting\n",
    "# model.add(Dropout(0.25))\n",
    "\n",
    "# # 2nd Fully Connected Layer\n",
    "# model.add(Dense(100))\n",
    "# model.add(Activation('relu'))\n",
    "# # Add Dropout\n",
    "# model.add(Dropout(0.2))\n",
    "\n",
    "# # 3rd Fully Connected Layer\n",
    "# model.add(Dense(50))\n",
    "# model.add(Activation('relu'))\n",
    "# # Add Dropout\n",
    "# model.add(Dropout(0.1))\n",
    "\n",
    "# # Output Layer\n",
    "# model.add(Dense(2))\n",
    "# model.add(Activation('softmax'))\n",
    "\n",
    "# model.compile(loss='categorical_crossentropy',\n",
    "#                   optimizer='adam',\n",
    "#                   metrics=['accuracy'])\n",
    "## Accuracy- Major Over Fitting -:  training -90 and test - 54\n",
    "# history = model.fit(x=train_generator,\n",
    "#                     steps_per_epoch=10,\n",
    "#                     validation_data=test_generator,\n",
    "#                     validation_steps=5,\n",
    "#                     epochs=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compiling using adam and categorical crossentropy\n",
    "# model.compile(loss='categorical_crossentropy',\n",
    "#                   optimizer='adam',\n",
    "#                   metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "40/40 [==============================] - 70s 2s/step - loss: 0.4706 - acc: 0.7734 - val_loss: 0.5331 - val_acc: 0.7100\n",
      "Epoch 2/5\n",
      "40/40 [==============================] - 66s 2s/step - loss: 0.4725 - acc: 0.7719 - val_loss: 0.5512 - val_acc: 0.6867\n",
      "Epoch 3/5\n",
      "40/40 [==============================] - 67s 2s/step - loss: 0.4784 - acc: 0.7609 - val_loss: 0.5471 - val_acc: 0.6900\n",
      "Epoch 4/5\n",
      "40/40 [==============================] - 68s 2s/step - loss: 0.4742 - acc: 0.7719 - val_loss: 0.6000 - val_acc: 0.6433\n",
      "Epoch 5/5\n",
      "40/40 [==============================] - 68s 2s/step - loss: 0.4581 - acc: 0.7688 - val_loss: 0.5437 - val_acc: 0.6867\n"
     ]
    }
   ],
   "source": [
    "# Fitting our CNN with 250 epochs and setting the results to history for visuals\n",
    "# history = model.fit(x=train_generator,\n",
    "#                     steps_per_epoch=8,\n",
    "#                     validation_data=test_generator,\n",
    "#                     validation_steps=4,\n",
    "#                     epochs=50)\n",
    "vgghist = model.fit(train_generator, validation_data = val_generator, steps_per_epoch = 40, epochs = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuUAAAIBCAYAAADu78FqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd5xU1fnH8c/DVpBeRQVpgliQJiRWRAQ1kajBH3ZQFAuWmAQLECVK7EGN2AUsgEosQY0timjUSEQxRoqCQBRs9N52eX5/3Du7s7MzszNbGGS/79drXrv33nPuPbfMzDPnnnuOuTsiIiIiIpI5NTJdABERERGR6k5BuYiIiIhIhikoFxERERHJMAXlIiIiIiIZpqBcRERERCTDFJSLiIiIiGSYgnLZZZlZLzNzM6v0fjvNbHC47iWVve7qzsxGh8d2RqbLkqpk11pFr8OqvI5T3L6uddllZfr9ISWZ2ZLwfAzOdFmqIwXl1Vzkw7Ccr8GZLr/sHszskfCaWmlmeWnkWxjme7Eqy7crMrNW4Q+g0Zkuy85iZlOjPn/GZLo8snuL+kGb6qtVpsssP23ZmS6AZNwPCebXBvYoI83myi9OCZuAL6po3WvDdS+rovVLesYDFwANgV8BU8vKYGZHA22j8leVqrwOK6IVcEP4/+gk6XaLa93MGgH9o2YNNrMb3L0wU2WSamUFUNa1pmtRKkRBeTXn7nvGmx/Wvt2QLE1Vc/d/A/tX0bpfAF6oinVL+tz9QzObCxwAnEcKQXmYDoIfjX+vwrJV2XW4M+xG1/rZQB7wCtCB4AdZv3BapKod6u5LMl0I2b2p+YqI7Coitd19zWyfZAnNrA4wIJx8wt0LqrRksisYEv59Angy/P/8DJVFRKTSKSiXcolqQ9fLzJqa2Vgz+9LMNkU/sGNmNc2sf9hm+FMzW25mW83sWzP7m5mdkGQbyR6+K/Hwmpl1C9ubfheuf1FYpgYJ1p3w4bfYBxXN7Fgz+3tY9i1mNs/MbjCz/DKO0a/M7C0zW2NmG8zsP2Z2tZnlVORhSDOrZ2anm9lkM/uvma0Ky/U/M5tiZj9Lkrey9u0EM/tHvH1Ld3+iPAlsJ/hcGlRG2oEUN6+aEJap3NdaMsmuw6g0+4fn4/vwOC4ys3vNrFkZ684xs+PM7C9mNiu8freZ2Y9m9rqZnWFmFiffEuDtqOnYtq2PRS0r80FPM2trZg+Y2QIz22xm68zsEzO73szqpnJczKydmU0ws2/C4740PBd7JzsGqTCzQ4GDCZriTCMIzB3ob2ZNUsjfwsxuD6+LteE+fmVm08zs3ETXu5n1NLOJFjy7sDE8LnPD/ewbkzaV49zKErQ/js1vZseE1+13ZlYYc05bmtmw8L37ZVi2DWHZ7jazlpV1TMzs+LBc281srzLW+c/Y6y9dZtbdzJ4N93tLeOzvMLP6cdI+HW4v6d2S8NrcEabtVd6ypcvMZoTbHG1muWZ2rZl9Fp6v1RZ8hpb5uWRmp5rZy2b2Q/j58EM4fUoKeRuF7+OZVvxdsST8fLnYzOolyZtrZsMt+HzfGF4n083s+HSPhaTI3fXSq9SLoI2qB5dI3OUevi4Avg//3wysi84DDI5K6wTtczfGzLszwTZ6JSpD1HqXAGcC28LpNQTt+iLr/hyonSx/kn2fAQwHdoSv1eHfyLqnA1kJyn5nzD6uJgg4HXgH+FNkGxU5N+FrPbAlanoHcEUZeSuyb7Hbj923myuwb8+GeReUke79MN17O+FaS7gsXH58zPFfT/BecOBbgmY2Za47fG0J80fPmwrUiMn3EbAqKs33Ma97UrnWw+X/F1P+dTHTXwMdyyj7MVHlXhd1PThBW/a9K/h59GC4roej5r0TzvttGXnPiTofDmwl+JyIPsadY/JkAffEpNkQcz2tSfUzJSpNq6j8rRLlB66g+P24huDz7bGotDNiyhb7ubcGOKIyjglgwKJw3qgk69w/Ku9haZzb6OvoV2FZnOAH2NaoZUviHLNI3kKgZZJt3Bqm+yLN624wCc5Xivkj5+lm4N3w/+0En5nRx3p0gvy5wNNR6QoJ3vfR53oKkJMgf19Kfk7E2/bJMXmWhPMvAz4M/99Gyc+lHcD5FXlP65Xgmsl0AfTaNV+kHpSvB+YDvQkDB6B9VLqTgYfCD89GUfObA9dTHEz3j7ONXonKEPVhuZEggHgEaBEuqwUMi1r3jUnyL0my76vDD7+bgcbhsrrAH6P2v9QHE3B61PLJhAEJkA9cSPBlGPmgnFGOc3MxMBboCdQP5xnQGrg7/MAsALpUwb71j1o+NeqY1wQuJfgSjXzol2ffToha/1EJ0nSIV8YqvNaSLduHIHhw4D9Aj3B+DYJg/Zuo4xEvf8/wGjkRaAZYOL8hQWAWWXepH1nJypXGtd416ri8B3SKKv9JBD8qHFhIzI9bSgZTqwhqsPcPl+USBPvrwuVPpHstRG2nVtRxOCJq/vnhvM+T5D2R4uD2PeAIij+n6gJHAg8DB8Tkuy1q38ZT8jOtKUHw+HSqxzkqTauo9bZKkH8zwft3IsXvryygbVTaccA1QEegZjgvG+gBvErxj6GalXFMwm05sJiYH4hRaf4cpvlvmuc3+jpaQ3AHqGPUPv0fxZ+X/yamsgCYGy77Y4L151BccfS7NMs2mATnK8X8M6L2awtwEZAfLmsB/DVq/fE+lyKVOzuAGyn+vG9AccWOA7fGyduF4h9enxN8tuZEvae6h+s/NibfEorf00sJrvVIvg7Avyj+7q9X3ve1XgmumUwXQK9d80XqQflaYJ8KbOf34XrejLOsV6IyxHxYPpZg3ZEviVK1rqQWlDuJazCeC5f/I2a+AV+Gy94gDLKSlH1GFZy7ceG6H63MfQuXzYmUmzhfzuGXTrn3jSAY/KaM8xoJmNYT5y5IFVxryZbdHy5bATSNs/wgioPeUvlTKPOAMO/CdMqVxrUeCeAWALXiLO9Cca337xNtn+DOSrzr4fJw+SYgu5zX87nxjgFQJ1yvAz3j5MumuIb3n0BuittrT3FN5G1plDPhcY5K0yrqmLVKkN+B58pzrML1ZBH8QHTg7Eo6Jk0orrXuF2d5LrA8XH55muWNvo6+IP4PiT5RaU6LWXZlOP8b4tzdA34dLt9KWAFRjnPq4f7F3pGKfj0fJ/+MqPzxKjlqUHzHZ07Msr2j3ns3Jyhf5DtuG9A8Ztk/w2VfkkbwTHFQvoXwR3acayES7J9V3utUr/gvtSmXinrS3ZdWIH+k14yfm1lWOdeRqL/iaeHfdmZWqxzr3UpQk5Bs3Z1i5ncG9gv/v9nDT7EYjxM0CagqkWN6RJI0ae+bmXUi6B0FYIy774iT9xEq0PVeuM7Hw8kBZlY7pgxZBLfeAZ5x9w1prL4yrrXoshhB23aAB939x9g07v45QZOc8oqUua2ZNa/AekoJ2+j2CyfvcPdNsWncfTbwfDh5RpLV3ZzgeohcSzUpfl+kK/KA55PRM919PcW9ygyhtGMI7h4BXOXu21Lc3iCCYGklxV1O7my3lDejB11EvhZOxn4GlOuYuPtygh/rAEPjJDkVaEwQrD0ZZ3mq7nD3Ul3tuvubwAfh5Okxix8n+HG2D8FdgFgXhn+fc/cVFShbY4K7WYleDZPk/YbgzkcJ4Xsm8v11gJkdHLX41wQ/orYQNL+JZwzBZ3kOxQ++Y2b7UXzuR7j72mQ7lsCz7j4/TpmXE9SWQ+nvP6kgBeVSUe+XlcDMmpnZH83sXxYMDlNgxQ+IzQ2T1SK4JZeuVe6+MMGyb6P+L8+65yQJ+iLrjv0g7hr+3U7xl0gJYaD+TjnKU8TM2pjZnWb2sQUPWxZGHdPIQ0/JejApz751D/8WENTClBJ+ycwoew+SmkBQC7MHxUFvxAkEzVEi6Uqo4mstVmuKj9H0JOmSLcPM6oQPU71jwQOe26LKHB0oV/iByRhdCe7sALyZJN0/wr+dLPGDvDMTzI9+DyYLWuIys3bAUQTXQ7xgL/ID7vQ4P7wPC/9+7+6z0thsJN8/3H1LGvkqy2bgk7ISmdmRZvaYmc0PH/L0qOvm6jBZ7GdAeY8JBO36IXi4NvYB5kjgO9Xd16S53mipvI+6R88Mt/dMTDkAMLN9gePCyYcrUC6A1u5uSV69kuSdkaCCBoK25pHeo6L3LfL/R+6+Ll5Gd18NzIpJD8XnuZDgblh5JHpPQ+LvCKkg9VMuFVWqdjCamf2cIEiMfnJ+A8W3nbMIaiAgCMLSrclYn2RZdDd55ekVJJV1x76HIj1BrCyjFqrctcnhE/dPEfTZHBH9cF4uQdC5R+ncRcqzb03DvyvcfWuS/BW5c4K7L7Kgd5hjCNoNRw8MFOkCb767l/jRsxOutVhNo/5Pdj4THg8zaw+8RcngaRNBG9RIzXMkAEp2Pssj3fJnE3wJlxpMLKy1LsXdC6y485jyvAcj5/t9d18UZ/mbhA+SAqdRHKQDRMZX+F+a2yxvvsqyMsFdhyJmdhvFgTcEwddqgmYMUDz4W+w1U+59c/d3reRYAreGZWlL8F6F4JmOikh2HUaWNY2z7MGwTCea2d7uHkl7AUHl4xfuPqOCZauIhPvl7lvNbCXB+zx63yL/l/VdEXl/RueNnOcV7r4xnYJGSeU7oiK9bUkcqimXiko4gpmZZRMEj/WBTwluLdZ19zru3syDQYmiu+8r1fXbT1BkHxLVisSmS2/lwaiGjxEE5NMJ2mPWcvd6Ucf0tPKsOw1l7VtliATih5lZBwAzawz8MmY54bJMX2vlPSYTCQLyJQTnrZG77+HuTcMyR9eO7wrvj51x7oGipkqDwskjrHS3j07w+RM5RvGasED5y7zT9jVG0lEhzew4igPy+wm6isxz94buvmd43dwVSZ5gNeXdt0ht+QVW/GvrwnA7n7v7v+Jnq1oeDPD1CcEP7yFQdP1EBhh7JBPlilKRaynVvPHSZeoalnJSUC5V6efAvgRfMr9091fj1KhlZLTQKhS5c9DYzHKTpEva328SJxL0kLAaOMnd34nTBrOqjmlk35qYWV6SdJXRzOI5gtpiKP5iPYegZqaA0k0ZMnGtRd8lStZUKO7xMLMWFN9mPsPdn3X3VTHJqvL9kWr5I8sKCK67neUE0nufHBm2pY34LvzbOl7iJCL5WqWZL1J7mKyP/4R9Qqch0qb6dXcf5u6fh+3IoyW6bsp7TCKeILiT0xboHf4YHhwuq2gtOST/7IgsS3R3NvKDYYiZ1SD4rNyboM314wny7CwJ31/hZ2mjcDJ63yL/t0hx3cuj5kXOcxMzq+w7bFKFFJRLVYp8mCyPup0Yq8/OKsxOEmkLmkNxwFVCWMN0VDnXHzmmX8R7MC9UVcc00nYxmwQPkYZfhr0quqGwLe+UcPLcmFqvl909tglFJq61xQTdhkHx7ft4eieYH/1lOztBmmRlLmriEFVrmY5PotZxbJJ0kTL8x923l2M75RWp+X6BoKeVZK/I+y56hM9I86ZmZlaiHXIZIvmOszIG0YoR+cHSNMmP1p5prC+RyHUT95oJr4VE11x5jwkA4QODT4WTQwm6SG1G0A5+UrrriyPZ+yiyLFFb+CkEzfhaEjzAHGlf/nwFH/CsDEcneY8eSXFTweh9K2ornmiAn/Bh7aK251GLIuc5i+DHrfxEKCiXqhR54rtZnAeDsGAo9St2bpGq3KcEfToDXJvgg/hsglrd8ogc0/bxAgYz60wwmFKlc/fPgHnh5MgwAI91PslrXdMRaaLSHPgDwW366PnRdvq1Fj64NTWcvDhsXhO73QOI6hUhRnSPCIfEyVsHGJWkCNEPf5Ua7bAs4QNyr4eTw+P1UGRmhxD0AgHFwViVC89hpKnSM+6+IdmLoL9ngEFRPeu8TdD9H8BdZdy5ivYYwR2XRgT99qfqP5HiA6VGWjSzmsBVaawvkch1U+qaCV0MtEmwrLzHJNoD4d+TKW5G80wFH/CM+H2Cz7VjgMMj24qXMWw7HbmDNorinlgq+oBnZWhJnFGKw8/QEeHkPHf/b9Ti5wjuvuQT9BMfzwiCpozbKe4dh7Dzg3fDyZstwai8sutRUC5V6T2CwX0MmBo+1IaZZZlZP4r7cN1thIFapBu1fsDjFg5NbWb5ZjaE4DZveZsBvEFQu9kQmGzhEOYWDIf8f+HyZA/oVNTI8O8xwJQw2I3s28UEfaRXxpcz7v4JwY8cCIJyCG7LxutNIFPX2i0Ex7sx8I9I7aMF+oZlTXRHYy7FXWNOMLNukQXhQ6szSN5LzJcUP9gX3cY3HSMJvtDbAa9b2CWbmdUwsxMJHpzNBr6icponpOrccLubgZdTSB/5cdScsGYwbNJxGcF5PwJ4y8yOiPyYNLO6ZtbLzCaFP54I8y0E7ggnrzazR6ObxZhZEzMbaGaR7hgj+ZYSXIcAY82sT+QHQnhu3yT+Q4rpinR3eIKZ/SHSPMHM6pvZCOBegu4cSynvMYlZx8fAxwQPlEdq/isr8G0O/D3qOZJsMxtAcbein1DcRWc8kSYshxHUEmf6Ac+ItcADZnZh5EdH2HztKYrvAIyMzhDe8bsnnLzWgl6l6od565vZTQSjMgOMdffvKOlKgof/9wPeN7PjLew9ycxqmVlPM3vQzHa3u9U/bYk6MNerer9IffCgXmWs5+KotE7JIciXE4wamGgwjV6JykAlDmmdZN9nJFl3wrKFy++K2vYOgmYOkUFk3qJ4KPrXynFubqXkMV0Tte5FBDXliY5bZezbmJjtr6J4kIt3o/Yt4TbS2NfLYrZ1SwautbKOxy8oPUx9pMeXbwma3SRa9y8pOST9RoqHct9I0Kwk4XsNeDQm7/8IHhq9M9X3CkG3k9HDma+l5BDsXxOOsJjOcYlKl9JnRUyeeWGeZ9PI83GY54WY+efGnJ8tlB5qvHNMniyKB+GKvp42Rk2viVOGzhSPYurhcdwQ/v89Qe1t2p9JMelyKB6yPfrzJTLg0cvATSR5D5bnmMTkHxKVLq0RPJNdRwSjR0Y+y9bElPF/BN0SlrW+f0blSWsEzzjrGhy1rrIGD/oeGBiTf0aY9+aocm2jeITSyOumBNvPJbgzEElXGHOunaDZTk6C/H3D4+hJtn1yTJ4l4fzBSY7LY2GaxypyfPUq/VJNuVQpd3+QIGiZQfDllE3QxdO9BLdf/5sw80+Yu19FMKDGDIIv8zyCQGM4QQ165OGbtGuV3f1agi/VfxN86ecQNJm5mWAExm8T5644dx9FEExOJwhAIvt2LUEQmeogLamYTPDFHFGqb/KocmXkWnP3vxP0+f00wcNZuQTdBo4jOB+Lk+R9meD5gr8TXAvZBF01TgS6uvtbZWx+GMEPrc/D6ZYETaNKNaVJUoZngAMJasK/IjifBQR3KW4ADnL3eYnXULnM7HBg/3ByarK0MSJpfxndhMndnwjXdzfB3YkCgnP0FfA3ggeIS+yfuxe6+2UEtcmTCX6Y5BBc23MImlD9mhju/inBUPeRa6EGwfm8jyBgnxubJ10etOvvS9C05kuCH3VG8HlwCUE776Q9uJTnmMR4ForuPFXaHRR3n0ZQy/0cwfveCN4/fyb4kZDwvRQl0pSpsh/wLGvwoGYEg2TFs43gs3EEwaileQQ/ft8CfuHuf4iXyd23uftAgmvtVYI7IHXCv68Cp7r7mZ7gWQ93f4OgpvxPBM8gbA7LuISg6dpFlDGOguxcFv7qEZGdyMzeJ/jyud7db8p0eUREUmVmvyYIzDcDe3nltCevFGb2EkGlwVPuXiXP16RRlhnA0cAf3X10JssiPw2qKRfZyczsaIp7ZnktWVoRkV3Q5eHfp3axgLwNxQ94PpAsrciuSEG5SBUws/vMbLCZ7Rl5AC98OOciYFqYbLq7f5R4LSIiuxYzG0pQ+7sDGJvh4hQJexh5gCCumenu/8xwkUTSFjuMtohUjsOBS8P/t5rZJoJu6yI9ZMwlaBcuIrJLM7OfEbSTr0dx95v3u/uczJUqYGZ3EoyGuydBu/gC4DcZLZRIOammXKRqXE/whPpcgocO6xD0bvBPgr6KD/XEg9yIiOxK8gkeIK5D8ODlDVROn+uVoTHBA87bgH8Bx7v7h5ktkkj56EFPEREREZEMq1bNVxo3buytWrXKdDFEREREZDf28ccfr3D3JunkqVZBeatWrZg1a1amiyEiIiIiuzEz+1+6edSmXEREREQkwxSUi4iIiIhkmIJyEREREZEMU1AuIiIiIpJhCspFRERERDJMQbmIiIiISIYpKBcRERERybBq1U+5iIhIpm3dupVVq1axfv16CgsLM10cEUlRbm4ujRs3pl69elWyfgXlIiIiO8nWrVv5+uuvadCgAa1atSInJwczy3SxRKQM7s7mzZtZunQpeXl55OfnV/o21HxFRERkJ1m1ahUNGjSgcePG5ObmKiAX+YkwM2rVqkXjxo1Zvnx5lWxDQbmIiMhOsn79eurWrZvpYohIOdWpU4ctW7ZUyboVlIuIiOwkhYWF5OTkZLoYIlJO2dnZFBQUVMm6FZSLiIjsRGqyIvLTVZXvXwXlIiIiIiIZpqBcREREftKWLFmCmTF69Ohyr2Pw4MG6iyEZpaBcREREKpWZpfxasmRJpou7y+rRowdmxgUXXJDposhOYO6e6TLsNId06eofzvyImrlZmS6KiIhUQ/PmzaNjx46ZLkaVmzRpUonpf/7znzz88MMMHTqUI488ssSyU045hT322KNC23N3tm7dSnZ2NtnZ5RuCZfv27RQWFlZJ/9Pl8fnnn3PwwQfTtm1bfvjhB77//vsKHyepHKm8j83sY3fvns56q9XgQUt+3EjfG6bzlwu70aVNw0wXR0REZLd09tlnl5guKCjg4Ycf5uc//3mpZbHWr19PnTp10tqemVU4mM7JydmlesYZP348tWvXZtKkSfz85z9n6tSpnHfeeZkuVpnKc/4kUK2ar+xZP59NWwv45U0zuOXZOWzdruGNRUREMqVVq1b06tWL2bNn069fP+rVq0enTp2AILgbNWoUPXv2pHHjxuTl5dGuXTuuvfZaNm3aVGI98dqUR897+eWXOfTQQ8nPz6d58+YMHz68VLd28dqUR+atXbuWSy65hKZNm5Kfn8/hhx/OzJkzS+3PypUrOf/882nUqBG1a9emd+/ezJ49m169etGqVauUj8u2bduYNGkSp512Gj/72c/o0qUL48ePT5j+ueee45hjjqF+/frUqlWLDh06cMUVV7Bt27aiNO7OI488Qs+ePalduza1a9fm4IMP5vrrry9KM3r06IRNiiLnKpqZMXjwYN566y2OOOIIateuzUknnQTAt99+y+9+9zs6d+5MgwYNyM/P54ADDuC2226jsLB0/LVt2zZuv/12OnfuTK1atahXrx7du3dn3LhxAIwdOxYz48033yyVd+vWrTRs2JBjjz026XHd1VWroLxOzRym33Qs/3fEvvzl5S844Y9v89//rcl0sURERKqtr7/+mt69e7Pvvvtyxx13cPnllwOwbNkyHn30Ubp3784f/vAHxo4dS9euXbn99ts55ZRTUl7/K6+8wvnnn88JJ5zAXXfdxSGHHMKdd97J7bffnvI6+vXrx9KlS7n++uu57rrr+PzzzznxxBNZv359UZpt27bRp08fJk6cSP/+/bnjjjvo0KEDffr0YdmyZakfEGDatGmsWLGCQYMGAcGPg/fff58vvviiVNqRI0cyYMAAfvzxR6666iruvvtuTj75ZF555ZUSP17OOecchg4dipkxcuRI7rjjDnr37s2zzz6bVtlizZo1i5NPPpkePXpw1113cdZZZwHw2Wef8fzzz9O7d2/GjBnDrbfeSosWLbj22mu59NJLS6xj27Zt9OvXj2uuuYZmzZpx44038qc//Ylu3brx/PPPAzBo0CDy8vLi/jh54YUXWL16NUOGDKnQvmScu1ebV7du3TzijdnfeqcrXvZ9zn/e73xhrm/bXugiIiJVae7cuZkuQkZMnDjRAZ84cWKJ+fvuu68D/sgjj5TKs3XrVt+2bVup+aNGjXLAZ86cWTRv8eLFDvgNN9xQal6tWrV88eLFRfN37NjhBx54oO+5554l1jto0CAPwqLS8y655JIS86dOneqAP/jgg0Xz7rvvPgd8zJgxJdJG5u+7776l9iWR448/3lu1auU7duxwd/fly5d7Tk6OX3311SXSzZw50wE/5phjfPPmzSWW7dixoyj/M88844CfffbZXlhYMt6Jnr7hhhscKHG8Ivbdd18/+uijS8wDHPB//OMfpdJv2rSpaPvRzj77bK9Ro4Z/++23RfNuu+02B/y6664rlT66fGeccYbn5eX5ypUrS6Tp06ePN2jQoNQxqCqpvI+BWZ5mnFqt2pRHO65zc2b86ThGTvoPd/5tHq/P/o5xF3Wn/V7pDX+8fO0WNm4toFXT2lVUUhER2d39YfJ/mPP12kwXo4QDW9bjprMOqfLtNGzYMG5b6dzc3KL/CwoKWL9+PYWFhfTp04cxY8Ywc+ZMevToUeb6Tz755BJNR8yMY445hnHjxrFhwwZq1y77+/uqq64qMd27d28AFixYUDTvpZdeIisriyuvvLJE2gsvvJARI0aUuY2IpUuX8sYbbzBq1Kii5jSNGzfmF7/4BU888QR/+tOfih5mnTx5MgC33HJLqTb10U1xIunuvPNOatQo2UgidjpdhxxyCH369Ck1v2bNmkX/b9u2jQ0bNrBjxw769evHpEmTmDVrVlFTl8mTJ9OgQYMSTWnilW/o0KE89dRTTJ48ueiOypIlS3jrrbcYNmzYLvOQbnlVq+YrsRrUzuX+iw/l0ct6snTlJn47/pO013H147Ppd8PbfL18YxWUUEREZPfWtm1bsrLi94p2//3306lTJ/Ly8mjYsCFNmjQpate8evXqlNbfpk2bUvMaNWoEBG3Ay7OOePkXL17MXnvtVSrIz8nJoXXr1iltB2DixIns2LGDww8/nIULFxa9evfuzffff88rr7xSlHbBggWYGYcckvzH04IFC2jevDnNmjVLuRypat++fdz5BQUFjBkzhvbt25Ofn0+jRo1o0qQJ55xzDlDy/C1YsID999+/zKC6V69etG/fvkQTlokTJ+Luu0W3kdW2pjzaL0E0JAgAACAASURBVLrvzaeLV/PQawvYsq2Q/BS7THR3PlqwinWbt3PxA//mbyOOJje7Wv/OERGRctgZNdK7qlq1asWdP3bsWH73u9/Rt29frrjiCvbaay9yc3NZtmwZgwcPZseOHSmtP1HAD8H3eEXWEZ0/1XUl4+5MnDgRCNqxxzNhwgT69+9flD6VAY9STZcsTeyDsRGJzt9vf/tb7r33XgYOHMjIkSNp2rQpOTk5fPLJJ1xzzTWlzl+qAzddeOGFDB8+nI8//pguXbrw2GOP0b179zJ/mPwUKCgPdWnTgO2Fzpyv19KtXWrdJS5dsYmV67fSu1Mzpn/2A7c+O4frTz+4iksqIiKy+3vyySdp1aoVr776aokmDK+99loGS5VY69atefPNN0s1idm+fTuLFy+mfv36Za7j7bffZvHixfzmN7/h8MMPL7X8qaee4sUXX+SHH36gWbNmdOjQgddee43PPvssaVOeDh06MG3atKJ8iTRsGMQ/q1atKtHkZ8uWLXz33Xe0a9euzH2IePLJJznqqKN4+umnS8xfuHBhqbTt27dn3rx5bN26lby8vKTrHTx4MCNHjmT8+PH86le/4uuvv+a6665LuVy7MlXrhiL9ls9evCrlPLMXB7derj71AAb3bsMDry3gzU+/q5LyiYiIVCdZWVmYWYka6IKCAm699dYMliqxk046icLCQu65554S8x955BHWrk3teYHx48eTlZXFiBEjGDBgQKnXFVdcQUFBAU888QQAZ555JgAjRoxg69atpdYXOXaRHlGuvvrqUjXU0cc30hQlttvBu+66K+U7ExFZWVml7h5s3LiRu+66q1Tas846i9WrVzNmzJiE+xDRuHFjTj75ZKZMmcK4ceOoVatW0XH4qVNNeah5g5rsWT+f2YtSa6MGMHvRavKya9Bxn3rccPrBfLRgJVc8+jFv3tibvRrGv50jIiIiZRswYADXXXcdJ5xwAqeeeirr1q1jypQpu9QAP9EuuOACHnroIUaNGsXChQvp0aMHn332GVOnTqVdu3YJm39ErFmzhueff54jjzySJk2axE1z5JFH0rRpUyZMmMDw4cPp0aMH11xzDbfddhvdunVj4MCB7LnnnixevJhnn32Wf//739SvX5/TTjuNgQMH8sQTT7BgwQL69+9PgwYN+PLLL3n99df5/PPPAejTpw/7778/119/PStXrqR169a89957fPjhhzRu3Dit4zFgwAAeeughBg4cSJ8+ffjhhx+YMGFCUXv8aFdeeSUvvfQSY8aM4aOPPqJv377k5+czZ84cvvjii1I/EoYOHcrUqVN5+eWXGTRoEHXrptdJx65KQXmUzm0a8GlaQfkqDtq3flE78oeG9aDvDdO59MGPePaaI8nO0o0IERGR8hg+fDjuzvjx47nyyivZc889GThwIOeddx4HHHBApotXSl5eHm+99RbDhw9n2rRpTJ06lZ49e/LWW29xwQUXlBrwKNbkyZPZsmULp556asI0NWrU4OSTT+bhhx/mgw8+4LDDDuPWW2/lkEMOYdy4cdx+++3s2LGDFi1acOKJJ5Zo7z1lyhSOPPJIxo8fz4033khWVhatW7fmtNNOK0qTlZXFtGnTuOKKK7j33nvJzc2lb9++vPPOO3Gb0yQzduxY6tSpw9SpU5k2bRotWrRg6NChHHrooaV6a8nNzeWNN97gz3/+M1OmTGHEiBHk5+ez3377xe2Zp3fv3rRr146FCxf+9Psmj2KV8WDCT0X37t191qxZCZff+/IX3PzsHOaO+yUNaucmTAdQULiD9pe8xJlHt2JM1AM6z37wNZc/PIur+u/P1afueh8aIiKSOfPmzaNjx46ZLobsRIWFhTRu3JiePXvusu3hf4oOPPBACgsLmT9//k7fdirvYzP72N27p7NeVeVG6dKmAQCfLi67tvyLZevYvK2Qrm1KPhQ64LCWDDyiJXe/NJ/35v5YJeUUERGRXc/mzZtLzXvwwQdZs2YNxx13XAZKtHuaPn06c+fOZejQoZkuSqVS85UonVo1wCxolnLMwcn78oy0PY8E8tFuPqczH3+1mmEPfcSbNx5Lk3o/7c7sRUREpGwXXnghW7Zs4bDDDiMvL49//etfTJkyhXbt2u12AWQmTJ8+na+++opbbrmFJk2acOGFF2a6SJVKNeVR6tbKoV3zOim1K5+9aDX198ihVdM9Si2rlZfNw5f2YN2m7Vz+yCx27Kg+TYRERESqq759+/LNN99w00038Zvf/IYZM2ZwwQUX8N5771GnTp1MF+8n78Ybb+SSSy6hdu3aPPfcc7vdMVVNeYwurRsw/b8/lNnR/qeLV9O5dYOEaTq2CIYnnvvNWgp2OLk1UusUX0RERH6azj33XM4999xMF2O3NWPGjEwXoUopKI/RtW1Dpr7/NUtXbKJFk9K14ACbthYwf+la+nXZP+m6zu6V+rC6IiIiIlJ9qflKjM5hG/HZSR72/GzJGnY4dI3TnlxEREREJF0KymN03Kceedk1kg4iFGlz3llBuYiIiIhUAgXlMXKza3DQvvWZvWhVwjSfLFpFi8a1aFxXvaqIiIiISMUpKI+jc5sGfLZkDQWFO+Iun71oddyuEEVEREREykNBeRxd2zRk87ZCvvx2fally9duYenKTXRp3TBOThERERGR9CkojyNSC/7JV6WbsERG++zSVjXlIiIiIlI5FJTH0arpHtTfIyfuw56zF60mq4Zx8L71M1AyEREREdkdKSiPw8zo3LpBUa14tNmLVrH/3nWplacu3kVERHa2JUuWYGaMHj26xHwzY/DgwSmtY/To0ZgZS5YsqfTyPfbYY5jZbj/QjVQ+BeUJdGnTkPlL17Jpa0HRPHcPRvLUQ54iIiIJnXbaaZgZn376acI07k7r1q2pX78+mzdv3omlq7gZM2YwevRo1qxZk+milKmwsJC99toLM2PMmDGZLo4koaA8ga5tGrDDg4GCIhb/sJE1G7er5xUREZEkhgwZAsDEiRMTpnn77bdZsmQJp59+OjVr1qzwNjdv3swjjzxS4fWkYsaMGfzxj3+MG5Sfc845bN68maOOOmqnlKUsr776Kt999x1t27Zl4sSJuHumiyQJKChPoGhkz6j+yiP/d22jnldEREQS6du3Ly1atGDy5Mls27YtbppIwB4J4CsqPz+fnJycSllXRWRlZZGfn0+NGrtGiDV+/HjatGnD2LFjWbRo0U+mWc369aV7wNvd7RpXzC6ocd18WjSuVeJhz9mLV1MrL4v2e9fNYMlERER2bTVq1GDw4MGsXLmSF198sdTydevW8fzzz3PQQQdx6KGHsn79ekaNGkXPnj1p3LgxeXl5tGvXjmuvvZZNmzaltM14bcp37NjBLbfcQuvWrcnPz+fggw9m8uTJcfPPnz+fSy+9lAMPPJA6depQq1YtunXrVqr2ffDgwfzxj38EoHXr1phZiTbuidqUr1ixgmHDhtGiRQtyc3Np0aIFw4YNY+XKlSXSRfJPnz6dO++8k7Zt25KXl0f79u15/PHHUzoWET/++CN///vfGTRoECeeeCJNmzZl/PjxcdO6O4888gg9e/akdu3a1K5dm4MPPpjrr7++RLpt27Zx++2307lzZ2rVqkW9evXo3r0748aNK3GMzCzudmLPU/QzAs888wzdunWjZs2aXH755UDq5yVi3bp1jBw5ko4dO5Kfn0+jRo044ogjePrppwG44oorMDMWLFhQKu93331HdnZ2pf1QTJeeVkyiS5sGfPJVcVD+6aLVdGrVgKwa8S80ERERCZx33nmMGTOGiRMnMmDAgBLLnn76aTZt2lQU/CxbtoxHH32UX//615x55plkZ2fzzjvvcPvttzN79mxef/31cpXht7/9Lffccw9HHXUUV111FT/++CPDhg2jTZs2pdLOmDGDd999l1/+8pe0bt2ajRs38te//pWhQ4eyYsUKrrvuOgAuuugi1q1bxwsvvMBdd91F48aNAejUqVPCcqxdu5bDDjuMhQsXcv7559O1a1dmz57NAw88wPTp0/n3v/9NnTp1SuQZMWIEmzdv5qKLLiIvL48HHniAwYMH065dOw4//PCU9v/xxx+noKCAc845h+zsbM466ywefPBB1q5dS7169UqkPeecc5g8eTI9e/Zk5MiR1K9fn/nz5/Pss89y4403AkFA3q9fP2bMmEHfvn05++yzyc/P57///S/PP/88l112WUrliudvf/sbf/nLX7jkkku4+OKLqVs3qABN9bwArFmzhiOOOII5c+YwYMAALrnkEgoLC5k9ezYvv/wyp59+OhdddBH33nsvEyZM4JZbbil1vAoLCzMWlOPu1ebVrVs3T8cDr3zpew56zn9cs9m3bi/0fYe84H986rO01iEiIhIxd+7cTBdhp+rdu7dnZWX5smXLSsz/2c9+5rm5ub58+XJ3d9+6datv27atVP5Ro0Y54DNnziyat3jxYgf8hhtuKJEW8EGDBhVNz58/383Me/fu7QUFBUXzP/74YzczB3zx4sVF8zds2FBq+4WFhX700Ud73bp1S5TvhhtuKJU/YuLEiQ7422+/XTRvxIgRDvh9991XIu24ceMc8FGjRpXK37lzZ9+6dWvR/KVLl3pubq6ffvrppbaZSMeOHf3oo48umv7Pf/7jgN9///0l0j3zzDMO+Nlnn+2FhYWljkHEbbfd5oBfd911pbYVnW7QoEEehJilxZ6nyPnMzs6O+/5I57xccsklDvhDDz2UtHw///nPvXnz5r59+/YSafbbbz/v2LFj3HJHS+V9DMzyNONU1ZQnEWlX/uni1TStn8/Wgh16yFNERCrfx7+B1Yl7KsmIBp2h290VWsWQIUOYPn06Tz75JNdccw0QNEf48MMPGTBgQFEtc25ublGegoIC1q9fT2FhIX369GHMmDHMnDmTHj16pLXtadOm4e789re/JSsrq2h+165dOe6443jjjTdKpN9jjz2K/t+yZQsbN27E3enbty/vvPMO8+fP5+CDD077GAC88MILNGnShKFDh5aYf9FFFzF69GheeOEFbrrpphLLLr300hLHZe+996Z9+/Zxm13E88EHHzBv3jyGDx9eNK9Tp0507tyZCRMmcMkllxTNjzTpufPOO0u1hY+enjx5Mg0aNCjVpCU2XXn84he/oGPHjqXmp3peduzYwdNPP03Hjh258MILk5Zv6NChnHfeebz66qucdNJJALz77rssWLCAO++8s0L7URFqU55Ep1b1yaphfPLVKmaHo3t2aauHPEVERFJx6qmnUr9+/RK9sEyYMAGA888/v0Ta+++/n06dOpGXl0fDhg1p0qQJvXr1AmD16tLjhpRl0aJFAOy///6llh1wwAGl5m3YsIHf//73tGzZkpo1a9K4cWOaNGnCyJEjy12GiMWLF9OhQweys0vWhWZnZ9OhQ4eiskaL18SmUaNGpdqgJzJ+/HhycnLo0qULCxcuLHr169ePWbNm8dlnnxWlXbBgAc2bN6dZs2ZJ17lgwQL2339/8vPzUypDOtq3bx93fqrnZcWKFaxevZrOnTsnbM8eMXDgQOrVq1eiff348ePJzc3l3HPPraQ9Sp9qypOolZfN/nvXZfbi1TSrl0+Tunns3bDi3TaJiIiUUMEa6V1Vfn4+Z555Jvfffz8ffPABPXv25Mknn2Sfffahb9++RenGjh3L7373O/r27csVV1zBXnvtRW5uLsuWLWPw4MHs2LEj7W172PVfvAAtsizamWeeycsvv8zQoUM56qijaNiwIdnZ2bzyyivcdddd5SpDRUTX7keLV/ZYGzZsYOrUqWzfvp0uXbrETTNhwgTuvvvuonWWFchGpJIuUZqCgoK48wFq1aoVd36q5yXZ+Y5Vs2ZNzj77bB566CG+//57atWqxbPPPkv//v1p0qRJmfmrioLyMnRu04CXP1pGk3r5dGnTIOWLVkRERIImLPfffz8TJ05k1apVfP/994wcObJE0Pnkk0/SqlUrXn311RLNDF577bVyb7dt27YAzJs3r1St87x580pMr1mzhpdffplzzjmHBx98sMSyN998s9S6040F2rRpwxdffEFBQUGJ2vKCggK+/PLLuLXiFTF16lQ2bNjAzTffzH777Vdq+V/+8hcmTZrE7bffTm5uLh06dGDatGn88MMPSWvL27dvz7x589i6dSt5eXkJ0zVsGLQqWLVqVdH/QNw7Asmkc16aNGlCgwYNkg5YFW3o0KHcd999PPHEE9SrV6/Eg8eZouYrZejSpgFrN21n4Xfr6az+yUVERNLStWtXOnfuzDPPPMO4ceMwM84777wSabKysjCzErXABQUF3HrrreXebv/+/TEzxo4dS2FhYdH8Tz75pFRAF/mBEFsL/d133/Hoo4+WWnft2rWBIOhMxcknn8zy5ctLreuRRx5h+fLlnHLKKSmtJ1Xjx4+nYcOGDB8+nAEDBpR6DRkyhJUrVzJt2jQAzjrrLACuvvrqUncEoo/JWWedxerVq+OODBqdLtIUJfY4//nPf05rP9I5LzVq1OCMM85g7ty5cbt9jF1Hp06d6NGjBxMmTGD8+PG0bNmyxN2bTFBNeRm6RAXieshTREQkfUOGDOHyyy/n9ddfp1evXkW12BEDBgzguuuu44QTTuDUU09l3bp1TJkypUKDAe2///4MGzaMcePG0bt3b37961/z448/Mm7cOA455BBmz55dlLZOnTr07duXSZMmUbNmTQ499FD+97//8dBDD9G6detS7bh/9rOfAXDNNddw1llnkZ+fz0EHHcRBBx0UtyxXX301f/3rXxk2bBiffPIJXbp0Yfbs2YwfP54OHTpw9dVXl3s/Y82fP58PPviAwYMHl2rDHtG/f39ycnIYP348p512GqeddhoDBw7kiSeeYMGCBfTv358GDRrw5Zdf8vrrr/P5558DcOWVV/LSSy8xZswYPvroI/r27Ut+fj5z5szhiy++KArCzzjjDEaMGMHQoUOZP38+jRo14tVXX2XFihVp7Uu652XMmDFMnz6dCy64gDfeeIMjjjgCd2f27NkUFBTw5JNPlkg/dOhQLrjgAgBuuOGGzA/4lG53LT/lV7pdIrq7FxTu8DZD/+Z7DnrOV2/YWnYGERGRBKpbl4gRq1at8vz8fAf8iSeeKLW8oKDAb775Zm/btq3n5uZ6y5Ytffjw4T537txS3R+m2iWie9AN3pgxY7xly5aem5vrBx54oE+aNClul4bLly/3IUOGePPmzT0vL88POuggf/jhh+N2cegedA/YunVrz87OLlGeROl//PFHv+SSS3zvvff27Oxs33vvvf3SSy8t6hYyIlF+d/ejjz7a99133zhHuNjvf/97B/zFF19Mmq5v375eo0YN//rrr4uO1bhx47xLly5es2ZNr127th988ME+evToEvk2b97sY8aM8QMOOMDz8vK8Xr163r1791LdPX744Yd+2GGHeV5enjdq1MgvvPBCX716dcIuEWPPZ0S652X16tU+fPhwb9u2refk5HjDhg39iCOO8GeeeabUujds2OB169b1GjVq+JIlS5Ier2hV1SWieQoPDFQVMzseuAfIAh5191tjlg8Hzgons4GOQBN3X2Vm9YFHgYMAB853938l21737t191qxZaZfz17e+yw9rtvDerZm9rSEiIj9t8+bNi9vtm4jsfFu3bqV58+YceuihaQ1Qlcr72Mw+dvfu6ZQnY81XzCwLuA84DlgKfGRmL7r73Egad78DuCNMfxJwlbtHGnDdA7zm7gPMLBeI/9huJbhjcFe2bC8sO6GIiIiI/CRMnjyZ1atXc9FFF2W6KEBm25T3ABa6+yIAM3sa+BUwN0H6M4CnwrR1gaOAwQDuvg3YVlUFbbNn7apatYiIiIjsRC+99BL/+9//GD16NAcccAC/+tWvMl0kILNB+d7AN1HTS4Ge8RKaWS3geOCycFYbYDkw0cwOAT4GrnT3jVVXXBERERH5qbv88sv59ttv6datG48++mjCPuF3tkwG5fE6+UzUwP0k4P2opivZQFfgcnefaWb3ANcCfyi1EbOhwFCAli1bVrjQIiIiIvLTtWTJkkwXIa5M9v2yFGgRNb0P8G2CtKcTNl2JyrvU3WeG088SBOmluPvD7t7d3btncpQmEREREZFEMhmUfwTsZ2atwwc1TwdejE1kZvWAo4FpkXnu/j3wjZl1CGcdS+K26CIiIiIiu7SMNV9x9wIzuwx4naBLxAnuPsfMLg6XR8ZTPQV4I0578cuByWFAvwg4DxERERGRn6CMjujp7q8Ar8TMezBm+jHgsTh5PwXS6v9RREQk09wds3iPVYnIrq4qx/fJ8HiiIiIi1Udubi6bN2/OdDFEpJw2b95MTk5OlaxbQbmIiMhO0rhxY5YuXcqqVavYvn17lda6iUjlcXc2bdrEsmXLaNq0aZVsI6PNV0RERKqTevXqkZeXx/Lly1m5ciUFBQWZLpKIpCgnJ4dmzZpRt27dKlm/gnIREZGdKD8/nxYtWpSdUESqFTVfERERERHJMAXlIiIiIiIZpqBcRERERCTDFJSLiIiIiGSYgnIRERERkQxTUC4iIiIikmEKykVEREREMkxBuYiIiIhIhikoFxERERHJMAXlIiIiIiIZpqBcRERERCTDFJSLiIiIiGSYgnIRERERkQxTUC4iIiIikmEKykVEREREMkxBuYiIiIhIhikoFxERERHJMAXlIiIiIiIZpqBcRERERCTDFJSLiIiIiGSYgnIRERERkQxTUC4iIiIikmEKykVEREREMkxBuYiIiIhIhikoFxERERHJMAXlIiIiIiIZpqBcRERERCTDFJSLiIiIiGSYgnIRERERkQxTUC4iIiIikmEKykVEREREMkxBuYiIiIhIhikoFxERERHJMAXlIiIiIiIZpqBcRERERCTDUg7KzaxmVRZERERERKS6Sqem/Dsze8DMulVZaUREREREqqF0gvIPgAuAf5vZp2Z2mZnVr6JyiYiIiIhUGykH5e5+IrAvcD2wB/AX4Fszm2xmx1RR+UREREREdntpPejp7t+6+5/cfT/gWOB54GTgTTP7ysxGmNleVVFQEREREZHdVbl7X3H3t939bGAvYDLQGrgJWGJmL5hZj0oqo4iIiIjIbq3cQbmZNTazq4D3gbOBjcBE4BGgN/CBmV1YKaUUEREREdmNpRWUW+B4M/srsBT4M7AVuBTYy90vcPdhQEtgBvCHSi6viIiIiMhuJzvVhGZ2IzAY2JugVvxx4GF3/zg2rbuvNbPHgccqp5giIiIiIruvlINyYBTwMUG78SnuvrGM9J8AN5a3YCIiIiIi1UU6QXlXd/801cTuPgeYk36RRERERESql3T6KS8RkJtZTTOrWflFEhERERGpXtJ90LOpmd1vZt8CG4ANZvZdOK9Z1RRRRERERGT3lnJQbmatgdnAxcBaYBrwIrAmnPeJmbVJZ+NhTy5fmNlCM7s2zvLhZvZp+PrczArNrGHU8iwzm21mL6ezXRERERGRXUk6NeV/BhoBp7p7R3c/1d1PcfeOwK/DZXemujIzywLuA04ADgDOMLMDotO4+x3u3tndOwPXAe+4+6qoJFcC89LYBxERERGRXU46QfmxwH3u/rfYBe7+AvBAmCZVPYCF7r7I3bcBTwO/SpL+DOCpyISZ7QP8Ang0jW2KiIiIiOxy0gnKHViQZPmXYZpU7Q18EzW9NJxXipnVAo4HnouafTdwNbAj2UbMbKiZzTKzWcuXL0+jeCIiIiIiO0c6Qfk7wDFJlvciGMUzVRZnXqKg/iTg/UjTFTP7JfBjvIGLSq3Q/WF37+7u3Zs0aZJG8UREREREdo50gvLfAD3N7M9m1jQyM+yRZSzQM0yTqqVAi6jpfYBvE6Q9naimK8DhQH8zW0LQ7KW3mU1KY9siIiIiIrsMc0+txYmZLQL2ABqHs9YQ1Gw3CKdXALGjfLq7t02wvmyCJi/HAsuAj4Azw0GHotPVAxYDLeKNImpmvYDfu/svy9qH7t27+6xZs8pKJiIiIiJSbmb2sbt3TydPOiN6fk16bcaTcvcCM7sMeB3IAia4+xwzuzhc/mCY9BTgjXgBuYiIiIjI7iDlmvLdgWrKRURERKSqlaemPK0RPUVEREREpPKl03wFADNrS9CfeGT0zkXANHf/qjILJiIiIiJSXaQVlJvZTcC1BG3Ao91uZje7+/WVVjIRERERkWoi5eYrZnY+MBKYSfDw5X7h62TgX8BIMzuvKgopIiIiIrI7S6emfBhBQN7L3Qui5n9lZq8A/wQuAyZWYvlERERERHZ76Tzo2RF4OiYgB4LuDQkG8elYWQUTEREREaku0gnKtwG1kyyvE6YREREREZE0pBOUfwRcZGbNYheYWVNgKEHzFhERERERSUM6bcpvAt4C5pnZeGBuOP9A4DyCmvKzKrd4IiIiIiK7v5SDcnd/18xOBcYBv4tZ/DUwyN3/WZmFExERERGpDtLqp9zdXzKzvwPdgNaAAV8Bn7j7jioon4iIiIjIbi+loNzMagP/Ae5197sJ2pd/VJUFExERERGpLlJ60NPdNwCNgA1VWxwRERERkeonnd5XPgS6V1VBRERERESqq3SC8muB/zOz88zMqqpAIiIiIiLVTToPeo4FVgOPAreb2VfAppg07u7HVlbhRERERESqg3SC8jaAE3R/CFBqECEREREREUlfOv2Ut6rCcoiIiIiIVFsptyk3s5ZmVjPJ8ppm1rJyiiUiIiIiUn2k86DnYuCUJMv7h2lERERERCQN6QTlZfW4UoOgzbmIiIiIiKQhnaAckgfdHYE1FSiLiIiIiEi1lPRBTzMbBAyKmjXKzC6Mk7QhcBDwQiWWTURERESkWiir95X6QOvwfweaALVi0jiwAZgAjKzU0omIiIiIVANJg3J3vwe4B8DMdgC/cfcpO6NgIiIiIiLVRTr9lKfb/lxEpspIKgAAIABJREFURERERFKgQFtEREREJMPSCsrN7HQze9/MfjSzwjivgqoqqIiIiIjI7irl5itmNhy4FVgJfBj+FRERERGRCko5KAeGATOBY919cxWVR0RERESk2kmn+cqewCQF5CIiIiIilSudoHwhQb/lIiIiIiJSidIJyv8MDDGzOlVVGBERERGR6iidNuWFwI/APDObACwO55Xg7k9UUtlERERERKqFdILyx6L+H5UgjQMKykVERERE0pBOUH5MlZVCRERERKQaSzkod/d3qrIgIiIiIiLVVVojekaYWZ6Z7W1muZVdIBERERGR6iatoNzMuprZdGA98DVwRDi/qZm9ZWZ9qqCMIiIiIiK7tZSDcjPrDPwTaEvMw5zu/iNQExhUqaUTEREREakG0qkpvxH4FjgQuBawmOVvAT0qqVwiIiIiItVGOkH5kcAj7r6BoOvDWF8De1VKqUREREREqpF0gvJ8YG2S5XUrWBYRERERkWopnaD8K6BbkuW9gbkVK46IiIiISPWTTlA+BTgnpocVBzCz3wHHA09WYtlERERERKqFdEb0vBM4DngdmE8QkN9lZk2APYF/APdXeglFRERERHZzKdeUu/s2gqD898BmYAvQHlgBXA380t13VEUhRURERER2Z+nUlOPuBcBd4UtERERERCpBWiN6JmJmeZWxHhERERGR6iidET1PMLPRMfMuNbN1wEYzm2JmOZVdQBERERGR3V06NeXDgf0jE2bWEbiHYJTPfwADgWGVWjoRERERkWognaC8IzAranogwQOfPdz9BOAZYFA6Gzez483sCzNbaGbXxlk+3Mw+DV+fm1mhmTU0sxZm9raZzTOzOWZ2ZTrbFRERERHZlaQTlDcg6Gklog8w3d3XhdMzgNaprszMsoD7gBOAA4AzzOyA6DTufoe7d3b3zsB1wDvuvgooAH7n7h2BnwHDYvOKiIiIiPxUpBOUrwD2BTCzOsChwHtRy3OArDTW1wNY6O6Lwu4WnwZ+lST9GcBTAO7+nbt/Ev6/HpgH7J3GtkVEREREdhnpdIn4L+BiM5tDULudDbwStbwd8F0a69sb+CZqeinQM15CM6tFMGLoZXGWtQK6ADPT2LaIiIiIyC4jnaD8BuBtYGo4/bi7zwUwMwNOCZenyuLM8wRpTwLeD5uuFK/ArDbwHPCbqGY0xKQZCgwFaNmyZRrFExERERHZOVIOyt19btjjyuHAWnd/N2pxfYIBhWakse2lQIuo6X0IenKJ53TCpisRYfeLzwGT3f35JOV+GHgYoHv37omCfhERERGRjEl3RM9VwEtx5q8m6B4xHR8B+5lZa2AZQeB9ZmwiM6sHHA2cHTXPgPHAPHcfm+Z2RURERER2KekMHtQorCmPntfazO41s8lm1i+dDbt7AUEb8dcJHtSc6u5zzOxiM7s4KukpwBvuvjFq3uHAOUDvqC4TT0xn+yIiIiIiuwpzT61Fh/1/e/cfJ1dd33v89cnOQjY/+KEEDb+xFSxSRchFxVukAgqKoLe3FZSHP+69cq2lF+21gnq1WFtt1fba9gEqRQpKq7VKlWsRROWHVLEEiZgQkRgRgkACiAkhgd3kc/84Z5PJMjs7Z3Z3zmT39Xw89jEz53xn5pPzmJ28883nfE/E5cAhmXl0+XgB8GNgn3LIVuBlY9pa+sqSJUty6dKlEw+UJEmSuhQRt2bmkirPqbIk4ouBrzc9fh1FIH9lebsSeHeVN5ckSZJULZQ/A7in6fHJwNLMvDozHwAupViaUJIkSVIFVUL5MDDU9PilwA1Njx8Fnj4VRUmSJEmzSZVQ/hPgd6JwKvA04FtN+/cHHmn5TEmSJEnjqrIk4gUULSq/BOYBq9kxlB8L/GjKKpMkSZJmiSoXD/psRGylWKLwV8CHM3MYiuUSgd2BC6elSkmSJGkGq3rxoMuBy1tsfxg4aqqKkiRJkmaTSqF8VDkzfnD58GdlKJckSZLUhSonehIRz4+IG4C1wPfLn7URcX1EPG86CpQkSZJmuo5nyiPicOAmYC5wJbC83PVc4NXAdyLimMxcMeVVSpIkSTNYlfaVP6VYq/yYzNxhlZUysN9YjvmdqStPkiRJmvmqtK8cC1wwNpADZOZyipVXXjpVhUmSJEmzRZVQPh94oM3++8sxkiRJkiqoEspXA6e02X9KOUaSJElSBVVC+WeBV0TEP0XEcyNioPw5PCL+EXg5xRU/JUmSJFVQ5UTPjwNHAqcDrwO2ltvnAAF8EfirKa1OkiRJmgU6DuWZuQV4XURcDLyG4uJBAfwU+EpmfnN6SpQkSZJmto5CeUTMB/438P3MvAa4dlqrkiRJkmaRjnrKM3Mj8F5g/+ktR5IkSZp9qpzo+VPgmdNViCRJkjRbVQnlFwJvjYinT1cxkiRJ0mxUZfWVDcAjwJ0RcRlwF/D42EGZ+dkpqk2SJEmaFaqE8kub7r9znDFJsZ65JEmSpA5VCeW/PW1VSJIkSbNYlXXKb5jOQnpiZCOs+y4sOqbuSiRJkqRtJjzRMyKeExHPmeyYvvD4vXD7++uuQpIkSdpB21AeEUuAFcArJnidVwDLI+J5U1XYtJgzCJvur7sKSZIkaQcTzZS/FfgZ8HcTjPs7YDXwtqkoatrMGYRNv6i7CkmSJGkHE4Xy44AvZ+bWdoPK/V+m308GjV1g+FcwsqnuSiRJkqRtJgrl+wM/6fC1VgEHTq6caTZnsLjdbAuLJEmS+sdEoXwrna/Q0ijH96/RUP64LSySJEnqHxOF8nuBIzp8rSOANZMrZ5o5Uy5JkqQ+NFEovw44IyKe0W5Quf8M4FtTVdi0cKZckiRJfWiiUP5/gSHgmog4tNWAiDgE+DowF/jE1JY3xaJRBHNnyiVJktRH2vaLZ+ZdEfF24NPAioi4CVgGrAcWAi8AXgIE8NbMvGua6528uYtdq1ySJEl9ZcKTODPzMxHxc+AvgWPLn2a3Aedm5jenob6pN7TYtcolSZLUVzpaWaUM3EdFxEHA4cBuFLPlyzPz7ukqbloM7QMbOl3lUZIkSZp+nS53CEAZwO+elkp6ZWgxrL2+7iokSZKkbSY60XPmGdoHnvwlbNlcdyWSJEkSMCtD+eLi1pM9JUmS1CcM5ZIkSVLNZmEo36e4NZRLkiSpT8zCUD46U+6yiJIkSeoPsy+U77pXcWVPZ8olSZLUJ8ZdEjEiDujmBTPznu7L6YGYA0PPdKZckiRJfaPdOuV3A9nFaw50V0oPzV3sTLkkSZL6RrtQ/qd0F8r737x94LHVdVchSZIkAW1CeWae38M6emvuYlh3U91VSJIkScBsPNETimURn3gYtjxRdyWSJElS2/aVcUXEAmAPWoT6vj/RE7Yvi7j5AZh/YL21SJIkadarFMoj4nTg/wC/0WZY/5/o2XwBIUO5JEmSatZx+0pEvAb4J4og/2kggM8D/wIMAz+gODm0/227gJArsEiSJKl+VXrK3wWsBI4APlBuuyQzTweWAIcAy6q8eUScFBF3RsSqiDivxf4/johl5c/yiNgSEU/r5LlteVVPSZIk9ZEqofx5wGWZuRnYWm4bAMjM5cBFwHs6fbGIGAAuAE4GDgPOiIjDmsdk5scy84jMPKJ87Rsy85FOntvWrosgBpwplyRJUl+oEsoHgIfL+5vK292b9t8JHF7h9Y4GVmXm6sx8EvgCcFqb8WdQtMt089wdzRmAuc9wplySJEl9oUooXwMcCJCZm4C1FG0row4FNlZ4vX2Be8e8/r6tBkbEPOAk4MtVnzuuoX2cKZckSVJfqLL6yneBE9jeT34lcE5EPE4R7v8A+H8VXi9abBvvCqKvBv49Mx+p+tyIOAs4C+CAAw7YvmNoMWzs/9UbJUmSNPNVmSm/ELg+IobKx++jaFk5nyKo/5TiZNBOrQH2b3q8HzBeP8npbG9dqfTczLwoM5dk5pJFixZt3zG02PYVSZIk9YWOZ8oz8xbglqbH64AjIuJ5wBZgZWZuHe/5LdwCPDsiDgbuowjerx87KCJ2B14KnFn1uW0N7QNPrIOtwzBnsNJTJUmSpKnU1RU9m2Xm7V0+byQizgauoTiJ9JLMXBERbyv3f6oc+lrgG5m5caLnVipg27KID8D8/duPlSRJkqZRx6E8Ik4Ajs/MlsseRsRHKMLzdZ2+ZmZeBVw1Ztunxjy+FLi0k+dWssNVPQ3lkiRJqk+VnvJ3A7/eZv/BwLmTK6eHvICQJEmS+kSVUP584OY2+79fjtk5zC1D+WaXRZQkSVK9qoTy3Wm/DvkmYM/JldNDc/eGmONa5ZIkSapdlVB+H3BUm/1HAQ9MrpwemtOAXfe2fUWSJEm1qxLK/w14U3nC5w4i4njgTUzmxMs6eFVPSZIk9YEqSyL+OfA7wDUR8XVgGcVVNF8AnEwxS/6hKa9wOg0thk331V2FJEmSZrkqFw96MCKOAT5JEcJfOboL+DpwdmbuXNPOQ4vhkaV1VyFJkqRZrtLFgzLz58ArI2JPiuURA7grM385HcVNu6F9YPNa2DpS9JhLkiRJNegqiZYh/JYprqX3hhYDCZsfhHn71l2NJEmSZqkqJ3rOPM1X9ZQkSZJqMu5MeURsBbYC8zLzyfJxTvB6mZk7Tx+IV/WUJElSH2gXoD9LEcK3jHk8c2wL5c6US5IkqT7jhvLMfHO7xzPC3GcAYSiXJElSrTrqKY+I+RHxgYh4xXQX1FNzBmHuIttXJEmSVKuOQnlmbgTeC+w/veXUwKt6SpIkqWZVVl/5KfDM6SqkNnMXO1MuSZKkWlUJ5RcCb42Ip09XMbUYWgybnSmXJElSfaosX7gBeAS4MyIuA+4CHh87KDM/O0W19cbQPsXFg7ZugTkDdVcjSZKkWahKKL+06f47xxmTFEsn7jyGFkNuhSfWbl8iUZIkSeqhKqH8t6etijo1X9XTUC5JkqQadBzKM/OG6SykNjtc1fPIWkuRJEnS7FTlRM8dRMReEbHXVBZTC6/qKUmSpJpVCuURsU9EXBYRjwIPAg9GxC8j4tKI2Hd6Spxmc8tVHg3lkiRJqknH7SsRcQBwM8Va5cuAFeWuw4A3AidGxIsy894pr3I6DewCu+7lWuWSJEmqTZUTPT8E7AmckplXNe+IiJOBK8oxb56y6nploqt6rvsubNkMz3xZ72qSJEnSrFGlfeXlwIVjAzlAZn4d+CRw0lQV1lNDba7qufEeuP5kuO1dva1JkiRJs0aVUL4nxQWDxnMXsMfkyqnJ0OLWM+W5FW5+MwyvL34kSZKkaVAllK8Bjmuz/9hyzM5naB/Y/EBxVc9md/4NPHhdsX9kQz21SZIkacarEsr/BfjdiPhIROw+ujEidouIDwO/B/zzVBfYE3MXQ26BJx7avu3R5bDsPbDvqXDQ62HYUC5JkqTpUSWUfwj4HnAu8FBE/Dwifg48DJwHfBf4s6kvsQfmlVf13Fy2sGx5Ar57JgzuBi/8e2gshC2bYOtIfTVKkiRpxuo4lGfm48BLgf8JfAPYCDwOXAOcBfx2Zm6ajiKn3dzyAkKPlyd7/uh8ePSH8MKLYe7eMLiw2D6ysZbyJEmSNLNVWRKRzNwC/H35M3OMXtVz8/2w9iZY+VH4tf8B+51abG8sKG5HNsAuu7d+DUmSJKlLla7oOWONhvL1d8L33gjzDoQj/3r7/kY5U25fuSRJkqZBlSt6fmCCIQlsAu4Brs/MtZMprKcGdoVdngZ3fqI44fOEG7e3rEBT+8pj9dQnSZKkGa1K+8r5FMEbIMbsG7t9OCI+npnvm0RtvTW0D/xqORz2Hlj0kh33jbavVJ0pf/A62LwWDnzd1NQoSZKkGalKKD8cuAx4Avgb4M5y+3OAc8rX+kNgf+CPgPMi4p7M/PTUlTuN9vhNGBiC3zz/qfu2zZRXDOWrLoaHv28olyRJUltVQvlbgc3AceUJn6Nuj4grgOuB0zPzjyLiq8BSipVado5QfszlRevKnMGn7tvWU16xfWV4fbGsoiRJktRGlRM9Twe+OCaQA5CZI8AXgTPGPD50KorsiZjTOpBD9zPlI+t37E2XJEmSWqgSyncvfzrd/xDbe813bt32lA9vgIYz5ZIkSWqvSij/IfD2iDhw7I6IOAh4O7CsafOhwP2TKa5vNOYDUX2m3PYVSZIkdaBKT/l5FFfvXBkRXwF+Um4/FDiNIuCfARARuwJvAL42daXWKKKYLe+qp9z2FUmSJLXXcSjPzBsi4gTgryn6y5stBd6VmTeWY58oZ9SHp6zSug0u6KKnfIMz5ZIkSZpQlZlyMvMm4OiI2Bs4mGJd8tWtLhSUmU9MTYl9orGwWk/5lidhy2ZDuSRJkiZUKZSPKkP4znPFzqkwuLDaFT1HZ9Ubtq9IkiSpvSonehIRAxHxxoi4PCKujYgXlNv3LLfvOz1l9oFGxfaV0Vl1Z8olSZI0gY5nyiNiHvAN4BhgIzAP2LPcvR74C+AS4P9McY39obEQNt3X+fjh9cWtoVySJEkTqDJTfj6wBHgt8CyKfnIAygsKXQG8YiqL6ytV21e2hXLbVyRJktRelVD+u8BFmflVYGuL/auAg6aiqL7UWFDtRE9nyiVJktShKqF8H4oLCI3ncWDmTgsPLqzWUz5iT7kkSZI6UyWUPwy0O5HzucAvJldOH2sshJGNkK3+k6CF0ZlyV1+RJEnSBKqE8m8BbylP+NxBRBwM/Dfg6qkqrO+M9oaPbOxsvO0rkiRJ6lCVUP5BitVWbgF+H0jgpIj4CPAD4AngI1NeYb9oLChuO+0rHx03+jxJkiRpHB2H8sxcBRwPjAB/SrH6yruAc4F7geMz894qbx4RJ0XEnRGxKiLOG2fMcRGxLCJWRMQNTdvfWW5bHhGfj4i5Vd67sm0z5Z2G8vXQmA9zBqavJkmSJM0Ila7omZm3As+PiMOB36AI5ndl5m1V3zgiBoALgBOBNcAtEXFlZt7RNGYP4ELgpMy8JyL2LrfvC/wv4LDM3BQRXwROBy6tWkfHRnvDO10WcWS9rSuSJEnqSJWLBx0LrMzMdZm5HFg+Zv9eFCH5xg5f8mhgVWauLp//BeA04I6mMa8HrsjMewAyc+2Y2ociYpjiQkbTe5LpYBftK4ZySZIkdaBKT/l1FLPa4zm+HNOpfSnaXkat4amruxwC7BkR10fErRHxRoDMvA/4OHAPcD/wq8z8RoX3rm50przjUL7elVckSZLUkSqhPCbYP0DriwpVeb0c87gBHAW8iuJqoe+PiEMiYk+KWfWDKdZPnx8RZ7Z8k4izImJpRCxdt25dhfLGGKzYvjJs+4okSZI6UyWUw1NDc7NjgIcqvNYaYP+mx/vx1BaUNcDVmbkxMx8CbgSeD5wA/KxspRkGrijf/6kFZ16UmUsyc8miRYsqlDfG6CoqnZ7oOWL7iiRJkjrTNpRHxDkRsToiVpebPjH6eMzPLymWSfxahfe+BXh2RBwcEbtQnKh55ZgxXwV+KyIa5froLwRWUrStvCgi5kVEULTOrKzw3tUNdtG+YiiXJElSByY60fNR4Ofl/YMorur54JgxSXHS583AJzp948wciYizgWsoWl8uycwVEfG2cv+nMnNlRFwN3E7RGnNxeZIpEfElivXRR4DbgIs6fe+uDMwvbu0plyRJ0hRrG8oz8zLgMoCI+BlwXmaOnc3uWmZeBVw1Ztunxjz+GPCxFs/9E+BPpqqWCc0ZgIF5nfWUZ7r6iiRJkjrW8ZKImXnwdBayUxhc2FlP+ZbNkCOGckmSJHWk6omes1tjYWftK8Pri9tB21ckSZI0sUqhPCJeEhFfi4h1ETESEVvG/IxMV6F9YXBhZ+0ro7PpzpRLkiSpAx2H8vKKntdRrIDy/fK511GsohIUJ3t+bhpq7B+NBRVnyg3lkiRJmliVmfL3UVw98zDgzeW2D2fmi4CTKC7kc/GUVtdvOu0pHw3lrr4iSZKkDlQJ5UdTLEm4ju1X7pwDUF7i/nPAh6a2vD7T6LB9Zdj2FUmSJHWuSijfFbivvP9Eeds8FbwMOGoqiupbg7avSJIkaepVCeX3A/sBZOZGigsLHd60fz+KC/nMXJ2uvjLi6iuSJEnqXMfrlFOc0PmSpsffAN4ZET+nCPdnU5wAOnONrr6SCRHjj7N9RZIkSRVUmSn/DPBQRAyVj98LbAIuBS6haGl595RW128aC4CELY+3Hze8HmJOcQVQSZIkaQJVruh5LXBt0+PVEXEIcDywBbgpM3819SX2kdF2lOEN0Jg//rjh9UWrS7vZdEmSJKlUpX3lKcre8iunqJb+12gK5UPPHH/cyAZbVyRJktSxtu0rETEQEX8REW+bYNzvR8SHI2b41HBjQXE70bKIw+sN5ZIkSerYRD3lZwJ/THGSZzv/AZwLnDEVRfWt0faViS4gNNq+IkmSJHVgolD+e8A3M/PWdoPK/dcw00N5c/tKO8O2r0iSJKlzE4Xyo4Bvdvha1wFLJldOn9s2U277iiRJkqbORKH8acDaDl9rXTl+5hrtKZ9wpny9Fw6SJElSxyYK5RuAvTp8racDE0wh7+Q67Sl39RVJkiRVMFEoXwG8vMPXOrEcP3Ntmylv82+P3GpPuSRJkiqZKJRfAZwQEae1GxQRp1KE8i9PVWF9aU4DBua2nykf2Qikq69IkiSpYxOF8k8Dq4AvRsSfR8RBzTsj4qCI+DPgi8BPyvEzW2Nh+57y0X3OlEuSJKlDba/omZmbIuJVwNeA9wDnRcQGYD2wENgNCOBO4JTM3DzN9dZvcGH7mfLh9eU4Q7kkSZI6M9FMOZm5CjgCOAe4CRgBnglsAb5Tbj8yM386jXX2j8aC9ksibgvltq9IkiSpM21nykeVM+B/V/7MboMTtK+M2L4iSZKkaiacKdcYE/aU274iSZKkagzlVXXavuLqK5IkSeqQobyqCU/0tH1FkiRJ1RjKq5qofWXE9hVJkiRVYyivanBh0b6S2Xr/8HqYMwgDu/a2LkmSJO20DOVVNRZAboEt4yzJPrzeWXJJkiRVYiivanT98fH6yoc3QMNQLkmSpM4ZyqsaXVVlvL7y4fVeOEiSJEmVGMqrGlxQ3I63LKLtK5IkSarIUF7VRDPlIxsM5ZIkSarEUF7VhD3lzpRLkiSpGkN5VY0O2le8mqckSZIqMJRXNTjRiZ62r0iSJKkaQ3lV7XrKt47AlscN5ZIkSarEUF5Vu/aV0T5zl0SUJElSBYbyqgZ2gTm7tD7Rc3T23JlySZIkVWAo78bgwtbtK8Pry/2GckmSJHXOUN6NxgSh3NVXJEmSVIGhvBuNBa17ym1fkSRJUhcM5d0YXNi6p3zE9hVJkiRVZyjvxkTtK66+IkmSpAoM5d0YtH1FkiRJU8dQ3g1P9JQkSdIUMpR3Y7ye8uH1MDAEcxq9r0mSJEk7LUN5N8ZbfWVkg60rkiRJqsxQ3o3BhbB1GLY8seP24fWGckmSJFVmKO/GaM/42L7y4fX2k0uSJKkyQ3k3GguK27F95cO2r0iSJKm6WkN5RJwUEXdGxKqIOG+cMcdFxLKIWBERNzRt3yMivhQRP46IlRHx4p4VProO+di+cttXJEmS1IXalgmJiAHgAuBEYA1wS0RcmZl3NI3ZA7gQOCkz74mIvZte4m+AqzPzv0bELsC8nhXfrn3FCwdJkiSpojpnyo8GVmXm6sx8EvgCcNqYMa8HrsjMewAycy1AROwGHAt8ptz+ZGY+2rPKB8cJ5a6+IkmSpC7UGcr3Be5terym3NbsEGDPiLg+Im6NiDeW258FrAP+ISJui4iLI2J+qzeJiLMiYmlELF23bt3UVL6tp9z2FUmSJE1enaE8WmzLMY8bwFHAq4BXAO+PiEPK7UcCn8zMFwAbgZY96Zl5UWYuycwlixYtmprKt/WUN82Ub3kCtj7p6iuSJEmqrM5QvgbYv+nxfsAvWoy5OjM3ZuZDwI3A88vtazLz++W4L1GE9N5o1VM+et+ZckmSJFVUZyi/BXh2RBxcnqh5OnDlmDFfBX4rIhoRMQ94IbAyMx8A7o2IQ8txxwN30CuDLdpXRtaX+wzlkiRJqqa21VcycyQizgauAQaASzJzRUS8rdz/qcxcGRFXA7cDW4GLM3N5+RJ/CPxjGehXA2/pWfFzdoVojJkpHw3ltq9IkiSpmtpCOUBmXgVcNWbbp8Y8/hjwsRbPXQYsmdYCxxNRhO8R21ckSZI0eV7Rs1uNBTu2r4zOlDcM5ZIkSarGUN6twYW2r0iSJGlKGMq71RgTykdsX5EkSVJ3DOXdekpPuauvSJIkqTuG8m6N21Pe8sKikiRJ0rgM5d0a274yvKHYFh5SSZIkVWOC7Far9hVbVyRJktQFQ3m3GgtgeEz7iiuvSJIkqQuG8m4NLoStT8DW4eLxyAZnyiVJktQVQ3m3GuWs+Ghfue0rkiRJ6pKhvFuDC4rb0RVYDOWSJEnqkqG8W0+ZKd+wfZskSZJUgaG8W6MndY7YviJJkqTJMZR3q1G2rwxvgEwYMZRLkiSpO4bybm2bKX8MtjwOudUlESVJktQVQ3m3mnvKR/vKnSmXJElSFwzl3WruKR9eX9xvGMolSZJUnaG8W42mJRFHQ7ntK5IkSeqCobxbA0MQc4rWlRHbVyRJktQ9Q3m3Ioq+8uGm9hVDuSRJkrpgKJ+MxoId21e8eJAkSZK6YCifjMGF5Ymetq9IkiSpe4byybB9RZIkSVPAUD4Zgwu2L4kYAzAwt+6KJEmStBMylE9GYyEMP1YE88HdipM/JUmSpIoM5ZOxrad8va0rkiRJ6pqhfDIaC7b3lLvyiiRJkrpkKJ+MwYXlkogbnCmXJElS1wzlk9FYCFs2wZOPGMolSZLUNUP5ZAyWLSub7t9+X5IkSarIUD4ZjQXF7eYHnSmXJElS1wzlk7Ht5M6EhqFckiRJ3TGUT0Zzy4rtK5IkSeqSoXwyRttXwPYVSZIkdc1QPhk7zJQbyiVJktQdQ/lkNF8wyIsHSZKMLDbzAAAM50lEQVQkqUuG8skYtH1FkiRJk2con4yG7SuSJEmaPEP5ZDTmAVHcd/UVSZIkdclQPhkxBxrzi/vOlEuSJKlLhvLJGp0hN5RLkiSpS4byyRrtK3f1FUmSJHXJUD5Zgwthzq4wsEvdlUiSJGknZSifrMYCW1ckSZI0KYbyyWosdOUVSZIkTUqj7gJ2ege9AR6/t+4qJEmStBMzlE/WQafXXYEkSZJ2cravSJIkSTUzlEuSJEk1M5RLkiRJNTOUS5IkSTWrNZRHxEkRcWdErIqI88YZc1xELIuIFRFxw5h9AxFxW0R8rTcVS5IkSVOvttVXImIAuAA4EVgD3BIRV2bmHU1j9gAuBE7KzHsiYu8xL3MOsBLw6j2SJEnaadU5U340sCozV2fmk8AXgNPGjHk9cEVm3gOQmWtHd0TEfsCrgIt7VK8kSZI0LeoM5fsCzVfdWVNua3YIsGdEXB8Rt0bEG5v2fQJ4N7B1esuUJEmSpledFw+KFttyzOMGcBRwPDAEfC8ibqYI62sz89aIOK7tm0ScBZwFcMABB0y2ZkmSJGnK1TlTvgbYv+nxfsAvWoy5OjM3ZuZDwI3A84GXAKdGxN0UbS8vi4jLW71JZl6UmUsyc8miRYum+s8gSZIkTVqdofwW4NkRcXBE7AKcDlw5ZsxXgd+KiEZEzANeCKzMzPdk5n6ZeVD5vG9n5pm9LF6SJEmaKrW1r2TmSEScDVwDDACXZOaKiHhbuf9TmbkyIq4GbqfoHb84M5fXVbMkSZI0HSJzbBv3zLVkyZJcunRp3WVIkiRpBouIWzNzSZXneEVPSZIkqWaGckmSJKlmhnJJkiSpZoZySZIkqWaGckmSJKlms2r1lYhYB2wEHqq7ltJeWEsr/VQL9Fc91tKatbTWT7VAf9VjLa1Zy/j6qR5raa2fajk0MxdWeUJt65TXITMXRcTSqkvUTBdraa2faoH+qsdaWrOW1vqpFuiveqylNWsZXz/VYy2t9VstVZ9j+4okSZJUM0O5JEmSVLPZGMovqruAJtbSWj/VAv1Vj7W0Zi2t9VMt0F/1WEtr1jK+fqrHWlrbqWuZVSd6SpIkSf1oNs6US5IkSX1l1oTyiDgpIu6MiFURcV4f1HN3RPwoIpZ1c4buJN/7kohYGxHLm7Y9LSKujYi7yts9a6zl/Ii4rzw2yyLilT2qZf+IuC4iVkbEiog4p9ze82PTppaeH5uImBsR/xERPyxr+WC5va7PzHj11PW5GYiI2yLia+XjWo5Lm3rqOi5P+Y6r8TPTqpa6jsseEfGliPhx+fv94jo/M+PUU8f3zKFN77csItZHxDtq+v4dr5a6PjPvLL/rlkfE58vvwLp+l1rVUtdxOaesY0VEvKPcVtdxaVVL5eMyK9pXImIA+AlwIrAGuAU4IzPvqLGmu4Elmdnz9TQj4ljgMeCzmXl4ue2jwCOZ+RdR/KNlz8w8t6Zazgcey8yPT/f7j6llMbA4M38QEQuBW4HXAG+mx8emTS2/R4+PTUQEMD8zH4uIQeAm4Bzgv1DPZ2a8ek6ins/NHwFLgN0y85S6fpfa1HM+9RyXuxnzHVfj90yrWs6nnuNyGfCdzLw4InYB5gHvpabPzDj1vIMajk1TTQPAfcALgT+g3t+n5lreQu+/f/el+I47LDM3RcQXgauAw+j930vj1XIQvT8uhwNfAI4GngSuBn4feCu9Py7j1fIGKh6X2TJTfjSwKjNXZ+aTFAfvtJprqk1m3gg8MmbzacBl5f3LKAJgXbXUIjPvz8wflPc3ACuBfanh2LSppeey8Fj5cLD8Ser7zIxXT89FxH7Aq4CLmzbXclza1NNPajs2/SAidgOOBT4DkJlPZuaj1HRc2tRTt+OBn2bmz6n/M9NcS10awFBENCj+0fQL6jsurWqpw28AN2fm45k5AtwAvJZ6jst4tVQ2W0L5vsC9TY/XUFPAaZLANyLi1og4q+ZaAJ6RmfdDEQiBvWuu5+yIuD2K9pae/vc/QEQcBLwA+D41H5sxtUANxyaKlohlwFrg2sys9biMUw/0/th8Ang3sLVpW52fl1b1QD2/T62+4+o6NuN93/b6uDwLWAf8QxQtRhdHxHzqOy7j1QP1fgefDny+vF/3303NtUCPj0tm3gd8HLgHuB/4VWZ+gxqOS5taoPefl+XAsRHx9IiYB7wS2J96Pi/j1QIVj8tsCeXRYlvdfTsvycwjgZOBPyjbOFT4JPBrwBEUv/h/1cs3j4gFwJeBd2Tm+l6+dwe11HJsMnNLZh4B7AccXf53XW3GqaenxyYiTgHWZuat0/k+nWpTT12/T/30HdeqljqOSwM4EvhkZr4A2AjUeY7TePXU9h1cttCcCvxLr96zQi09Py5lkDsNOBjYB5gfEWdO9/tWrKXnxyUzVwJ/CVxL0S7yQ2Bkut+3Yi2Vj8tsCeVr2P6vFij+Iq/rv1wAyMxflLdrgX+laLGp04NlH/NoP/PaugrJzAfL0LUV+Ht6eGzKHuUvA/+YmVeUm2s5Nq1qqfPYlO//KHA9Rf927Z+Z5npqODYvAU4t+5W/ALwsIi6nvuPSsp66PjPjfMfVcmxa1VLTcVkDrGn6n50vUYTiuj4zLeup+XvmZOAHmflg+bjO75kdaqnpuJwA/Cwz12XmMHAFcAz1HJeWtdT4HfOZzDwyM4+laIO9i/q+Y55SSzfHZbaE8luAZ0fEweW/fE8HrqyrmIiYH8XJe5T/Vfhyiv/+qNOVwJvK+28CvlpXIaO/UKXX0qNjExFB0Vu5MjP/umlXz4/NeLXUcWwiYlFE7FHeH6L4Yv4xNX1mxqun18cmM9+Tmftl5kEU3ynfzswzqem4jFdPTZ+Z8b7j6vhdallLHcclMx8A7o2IQ8tNxwN3UN9npmU9dX0Hl85gx3aROv9u2qGWmo7LPcCLImJe+ffC8RTnGNVxXFrWUuPf2XuXtwdQLDzweer7e+kptXR1XDJzVvxQ9Pj8BPgp8L6aa3kWxX9v/BBY0et6KD649wPDFDMl/x14OvAtin9pfgt4Wo21fA74EXA7xS/Y4h7V8p8p2ppuB5aVP6+s49i0qaXnxwZ4HnBb+Z7LgQ+U2+v6zIxXTy2fm/K9jwO+VudxaVNPHZ+Zlt9xNf0ujVdLXd8zRwBLy/f9CrBnnZ+Zceqp69jMAx4Gdm/aVtf3TKta6jouH6SYCFle1rBrjcelVS11HZfvUPyj9ofA8TV/XlrVUvm4zIolESVJkqR+NlvaVyRJkqS+ZSiXJEmSamYolyRJkmpmKJckSZJqZiiXJEmSamYolyRNu4i4vrywkSSpBUO5JO2kIuK4iMg2P7VcdlqSVF2j7gIkSZP2eeCqFtu39roQSVJ3DOWStPP7QWZeXncRkqTu2b4iSTNcRBxUtrOcHxFnRMTtEbE5Iu4ptz1lgiYinhcR/xoRD5dj74iId0fEQIuxz4yIv42I1RHxRESsjYhrI+LEFmP3iYjPR8QvI2JjRFwTEYdM159dknYWzpRL0s5vXkTs1WL7k5m5vunxq4F3ABcADwCnAn8CHAi8ZXRQRCwBbgCGm8a+GvhL4PnAG5rGHgT8O/AM4LPAUmA+8CLgBODapvefD9wI3Ay8FzgYOAf4akQcnplbuvnDS9JMEJlZdw2SpC5ExHHAdW2G/FtmnlIG559R9Jj/p8z8Qfn8AK4AXgO8ODNvLrf/O/BC4MjMvL1p7D8DvwuckJnfKrdfBZwMnJSZ14ypb05mbi3vXw+8FDg3Mz/aNOaPgY+2er4kzSa2r0jSzu8i4MQWP+8bM+7a0UAOkMWszGhAfi1AROwNHANcORrIm8Z+eMzYpwEnAVe3CtSjgbzJVuBvx2z7dnn77An/lJI0g9m+Ikk7v7sy85sdjFvZYtsd5e2zytuDy9sV44zd2jT214EAbuuwzl9k5uYx2x4ub5/e4WtI0ozkTLkkzR6d9CtGhdcbHdtpH2S7nvEq7ytJM46hXJJmj8PabFs95va5LcY+h+LvjdExd1EE8hdMVYGSNFsZyiVp9jgxIo4cfVCevPnu8uFXADJzLfBd4NURcfiYse8pH/5rOfYR4OvAyRFxwtg3K58jSeqAPeWStPM7MiLOHGffV5ru/xD4dkRcANwPnEaxbOHnMvN7TePOoVgS8Tvl2AeAU4BXAP80uvJK6WyKEP/1iLgMuBUYoli95W7g3En+2SRpVjCUS9LO74zyp5VnAyPl/SuBOylmvA8F1gIfKn+2ycylEXEM8EHg7RTri6+mCNh/NWbsz8p1zd8PvBJ4I/BLin8AXDTZP5gkzRauUy5JM1zTOuUfzMzzay1GktSSPeWSJElSzQzlkiRJUs0M5ZIkSVLN7CmXJEmSauZMuSRJklQzQ7kkSZJUM0O5JEmSVDNDuSRJklQzQ7kkSZJUM0O5JEmSVLP/D4FAoldNSm0SAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Check out our train accuracy and validation accuracy over epochs.\n",
    "# train_accuracy = history.history['accuracy']\n",
    "# val_accuracy = history.history['val_accuracy']\n",
    "train_accuracy = vgghist.history['acc']\n",
    "val_accuracy = vgghist.history['val_acc']\n",
    "# train_accuracy = resnet_history.history['acc']\n",
    "# val_accuracy = resnet_history.history['val_acc']\n",
    "# Set figure size.\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "# Generate line plot of training, testing loss over epochs.\n",
    "plt.plot(train_accuracy, label='Training Accuracy', color='#185fad')\n",
    "plt.plot(val_accuracy, label='Validation Accuracy', color='orange')\n",
    "\n",
    "# Set title\n",
    "plt.title('Training and Validation Accuracy by Epoch', fontsize = 25)\n",
    "plt.xlabel('Epoch', fontsize = 18)\n",
    "plt.ylabel('Categorical Crossentropy', fontsize = 18)\n",
    "plt.xticks(range(0,100,5), range(0,100,5))\n",
    "\n",
    "plt.legend(fontsize = 18)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>corona_test</th>\n",
       "      <th>cough_filename</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2272</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_398.wav.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2624</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_714.wav.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>485</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_134.wav.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1334</th>\n",
       "      <td>negative</td>\n",
       "      <td>wavegan_neg_9.wav.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2906</th>\n",
       "      <td>positive</td>\n",
       "      <td>wavegan_pos_969.wav.jpg</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     corona_test           cough_filename\n",
       "2272    positive  wavegan_pos_398.wav.jpg\n",
       "2624    positive  wavegan_pos_714.wav.jpg\n",
       "485     negative  wavegan_neg_134.wav.jpg\n",
       "1334    negative    wavegan_neg_9.wav.jpg\n",
       "2906    positive  wavegan_pos_969.wav.jpg"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.56"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a new test dataframe that includes the labels for comparison and \n",
    "# checking the accuracy of our model with this never before seen data\n",
    "# test = data[4435:]\n",
    "\n",
    "# Generating predictions on our never seen data with the model we built\n",
    "preds = model.predict(val_generator)\n",
    "\n",
    "# Creating an empty list to store the values where the predictions are the maximum out \n",
    "# of all the 10 possible values\n",
    "p = []\n",
    "for i in range(0, len(preds)):\n",
    "    p.append(np.where(preds[i] == max(preds[i])))\n",
    "\n",
    "# Creating an empty list to store the values in a clean list\n",
    "predictions = []\n",
    "for i in range(0, len(preds)):\n",
    "    predictions.append(p[i][0][0])\n",
    "    \n",
    "# Adding those predictions to our test dataframe\n",
    "val['predictions'] = predictions\n",
    "\n",
    "# Changing the numeric values to their corresponding labels\n",
    "val['predictions'] = val['predictions'].map({ 0:'negative',1:'positive'})\n",
    "\n",
    "# Checking the percentage of correct predictions \n",
    "round(len(val[val['corona_test'] == val['predictions']])/len(val),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.59"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a new test dataframe that includes the labels for comparison and \n",
    "# checking the accuracy of our model with this never before seen data\n",
    "# test = data[4435:]\n",
    "\n",
    "# Generating predictions on our never seen data with the model we built\n",
    "preds = model.predict(train_generator)\n",
    "\n",
    "# Creating an empty list to store the values where the predictions are the maximum out \n",
    "# of all the 10 possible values\n",
    "p = []\n",
    "for i in range(0, len(preds)):\n",
    "    p.append(np.where(preds[i] == max(preds[i])))\n",
    "\n",
    "# Creating an empty list to store the values in a clean list\n",
    "predictions = []\n",
    "for i in range(0, len(preds)):\n",
    "    predictions.append(p[i][0][0])\n",
    "    \n",
    "# Adding those predictions to our test dataframe\n",
    "train['predictions'] = predictions\n",
    "\n",
    "# Changing the numeric values to their corresponding labels\n",
    "train['predictions'] = train['predictions'].map({ 0:'negative',1:'positive'})\n",
    "\n",
    "# Checking the percentage of correct predictions \n",
    "round(len(train[train['corona_test'] == train['predictions']])/len(train),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.67"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a new test dataframe that includes the labels for comparison and \n",
    "# checking the accuracy of our model with this never before seen data\n",
    "# test = data[4435:]\n",
    "\n",
    "# Generating predictions on our never seen data with the model we built\n",
    "preds = model.predict(test_generator)\n",
    "\n",
    "# Creating an empty list to store the values where the predictions are the maximum out \n",
    "# of all the 10 possible values\n",
    "p = []\n",
    "for i in range(0, len(preds)):\n",
    "    p.append(np.where(preds[i] == max(preds[i])))\n",
    "\n",
    "# Creating an empty list to store the values in a clean list\n",
    "predictions = []\n",
    "for i in range(0, len(preds)):\n",
    "    predictions.append(p[i][0][0])\n",
    "    \n",
    "# Adding those predictions to our test dataframe\n",
    "test['predictions'] = predictions\n",
    "\n",
    "# Changing the numeric values to their corresponding labels\n",
    "test['predictions'] = test['predictions'].map({ 0:'negative',1:'positive'})\n",
    "\n",
    "# Checking the percentage of correct predictions \n",
    "round(len(test[test['corona_test'] == test['predictions']])/len(test),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Model was constructed with shape (None, 64, 64, 3) for input KerasTensor(type_spec=TensorSpec(shape=(None, 64, 64, 3), dtype=tf.float32, name='input_1'), name='input_1', description=\"created by layer 'input_1'\"), but it was called on an input with incompatible shape (32, 1).\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "in user code:\n\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py:1233 test_function  *\n        return step_function(self, iterator)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py:1224 step_function  **\n        outputs = model.distribute_strategy.run(run_step, args=(data,))\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\distribute\\distribute_lib.py:1259 run\n        return self._extended.call_for_each_replica(fn, args=args, kwargs=kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\distribute\\distribute_lib.py:2730 call_for_each_replica\n        return self._call_for_each_replica(fn, args, kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\distribute\\distribute_lib.py:3417 _call_for_each_replica\n        return fn(*args, **kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py:1217 run_step  **\n        outputs = model.test_step(data)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py:1183 test_step\n        y_pred = self(x, training=False)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\base_layer.py:1012 __call__\n        outputs = call_fn(inputs, *args, **kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\functional.py:424 call\n        return self._run_internal_graph(\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\functional.py:560 _run_internal_graph\n        outputs = node.layer(*args, **kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\base_layer.py:998 __call__\n        input_spec.assert_input_compatibility(self.input_spec, inputs, self.name)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\input_spec.py:234 assert_input_compatibility\n        raise ValueError('Input ' + str(input_index) + ' of layer ' +\n\n    ValueError: Input 0 of layer block1_conv1 is incompatible with the layer: : expected min_ndim=4, found ndim=2. Full shape received: (32, 1)\n",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-59-ae9009258e68>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mscore\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrain\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"cough_filename\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrain\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"corona_test\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Training Accuracy: \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mscore\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mscore\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mevaluate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"cough_filename\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"corona_test\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Testing Accuracy: \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mscore\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mevaluate\u001b[1;34m(self, x, y, batch_size, verbose, sample_weight, steps, callbacks, max_queue_size, workers, use_multiprocessing, return_dict)\u001b[0m\n\u001b[0;32m   1387\u001b[0m             \u001b[1;32mwith\u001b[0m \u001b[0mtrace\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTrace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'test'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstep_num\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0m_r\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1388\u001b[0m               \u001b[0mcallbacks\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mon_test_batch_begin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1389\u001b[1;33m               \u001b[0mtmp_logs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtest_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1390\u001b[0m               \u001b[1;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1391\u001b[0m                 \u001b[0mcontext\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    826\u001b[0m     \u001b[0mtracing_count\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    827\u001b[0m     \u001b[1;32mwith\u001b[0m \u001b[0mtrace\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTrace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mtm\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 828\u001b[1;33m       \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    829\u001b[0m       \u001b[0mcompiler\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"xla\"\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_experimental_compile\u001b[0m \u001b[1;32melse\u001b[0m \u001b[1;34m\"nonXla\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    830\u001b[0m       \u001b[0mnew_tracing_count\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36m_call\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    860\u001b[0m       \u001b[1;31m# In this case we have not created variables on the first call. So we can\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    861\u001b[0m       \u001b[1;31m# run the first trace but we should fail if variables are created.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 862\u001b[1;33m       \u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    863\u001b[0m       \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_created_variables\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    864\u001b[0m         raise ValueError(\"Creating variables on a non-first call to a function\"\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   2939\u001b[0m     \u001b[1;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2940\u001b[0m       (graph_function,\n\u001b[1;32m-> 2941\u001b[1;33m        filtered_flat_args) = self._maybe_define_function(args, kwargs)\n\u001b[0m\u001b[0;32m   2942\u001b[0m     return graph_function._call_flat(\n\u001b[0;32m   2943\u001b[0m         filtered_flat_args, captured_inputs=graph_function.captured_inputs)  # pylint: disable=protected-access\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_maybe_define_function\u001b[1;34m(self, args, kwargs)\u001b[0m\n\u001b[0;32m   3355\u001b[0m               \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minput_signature\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m \u001b[1;32mand\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3356\u001b[0m               call_context_key in self._function_cache.missed):\n\u001b[1;32m-> 3357\u001b[1;33m             return self._define_function_with_shape_relaxation(\n\u001b[0m\u001b[0;32m   3358\u001b[0m                 args, kwargs, flat_args, filtered_flat_args, cache_key_context)\n\u001b[0;32m   3359\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_define_function_with_shape_relaxation\u001b[1;34m(self, args, kwargs, flat_args, filtered_flat_args, cache_key_context)\u001b[0m\n\u001b[0;32m   3277\u001b[0m           expand_composites=True)\n\u001b[0;32m   3278\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 3279\u001b[1;33m     graph_function = self._create_graph_function(\n\u001b[0m\u001b[0;32m   3280\u001b[0m         args, kwargs, override_flat_arg_shapes=relaxed_arg_shapes)\n\u001b[0;32m   3281\u001b[0m     \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_function_cache\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marg_relaxed\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mrank_only_cache_key\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\eager\\function.py\u001b[0m in \u001b[0;36m_create_graph_function\u001b[1;34m(self, args, kwargs, override_flat_arg_shapes)\u001b[0m\n\u001b[0;32m   3194\u001b[0m     \u001b[0marg_names\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbase_arg_names\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mmissing_arg_names\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3195\u001b[0m     graph_function = ConcreteFunction(\n\u001b[1;32m-> 3196\u001b[1;33m         func_graph_module.func_graph_from_py_func(\n\u001b[0m\u001b[0;32m   3197\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3198\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_python_function\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\framework\\func_graph.py\u001b[0m in \u001b[0;36mfunc_graph_from_py_func\u001b[1;34m(name, python_func, args, kwargs, signature, func_graph, autograph, autograph_options, add_control_dependencies, arg_names, op_return_value, collections, capture_by_value, override_flat_arg_shapes)\u001b[0m\n\u001b[0;32m    988\u001b[0m         \u001b[0m_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moriginal_func\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf_decorator\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munwrap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpython_func\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    989\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 990\u001b[1;33m       \u001b[0mfunc_outputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpython_func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mfunc_args\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mfunc_kwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    991\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    992\u001b[0m       \u001b[1;31m# invariant: `func_outputs` contains only Tensors, CompositeTensors,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\eager\\def_function.py\u001b[0m in \u001b[0;36mwrapped_fn\u001b[1;34m(*args, **kwds)\u001b[0m\n\u001b[0;32m    632\u001b[0m             \u001b[0mxla_context\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    633\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 634\u001b[1;33m           \u001b[0mout\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mweak_wrapped_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__wrapped__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    635\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    636\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\framework\\func_graph.py\u001b[0m in \u001b[0;36mwrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    975\u001b[0m           \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m  \u001b[1;31m# pylint:disable=broad-except\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    976\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"ag_error_metadata\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 977\u001b[1;33m               \u001b[1;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mag_error_metadata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto_exception\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    978\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    979\u001b[0m               \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: in user code:\n\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py:1233 test_function  *\n        return step_function(self, iterator)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py:1224 step_function  **\n        outputs = model.distribute_strategy.run(run_step, args=(data,))\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\distribute\\distribute_lib.py:1259 run\n        return self._extended.call_for_each_replica(fn, args=args, kwargs=kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\distribute\\distribute_lib.py:2730 call_for_each_replica\n        return self._call_for_each_replica(fn, args, kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\distribute\\distribute_lib.py:3417 _call_for_each_replica\n        return fn(*args, **kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py:1217 run_step  **\n        outputs = model.test_step(data)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\training.py:1183 test_step\n        y_pred = self(x, training=False)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\base_layer.py:1012 __call__\n        outputs = call_fn(inputs, *args, **kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\functional.py:424 call\n        return self._run_internal_graph(\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\functional.py:560 _run_internal_graph\n        outputs = node.layer(*args, **kwargs)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\base_layer.py:998 __call__\n        input_spec.assert_input_compatibility(self.input_spec, inputs, self.name)\n    C:\\Users\\Deepa Kapoor\\AppData\\Roaming\\Python\\Python38\\site-packages\\tensorflow\\python\\keras\\engine\\input_spec.py:234 assert_input_compatibility\n        raise ValueError('Input ' + str(input_index) + ' of layer ' +\n\n    ValueError: Input 0 of layer block1_conv1 is incompatible with the layer: : expected min_ndim=4, found ndim=2. Full shape received: (32, 1)\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(train[\"cough_filename\"], train[\"corona_test\"], verbose=0)\n",
    "print(\"Training Accuracy: \", score[1])\n",
    "\n",
    "score = model.evaluate(test[\"cough_filename\"], test[\"corona_test\"], verbose=0)\n",
    "print(\"Testing Accuracy: \", score[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We got 62% accuracy on our test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saving the dataframe to use with our Dense NN to use as a voting classifier \n",
    "predic_cnn = pd.DataFrame(preds)\n",
    "\n",
    "predic_cnn.to_csv('predict_cnn.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.system('say -v Juan ya acabé');"
   ]
  },
  {
   "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.8.3"
  },
  "metadata": {
   "interpreter": {
    "hash": "de1d295a3419ab67f9fc432cc94c69d449188380c591f37e3f15ae3d438489a0"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}