audio-classifier-project.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "####### All Imports #######\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import re\n",
    "import os\n",
    "import random\n",
    "from datetime import datetime\n",
    "\n",
    "import librosa\n",
    "from scipy.io import wavfile\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn as sk\n",
    "import torch\n",
    "from torch.utils import data\n",
    "import tensorflow as tf\n",
    "import keras\n",
    "from keras.callbacks import ModelCheckpoint \n",
    "from keras.models import Sequential, model_from_json\n",
    "from keras.layers import Dense\n",
    "from sklearn import model_selection\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "import IPython.display as ipd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Physical GPUs, 1 Logical GPUs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x232820dc690>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "####### Setup Environment #######\n",
    "\n",
    "# enable GPU\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# (tf v2) - allowing GPU memory growth.\n",
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "if gpus:\n",
    "    try:\n",
    "        # Currently, memory growth needs to be the same across GPUs\n",
    "        for gpu in gpus:\n",
    "            tf.config.experimental.set_memory_growth(gpu, True)\n",
    "        logical_gpus = tf.config.experimental.list_logical_devices('GPU')\n",
    "        print(len(gpus), \"Physical GPUs,\", len(logical_gpus), \"Logical GPUs\")\n",
    "    except RuntimeError as e:\n",
    "      # Memory growth must be set before GPUs have been initialized\n",
    "      print(e)\n",
    "\n",
    "#keras saving/loading issue attempt?\n",
    "tf.random.set_seed(42)\n",
    "random.seed(42)\n",
    "np.random.seed(42)\n",
    "torch.manual_seed(42)\n",
    "# manual_variable_initialization(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "####### Configs for Machine Learning #######\n",
    "\n",
    "### Loading Test/Training Data ###\n",
    "load_urbansound_data = False # <-- Note: Urbansound8k has a shortcut for testing/debugging, only loads 1 folder (800 instead of 8000)\n",
    "# Data Source: https://urbansounddataset.weebly.com/urbansound8k.html\n",
    "load_birds_data      = False\n",
    "# Data Source: http://machine-listening.eecs.qmul.ac.uk/bird-audio-detection-challenge/#downloads\n",
    "load_kaggle_data     = True\n",
    "# Data Source: https://www.kaggle.com/mmoreaux/environmental-sound-classification-50#esc50.csv\n",
    "load_kaggle_cats_dogs_data  = False\n",
    "# Data Source:  https://www.kaggle.com/mmoreaux/audio-cats-and-dogs\n",
    "load_audioset_data   = False\n",
    "# Data Source: https://research.google.com/audioset/index.html\n",
    "# See scripts/README.md for downloading & filtering instructions.\n",
    "\n",
    "\n",
    "### Loading/Saving Model ###\n",
    "save_numpy = False # False = do nothing. String = Saves only features/labels into a .npy file within /data directory\n",
    "load_numpy = False # False = load direct from wav files (SLOW). String = load features/labels from a .npy file\n",
    "# save_numpy = \"kaggle50.npy\" # all_data_<name.npy> and all_labels_<name.npy>\n",
    "load_numpy = \"kaggle50.npy\" # all_data_<name.npy> and all_labels_<name.npy>\n",
    "\n",
    "load_model_file = False # False = create new model, String = load pre-trian model from filename (no filename extension).\n",
    "save_model_file = False # False = do nothing, String = save trained model to filename (no filename extension).\n",
    "# save_model_file = \"urbansound_first_try\" \n",
    "# load_model_file = \"urbansound_first_try\"\n",
    "\n",
    "\n",
    "### Training / Fitting / Optimizing Model #####\n",
    "test_size = 0.2\n",
    "epochs    = 60\n",
    "batch_size= 50\n",
    "optimizer = keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, amsgrad=False)\n",
    "\n",
    "do_model_analysis = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "####### HELPER FUNCTIONS (Table of Content) #######\n",
    "# extract_features()\n",
    "# display_wav()\n",
    "# load_all_wav_files()\n",
    "#    load_urbansound\n",
    "#    load_birds\n",
    "#    load_kaggle\n",
    "#    load_kaggle_cats_dogs\n",
    "#    load_audioset_data\n",
    "# analyze_features()\n",
    "# plot_history() loss & accuracy v epochs)\n",
    "# plot_confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_features(file_name):\n",
    "    \"\"\"\n",
    "    Extracts 193 chromatographic features from sound file. \n",
    "    including: MFCC's, Chroma_StFt, Melspectrogram, Spectral Contrast, and Tonnetz\n",
    "    NOTE: this extraction technique changes the time series nature of the data\n",
    "    \"\"\"\n",
    "    features = []\n",
    "    \n",
    "    audio_data, sample_rate = librosa.load(file_name)\n",
    "    stft = np.abs(librosa.stft(audio_data))\n",
    "    \n",
    "    mfcc = np.mean(librosa.feature.mfcc(y=audio_data, sr=sample_rate, n_mfcc=40).T,axis=0)\n",
    "    features.extend(mfcc) # 40 = 40\n",
    "    \n",
    "    chroma = np.mean(librosa.feature.chroma_stft(S=stft, sr=sample_rate).T,axis=0)\n",
    "    features.extend(chroma) # 12 = 52\n",
    "    \n",
    "    mel = np.mean(librosa.feature.melspectrogram(audio_data, sr=sample_rate).T,axis=0)\n",
    "    features.extend(mel) # 128 = 180\n",
    "    \n",
    "    contrast = np.mean(librosa.feature.spectral_contrast(S=stft, sr=sample_rate).T,axis=0)\n",
    "    features.extend(contrast) # 7 = 187\n",
    "\n",
    "# More possible features to add\n",
    "#     tonnetz = np.mean(librosa.feature.tonnetz(y=librosa.effects.harmonic(X, ), sr=sample_rate).T,axis=0)\n",
    "#     spec_cent = np.mean(librosa.feature.spectral_centroid(y=audio_data, sr=sample_rate).T, axis=0)\n",
    "#     spec_bw = np.mean(librosa.feature.spectral_bandwidth(y=audio_data, sr=sample_rate).T, axis=0)\n",
    "#     rolloff = np.mean(librosa.feature.spectral_rolloff(y=audio_data, sr=sample_rate).T, axis=0)\n",
    "#     zcr = np.mean(librosa.feature.zero_crossing_rate(audio_data).T, axis=0)\n",
    "#     features.extend(tonnetz) # 6 = 193\n",
    "#     features.extend(spec_cent)\n",
    "#     features.extend(spec_bw)\n",
    "#     features.extend(rolloff)\n",
    "#     features.extend(zcr)\n",
    "\n",
    "    return np.array(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_wav(file = None):\n",
    "    # Displays comparison of loading a wav file via librosa vs via scipy\n",
    "    if not file:\n",
    "        print(\"No wav file to display\")\n",
    "        return\n",
    "    librosa_load, librosa_sampling_rate = librosa.load(file)\n",
    "    scipy_sampling_rate, scipy_load = wavfile.read(file)\n",
    "    print('original sample rate:',scipy_sampling_rate)\n",
    "    print('converted sample rate:',librosa_sampling_rate)\n",
    "    print('\\n')\n",
    "    print('original wav file min~max range:',np.min(scipy_load),'~',np.max(scipy_load))\n",
    "    print('converted wav file min~max range:',np.min(librosa_load),'~',np.max(librosa_load))\n",
    "    plt.figure(figsize=(12, 4))\n",
    "    plt.plot(scipy_load)\n",
    "    plt.figure(figsize=(12, 4))\n",
    "    plt.plot(librosa_load)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_all_wav_files(load_urbansound=False,\n",
    "                       load_birds=False,\n",
    "                       load_kaggle=False,\n",
    "                       load_kaggle_cats_dogs=False,\n",
    "                       load_audioset=False):\n",
    "    '''\n",
    "    Returns two numpy array\n",
    "    The first is a numpy array containing each audio's numerical features - see extract_features()\n",
    "    The second numpy array is the array *STRING* of the label.\n",
    "    (The array indexes align up between the two arrays. data[idx] is classified as labels[idx]) \n",
    "    '''\n",
    "    one_file = None\n",
    "    #THIS WILL TAKE A WHILE!!!!!\n",
    "    all_data = []\n",
    "    all_labels = []\n",
    "    #UltraSound8K\n",
    "    if load_urbansound:\n",
    "        print(\"loading Ultrasound8k\")\n",
    "        # Data Source: https://urbansounddataset.weebly.com/urbansound8k.html\n",
    "        metadata = pd.read_csv(\"./data/UrbanSound8K/metadata/UrbanSound8K.csv\")\n",
    "        for root, dirs, files in os.walk(\"./data/UrbanSound8K\"):\n",
    "            print(root, str(len(dirs)), str(len(files)), len(all_data))\n",
    "#SHORTCUT\n",
    "# This is in here for quick tests - only loads first Ultrasound8k folder (instead of all of them)\n",
    "#             if len(all_data) > 0: \n",
    "#                 break\n",
    "#END SHORTCUT\n",
    "            for idx, file in enumerate(files):\n",
    "                if file.endswith('.wav'):\n",
    "                    fname = os.path.join(root, file)\n",
    "                    if(len(all_data) % 100 == 0):\n",
    "                        print(str(len(all_data)))\n",
    "                    features = extract_features(fname)\n",
    "                    label = metadata[metadata.slice_file_name == file][\"class\"].tolist()[0]\n",
    "#                     if(label == \"dog_bark\"):\n",
    "                    all_data.append(features)\n",
    "                    all_labels.append(label)\n",
    "                    one_file = fname\n",
    "#                     display_wav(fname)\n",
    "#                     break\n",
    "\n",
    "\n",
    "    if load_birds:\n",
    "        print(\"Loading birds\")\n",
    "        # Data Source: http://dcase.community/challenge2018/task-bird-audio-detection\n",
    "        # Data Source: http://machine-listening.eecs.qmul.ac.uk/bird-audio-detection-challenge/#downloads\n",
    "        for root, dirs, files in os.walk(\"./data/warblrb10k_public_wav/train/hasbird\"):\n",
    "            print(root, str(len(dirs)), str(len(files)), len(all_data))\n",
    "            for file in files:\n",
    "                if file.endswith('.wav'):\n",
    "                    fname = os.path.join(root, file)\n",
    "                    if(len(all_data) % 100 == 0):\n",
    "                        print(str(len(all_data)))\n",
    "                    features = extract_features(fname)\n",
    "                    all_data.append(features)\n",
    "                    all_labels.append(\"chirping_birds\")\n",
    "\n",
    "\n",
    "    if load_kaggle:\n",
    "        print(\"Loading Kaggle\")\n",
    "        # Data Source: https://www.kaggle.com/mmoreaux/environmental-sound-classification-50#esc50.csv\n",
    "        metadata = pd.read_csv(\"./data/environmental-sound-classification-50/esc50.csv\")\n",
    "        for root, dirs, files in os.walk(\"./data/environmental-sound-classification-50/\"):\n",
    "            for file in files:\n",
    "        #for file in os.listdir(\"./data/environmental-sound-classification-50/audio\"):\n",
    "        #    fname = \"./data/environmental-sound-classification-50/audio/\"+file\n",
    "                if file.endswith('.wav'):\n",
    "                    fname = os.path.join(root, file)\n",
    "                    label = metadata[metadata.filename == file][\"category\"].tolist()[0]\n",
    "                    animals=[\"cat\", \"chirping_birds\",\"cow\",\"crickets\",\"crow\",\"dog\",\"frog\",\"hen\",\"insects\",\"pig\",\"rooster\",\"sheep\"]\n",
    "                    if label in animals:\n",
    "                        if(len(all_data) % 100 == 0):\n",
    "                            print(str(len(all_data)))\n",
    "                        features = extract_features(fname)\n",
    "                        all_data.append(features)\n",
    "                        all_labels.append(label)\n",
    "\n",
    "    if load_kaggle_cats_dogs:\n",
    "        print(\"Loading Kaggle cats and dogs\")\n",
    "        # Data Source:  https://www.kaggle.com/mmoreaux/audio-cats-and-dogs\n",
    "        metadata = pd.read_csv(\"./data/kaggle_cats_dogs/train_test_split.csv\")\n",
    "        for file in os.listdir(\"./data/kaggle_cats_dogs/cats_dogs\"):\n",
    "            fname = \"./data/kaggle_cats_dogs/cats_dogs/\"+file\n",
    "            if file.endswith('.wav'):\n",
    "                if(len(all_data) % 100 == 0):\n",
    "                    print(str(len(all_data)))\n",
    "                features = extract_features(fname)\n",
    "                all_data.append(features)\n",
    "                label = 'cat' if file.startswith('cat') else 'dog'\n",
    "                all_labels.append(label)\n",
    "#                 one\n",
    "     \n",
    "    if load_audioset:\n",
    "        err_files = []\n",
    "        # Data Source: https://research.google.com/audioset/index.html\n",
    "        # See scripts/README.md for downloading & filtering instructions.\n",
    "        print(\"Loading Audioset\")\n",
    "        metadata_b = pd.read_csv(\"./data/audioset/balanced_train_segments-animals.csv\")\n",
    "        metadata_e = pd.read_csv(\"./data/audioset/eval_segments-animals.csv\")\n",
    "        metadata_l = pd.read_csv(\"./data/audioset/class_labels_indices-animals.csv\")\n",
    "#         print(\"METADATA BALANCED\", metadata_b.head())\n",
    "#         print(\"METADATA EVAL\", metadata_e.head())\n",
    "#         print(\"METADATA LABEL\", metadata_l.head())\n",
    "        for root, dirs, files in os.walk(\"./data/audioset\"):\n",
    "            print(root, str(len(dirs)), str(len(files)), len(all_data))\n",
    "            for idx, file in enumerate(files):\n",
    "                if file.endswith('.wav'):\n",
    "                    if(len(all_data) % 100 == 0):\n",
    "                        print(str(len(all_data)))\n",
    "                    fname = os.path.join(root, file)\n",
    "                    try:\n",
    "                        features = extract_features(fname)\n",
    "                    except ValueError as err:\n",
    "                        # Errors out on files that are empty or nearly empty\n",
    "                        err_files.append(fname)\n",
    "                        continue\n",
    "#                     file_id = file.replace(\".wav\", \"\")\n",
    "                    fid = re.sub(r'_[\\d\\.]+wav$','',file)\n",
    "                    temp = None\n",
    "                    if \"balanced_train_segments\" in fname:\n",
    "#                         temp = metadata_b[metadata_b['# YTID'] == no_ext][\"Unnamed: 3\"].tolist()\n",
    "                        temp = metadata_b[metadata_b['# YTID'] == fid][\"Unnamed: 3\"].tolist()\n",
    "                    elif \"eval_segments\" in fname:\n",
    "#                         temp = metadata_e[metadata_e['# YTID'] == no_ext][\"Unnamed: 3\"].tolist()\n",
    "                        temp = metadata_e[metadata_e['# YTID'] == fid][\"Unnamed: 3\"].tolist()\n",
    "                    if not temp:\n",
    "                        continue\n",
    "                    label_code = temp[0]\n",
    "                    label_temp = metadata_l[metadata_l.mid == label_code][\"display_name\"].to_list()\n",
    "                    if not label_temp:\n",
    "                        continue\n",
    "                    label = label_temp[0]\n",
    "                    \n",
    "                    all_data.append(features)\n",
    "                    all_labels.append(label)\n",
    "                    if(len(all_data) >= 1000):\n",
    "                        break\n",
    "        if err_files:\n",
    "            print(\"{} ERROR FILES:\\n {}\".format(len(err_files), err_files))\n",
    "        \n",
    "    \n",
    "    return np.array(all_data), np.array(all_labels), one_file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def analyze_features(all_data, all_labels):\n",
    "    #seeking only the numeric features from the data\n",
    "    numeric_features = all_data.select_dtypes(include = [np.number])\n",
    "    print(numeric_features.dtypes)\n",
    "    corr = numeric_features.corr()\n",
    "    print(corr)\n",
    "#     print(corr['SalePrice'].sort_values(ascending = False)[:5], '\\n')\n",
    "#     print(corr['SalePrice'].sort_values(ascending = False)[-5:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_history(history = None):\n",
    "    # Plots accuracy & loss versus epochs\n",
    "    if not history:\n",
    "        print(\"No history to plot\")\n",
    "        return\n",
    "    fig = plt.figure(figsize=(10,8))\n",
    "#     fig = plt.figure(figsize=(20,16))\n",
    "    plt.plot(history.history['loss'], label=\"Loss\")\n",
    "    plt.plot(history.history['accuracy'], label=\"Accuracy\")\n",
    "    plt.axis([0,90,0,1.1])\n",
    "    plt.title(\"Accuracy and Loss vs Epoch\")\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Percentage\")\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(cm):\n",
    "    fig, ax = plt.subplots()\n",
    "    im = ax.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "    # We want to show all ticks...\n",
    "    ax.set(xticks=np.arange(cm.shape[1]),\n",
    "           yticks=np.arange(cm.shape[0]),\n",
    "           # ... and label them with the respective list entries\n",
    "           xticklabels=classes,\n",
    "           yticklabels=classes,\n",
    "           title=\"Confusion Matrix\",\n",
    "           ylabel='True label',\n",
    "           xlabel='Predicted label')\n",
    "    ax.set_ylim(len(classes)-0.5, -0.5)\n",
    "    ax.set_aspect('auto')\n",
    "\n",
    "    # Rotate the tick labels and set their alignment.\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\", rotation_mode=\"anchor\")\n",
    "\n",
    "    # Loop over data dimensions and create text annotations.\n",
    "    thresh = cm.max() / 2.\n",
    "    for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            ax.text(j, i, format(cm[i, j], 'd'),\n",
    "                    ha=\"center\", va=\"center\",\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.grid(None)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "all_data = np.array([])\n",
    "all_labels = np.array([])\n",
    "one_file = None\n",
    "if not load_numpy:\n",
    "    all_data, all_labels, one_file = load_all_wav_files(load_urbansound_data,\n",
    "                                          load_birds_data,\n",
    "                                          load_kaggle_data,\n",
    "                                          load_kaggle_cats_dogs_data,\n",
    "                                          load_audioset_data)\n",
    "else:\n",
    "    all_data = np.load(\"data/all_data_\"+load_numpy)\n",
    "    all_labels = np.load(\"data/all_labels_\"+load_numpy)\n",
    "if save_numpy:\n",
    "    np.save(\"data/all_data_\"+save_numpy, all_data)\n",
    "    np.save(\"data/all_labels_\"+save_numpy, all_labels)\n",
    "# # display_wav(one_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1440, 187)\n",
      "['sheep', 'cow', 'hen', 'pig', 'chirping_birds', 'crow', 'frog', 'dog', 'cat', 'insects', 'rooster', 'crickets']\n"
     ]
    }
   ],
   "source": [
    "print(all_data.shape)\n",
    "classes = list(set(all_labels)) # classes = unique list of labels\n",
    "n_classes = len(classes)\n",
    "numeric_labels = np.array([classes.index(label) for label in all_labels]) # labels by index\n",
    "print(classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1152, 187)\n",
      "(1152,)\n",
      "(288, 187)\n",
      "(288,)\n"
     ]
    }
   ],
   "source": [
    "x_train, x_test, y_train, y_test = sk.model_selection.train_test_split(all_data, numeric_labels, test_size=test_size, shuffle=True)\n",
    "print(x_train.shape)\n",
    "print(y_train.shape)\n",
    "print(x_test.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "model.add(Dense(256, activation='relu',  input_dim=x_train.shape[1]))\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(64, activation='relu'))\n",
    "model.add(Dense(n_classes, activation='softmax')) # sigmoid\n",
    "\n",
    "model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 1152 samples, validate on 288 samples\n",
      "Epoch 1/60\n",
      " - 0s - loss: 6.0807 - accuracy: 0.2422 - val_loss: 2.5890 - val_accuracy: 0.3819\n",
      "Epoch 2/60\n",
      " - 0s - loss: 1.6495 - accuracy: 0.5200 - val_loss: 1.3408 - val_accuracy: 0.5660\n",
      "Epoch 3/60\n",
      " - 0s - loss: 1.0641 - accuracy: 0.6589 - val_loss: 0.9800 - val_accuracy: 0.6493\n",
      "Epoch 4/60\n",
      " - 0s - loss: 0.9916 - accuracy: 0.6832 - val_loss: 0.8646 - val_accuracy: 0.7049\n",
      "Epoch 5/60\n",
      " - 0s - loss: 0.7685 - accuracy: 0.7422 - val_loss: 0.7927 - val_accuracy: 0.7257\n",
      "Epoch 6/60\n",
      " - 0s - loss: 0.7405 - accuracy: 0.7517 - val_loss: 0.7920 - val_accuracy: 0.7292\n",
      "Epoch 7/60\n",
      " - 0s - loss: 0.7299 - accuracy: 0.7726 - val_loss: 0.5511 - val_accuracy: 0.8021\n",
      "Epoch 8/60\n",
      " - 0s - loss: 0.4856 - accuracy: 0.8429 - val_loss: 0.5487 - val_accuracy: 0.8194\n",
      "Epoch 9/60\n",
      " - 0s - loss: 0.3967 - accuracy: 0.8733 - val_loss: 0.5769 - val_accuracy: 0.8264\n",
      "Epoch 10/60\n",
      " - 0s - loss: 0.6350 - accuracy: 0.8134 - val_loss: 0.5235 - val_accuracy: 0.8333\n",
      "Epoch 11/60\n",
      " - 0s - loss: 0.3642 - accuracy: 0.8880 - val_loss: 0.4538 - val_accuracy: 0.8611\n",
      "Epoch 12/60\n",
      " - 0s - loss: 0.2966 - accuracy: 0.9141 - val_loss: 0.4362 - val_accuracy: 0.8542\n",
      "Epoch 13/60\n",
      " - 0s - loss: 0.2689 - accuracy: 0.9227 - val_loss: 0.4006 - val_accuracy: 0.8785\n",
      "Epoch 14/60\n",
      " - 0s - loss: 0.2044 - accuracy: 0.9479 - val_loss: 0.4235 - val_accuracy: 0.8681\n",
      "Epoch 15/60\n",
      " - 0s - loss: 0.4778 - accuracy: 0.8568 - val_loss: 0.3766 - val_accuracy: 0.8854\n",
      "Epoch 16/60\n",
      " - 0s - loss: 0.2076 - accuracy: 0.9470 - val_loss: 0.4262 - val_accuracy: 0.8646\n",
      "Epoch 17/60\n",
      " - 0s - loss: 0.2838 - accuracy: 0.9080 - val_loss: 0.3961 - val_accuracy: 0.8646\n",
      "Epoch 18/60\n",
      " - 0s - loss: 0.1564 - accuracy: 0.9627 - val_loss: 0.2357 - val_accuracy: 0.9340\n",
      "Epoch 19/60\n",
      " - 0s - loss: 0.1726 - accuracy: 0.9436 - val_loss: 0.2843 - val_accuracy: 0.9062\n",
      "Epoch 20/60\n",
      " - 0s - loss: 0.1535 - accuracy: 0.9575 - val_loss: 0.6964 - val_accuracy: 0.9271\n",
      "Epoch 21/60\n",
      " - 0s - loss: 0.1710 - accuracy: 0.9852 - val_loss: 0.4593 - val_accuracy: 0.9236\n",
      "Epoch 22/60\n",
      " - 0s - loss: 0.0841 - accuracy: 0.9870 - val_loss: 0.2251 - val_accuracy: 0.9410\n",
      "Epoch 23/60\n",
      " - 0s - loss: 0.0734 - accuracy: 0.9887 - val_loss: 0.2079 - val_accuracy: 0.9375\n",
      "Epoch 24/60\n",
      " - 0s - loss: 0.1073 - accuracy: 0.9835 - val_loss: 0.3599 - val_accuracy: 0.9340\n",
      "Epoch 25/60\n",
      " - 0s - loss: 0.1044 - accuracy: 0.9844 - val_loss: 0.2118 - val_accuracy: 0.9271\n",
      "Epoch 26/60\n",
      " - 0s - loss: 0.0515 - accuracy: 0.9965 - val_loss: 0.2081 - val_accuracy: 0.9271\n",
      "Epoch 27/60\n",
      " - 0s - loss: 0.0476 - accuracy: 0.9974 - val_loss: 0.1864 - val_accuracy: 0.9479\n",
      "Epoch 28/60\n",
      " - 0s - loss: 0.0532 - accuracy: 0.9922 - val_loss: 0.2553 - val_accuracy: 0.9236\n",
      "Epoch 29/60\n",
      " - 0s - loss: 0.0503 - accuracy: 0.9922 - val_loss: 0.1739 - val_accuracy: 0.9444\n",
      "Epoch 30/60\n",
      " - 0s - loss: 0.0459 - accuracy: 0.9922 - val_loss: 0.1701 - val_accuracy: 0.9514\n",
      "Epoch 31/60\n",
      " - 0s - loss: 0.0462 - accuracy: 0.9931 - val_loss: 0.1907 - val_accuracy: 0.9375\n",
      "Epoch 32/60\n",
      " - 0s - loss: 0.0331 - accuracy: 0.9965 - val_loss: 0.1473 - val_accuracy: 0.9653\n",
      "Epoch 33/60\n",
      " - 0s - loss: 0.0279 - accuracy: 0.9983 - val_loss: 0.1404 - val_accuracy: 0.9618\n",
      "Epoch 34/60\n",
      " - 0s - loss: 0.0271 - accuracy: 0.9983 - val_loss: 0.1486 - val_accuracy: 0.9514\n",
      "Epoch 35/60\n",
      " - 0s - loss: 0.0432 - accuracy: 0.9939 - val_loss: 0.1872 - val_accuracy: 0.9514\n",
      "Epoch 36/60\n",
      " - 0s - loss: 0.0300 - accuracy: 0.9974 - val_loss: 0.1827 - val_accuracy: 0.9549\n",
      "Epoch 37/60\n",
      " - 0s - loss: 0.0282 - accuracy: 0.9965 - val_loss: 0.1336 - val_accuracy: 0.9549\n",
      "Epoch 38/60\n",
      " - 0s - loss: 0.0265 - accuracy: 0.9983 - val_loss: 0.1603 - val_accuracy: 0.9549\n",
      "Epoch 39/60\n",
      " - 0s - loss: 0.0186 - accuracy: 1.0000 - val_loss: 0.1574 - val_accuracy: 0.9549\n",
      "Epoch 40/60\n",
      " - 0s - loss: 0.0187 - accuracy: 1.0000 - val_loss: 0.1777 - val_accuracy: 0.9514\n",
      "Epoch 41/60\n",
      " - 0s - loss: 0.0154 - accuracy: 0.9991 - val_loss: 0.1548 - val_accuracy: 0.9444\n",
      "Epoch 42/60\n",
      " - 0s - loss: 0.0151 - accuracy: 0.9991 - val_loss: 0.1707 - val_accuracy: 0.9514\n",
      "Epoch 43/60\n",
      " - 0s - loss: 0.0156 - accuracy: 0.9991 - val_loss: 0.1549 - val_accuracy: 0.9479\n",
      "Epoch 44/60\n",
      " - 0s - loss: 0.0241 - accuracy: 0.9974 - val_loss: 0.2298 - val_accuracy: 0.9444\n",
      "Epoch 45/60\n",
      " - 0s - loss: 0.0317 - accuracy: 0.9931 - val_loss: 0.1477 - val_accuracy: 0.9653\n",
      "Epoch 46/60\n",
      " - 0s - loss: 0.0240 - accuracy: 0.9974 - val_loss: 0.1592 - val_accuracy: 0.9514\n",
      "Epoch 47/60\n",
      " - 0s - loss: 0.0118 - accuracy: 1.0000 - val_loss: 0.1366 - val_accuracy: 0.9653\n",
      "Epoch 48/60\n",
      " - 0s - loss: 0.0093 - accuracy: 1.0000 - val_loss: 0.1449 - val_accuracy: 0.9583\n",
      "Epoch 49/60\n",
      " - 0s - loss: 0.0078 - accuracy: 1.0000 - val_loss: 0.1342 - val_accuracy: 0.9583\n",
      "Epoch 50/60\n",
      " - 0s - loss: 0.0081 - accuracy: 1.0000 - val_loss: 0.1406 - val_accuracy: 0.9653\n",
      "Epoch 51/60\n",
      " - 0s - loss: 0.0088 - accuracy: 1.0000 - val_loss: 0.1309 - val_accuracy: 0.9653\n",
      "Epoch 52/60\n",
      " - 0s - loss: 0.0082 - accuracy: 1.0000 - val_loss: 0.1627 - val_accuracy: 0.9583\n",
      "Epoch 53/60\n",
      " - 0s - loss: 0.0114 - accuracy: 1.0000 - val_loss: 0.1432 - val_accuracy: 0.9688\n",
      "Epoch 54/60\n",
      " - 0s - loss: 0.0178 - accuracy: 0.9965 - val_loss: 0.1657 - val_accuracy: 0.9583\n",
      "Epoch 55/60\n",
      " - 0s - loss: 0.0322 - accuracy: 0.9931 - val_loss: 0.2256 - val_accuracy: 0.9271\n",
      "Epoch 56/60\n",
      " - 0s - loss: 0.0464 - accuracy: 0.9896 - val_loss: 0.2602 - val_accuracy: 0.9271\n",
      "Epoch 57/60\n",
      " - 0s - loss: 0.0511 - accuracy: 0.9887 - val_loss: 0.2269 - val_accuracy: 0.9479\n",
      "Epoch 58/60\n",
      " - 0s - loss: 0.0158 - accuracy: 0.9983 - val_loss: 0.1296 - val_accuracy: 0.9722\n",
      "Epoch 59/60\n",
      " - 0s - loss: 0.0081 - accuracy: 1.0000 - val_loss: 0.1311 - val_accuracy: 0.9722\n",
      "Epoch 60/60\n",
      " - 0s - loss: 0.0057 - accuracy: 1.0000 - val_loss: 0.1324 - val_accuracy: 0.9722\n"
     ]
    }
   ],
   "source": [
    "history = None\n",
    "if load_model_file:\n",
    "    fpath = os.path.join(\"model\", load_model_file + \".hdf5\")\n",
    "    model.load_weights(fpath)\n",
    "elif save_model_file:\n",
    "    fpath = os.path.join(\"model\", save_model_file + \".hdf5\")\n",
    "    checkpointer = ModelCheckpoint(filepath=fpath,\n",
    "                                   monitor='val_loss', \n",
    "                                   save_best_only=True,\n",
    "                                   verbose=1)\n",
    "    history = model.fit(x_train, y_train,\n",
    "                        epochs=epochs,\n",
    "                        batch_size=batch_size,\n",
    "                        validation_data=(x_test, y_test),\n",
    "                        callbacks=[checkpointer],\n",
    "#                         shuffle=True,\n",
    "                        verbose=2)\n",
    "else:\n",
    "    history = model.fit(x_train, y_train,\n",
    "                        epochs=epochs,\n",
    "                        batch_size=batch_size,\n",
    "                        validation_data=(x_test, y_test),\n",
    "#                         shuffle=True,\n",
    "                        verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 256)               48128     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 128)               32896     \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 64)                8256      \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 12)                780       \n",
      "=================================================================\n",
      "Total params: 90,060\n",
      "Trainable params: 90,060\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Display model architecture summary \n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy:  1.0\n",
      "Training Cross Entropy: 0.01\n",
      "Testing Accuracy:  0.9722222089767456\n",
      "Testing Cross Entropy: 0.13\n"
     ]
    }
   ],
   "source": [
    "score_train = model.evaluate(x_train, y_train, verbose=0)\n",
    "print(\"Training Accuracy: \", score_train[1])\n",
    "print(\"Training Cross Entropy: %.2f\" % score_train[0])\n",
    "\n",
    "score_test = model.evaluate(x_test, y_test, verbose=0)\n",
    "print(\"Testing Accuracy: \", score_test[1])\n",
    "print(\"Testing Cross Entropy: %.2f\" % score_test[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_percentages = model.predict(x_test) # predicted percentages\n",
    "\n",
    "y_pred = np.argmax(y_pred_percentages, axis=1) # Most prevalent prediction\n",
    "\n",
    "cm = confusion_matrix(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "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"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAEaCAYAAADwlvf0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXgcxZn48W/NrfsaS7Z8YgM24GBzmyNgCFcI1yakNgkmIReb/ZGEZJfdDWx2Q+5kN8uGhVwOkINAoCCBhCtAQrAJN5jLYGyDb0u2LOu+5ur6/dEtWRayLMnSjNTzfp5nnpnp6Z6udzR6u6aqulpZaxFCCOFvgVwXQAghxPiTZC+EEHlAkr0QQuQBSfZCCJEHJNkLIUQekGQvhBB5QJK9EB6l1Cal1FdHuI1VSi0b4vWl3jozDryEQoyeJHshhMgDkuyFECIPSLIXE5ZS6gml1C1KqW8ppRqUUi1KqW8rpQJKqf9USu1USu1SSn17wHYlSqmfea/1KKVeVEqdPWCdRUqpp73X1yml9CD7L1ZK3aCU2q6U6lJKvayU+uAYxLVEKbVSKdWtlGpWSt2hlKru9/oMpdTvlFKN3joblFL/0u/1i7yydHmfyfNKqaMOtFzC3yTZi4nuEiAMnAL8E3At8ABQDLwXuBq4Vin1/n7b3AqcAywDjgKeAh5QSi0AUEoVAA8BLcAJwCeAfwH6J1wF3A8sAv4eWAj8BLhTKfW+0QajlJoKPApsA44HLvDe+3f9VvsxUAacCRwGfNpbv3f7u4HfAkcAJwI/BNKjLZPIE9ZaucltQt6AJ4BXBix7A3h9wLJXgR94jw8GLHDegHVWAbd6jz8DdAAV/V5f6G33Ve/5UqAHKBvwPrcC9/V7boFlQ8Sw1Ftnhvf8m7iJO9JvnUXeOqf2i+e6fbzfUd66c3L995Hb5LqFxu6wIcS4eHXA8x3ebeCy3lr54d79ygHrrMStBfeus8Za29z7orV2tVKqtd/6xwERYLtbye8TAdaPJIABjgCetdYm++37VW/fR3jl/CHwM+/XyhPAg9ba3nheAx4BViulHvNe/721dusBlEnkAWnGERNdasBzu49l+/suK2+9gY/3JQC0AosH3A4H3j/EdsOxr327PxWs/QUwG/gpMA14WCn1G++1jLf/M4AXgA8B65RS5x9gmYTPSbIXfvOGd3/qgOXv7ffaG8DhSqny3heVUkfgtpP3ehEoB2LW2rcH3LYcYPlOVEpF+u17kbfv3vJhra231v7CWvtx3Db7S5VSpd5r1lr7vLX2O9baU4EVwCcPoEwiD0iyF75irX0HtwPzx0qpc5RSC5RSN+C2yf+3t9odQDvwG29UzhLctvjufm/1OPBn4PdKqb9TSs1VSh2jlPqCUuqzB1DEm4BS4JdKqYVKqVOA24C/WWufBFBK3aSUOk8pNc87CH0Q2Aq0K6VOUkr9h1LqBKXULK+z+EjgzQMok8gDkuyFH30Gt137N7ht/icD51tr3wKw1nYB5wFVwPPA7cD/Ag29b2CttcCFwO+B64G3gAeBDwDvjLZg1tqdwNnADNxmmAeA1bjNMb0Ubrv9atw2/CLg/V6ZWnH7Hv6A23dwq1f+b462TCI/KPf7I4QQws+kZi+EEHlAkr0QQuQBSfZCCJEHJNkLIUQemMhn0ErPsRBCjJwabOFETvbU1dWNart4PE5jY+MYlyY3/BQLSDwTmZ9iAX/FM9xYamtr9/maNOMIIUQekGQvhBB5QJK9EELkgQndZj+QtZaenh4cx2HAtLN72blzJ4lEIoslGzvWWgKBALFYbMgYhRBiJCZVsu/p6SEcDhMKDV3sUChEMBjMUqnGXjqdpqenh4KCglwXRQjhE5OqGcdxnP0mej8IhUI4jpPrYgghfGRSJft8atbIp1iFEONvUiX74bAtTThdHbkuhhBCTChZaxPRWpcDN7Pnws6fMsY8M+Y7amvGYiESG/O3bm1t5d577+Xyyy8f0XaXXXYZN910E2VlZftfWQghxkE2a/Y3AH8yxiwAFgFrxmUvSoEzPjMttLW18etf//pdyzOZzJDb3XbbbZLohRA5lZWavda6FPeaoJcDGGOSQHJcdqYCYMenc/M73/kOmzdv5qyzziIcDlNYWEhNTQ1vvPEGTzzxBJ/61Keoq6sjkUjw6U9/mmXLlgFwwgkn8PDDD9PZ2cmyZcs4/vjjefHFF5k6dSq33nqrjLoRQoy7rFypSmu9GFiOe53MRcBLwFXGmM4B610BXAFgjDkmmdz7eLBz506i0SgA6Tt+hrNlw7v2ZRPdoAKoSHTE5QzMmkvoY/+wz9e3bNnCsmXLWLlyJU899RSXXnopK1asYPbs2QA0NzdTUVFBd3c355xzDvfddx+VlZUce+yxPPLII3R2drJkyRIeffRRFi5cyGc/+1nOOeccLrnkknftK5FIUFNTQygUIp1OjziWiUrimbj8FAv4K57hxhKJRCDHE6GFgKOBLxhjntNa3wB8BfiP/isZY5bjHhQA7MCJfxKJRN/4ecdxGOpANZqDmOM4Q36gvc016XSaTCbD4sWLmT59et82y5cv5+GHHwbcSdzWr1/PMcccg7WWTCZDJpNh5syZLFiwgHQ6zcKFC9m0adOg+0wkEjQ2NvpqMifw1+RU4K94/BQL+CuesZgILVvJfhuwzRjznPf8HtxkP2qBj3x20OW2fhsqGIDqfQc9VgoLC/seP/300zz55JPcf//9FBQUcMkllwx6Fm/vLxOAYDBIT0/PuJdTCCGy0kFrjNkBbNVaz/cWvQ+3SWfsjWMHbVFRER0dgw/rbG9vp6ysjIKCAt5++21WrVo1LmUQQojRyObpqF8AbtdaR4ANwCfHZS9KgTP06JjRqqys5LjjjuOMM84gFosRj8f7Xlu6dCm33XYbZ555JnPnzuXoo48elzIIIcRoZKWDdpTswIuXdHV17dV0MuhGDfWodApqZ41n2cZdb6x+ancEf7Wjgr/i8VMs4K94RthmP2gHre/OoCUQwMq8MkIIsRf/JXulYOL+WhFCiJzwabKXmr0QQvTn02QvNXshhOjPh8k+ANaO6qQqIYTwKx8me68jWppyhBCijw+TvRfSONTsW1tb+eUvfzmqbX/+85/T3d09tgUSQohh8l+yD3g1+3E4i3ZfUxwPx8033yzJXgiRM/67oGtfM87YJ/v+UxyfeuqpxONx7r//fpLJJOeeey5XX301XV1d/MM//AP19fU4jsNVV11FY2MjO3fu5MMf/jAVFRXcc889Y142IYQYyqRN9je/uJONze+eRMw6GUhmYO12VGBkP1wOqojxmWNr9vn6tddey9q1a3nsscdYsWIFDz74IA8++CDWWi6//HKeffZZdu/ezdSpU7ntttsA99dAaWkpy5cv5+6776aysnJkgQohxBjwXzPO4GcKj7kVK1awYsUKzj77bM455xzeeecdNm7cyIIFC3jyySf59re/zXPPPUdpaWlWyiOEEEOZtDX7fdXAbU837NgGNTWogqHn0TkQ1lo+//nPc9lll73rtYcffpjHH3+c7373u5x22ml8+ctfHrdyCCHEcPivZj+OQy/7T3G8dOlS7rrrLjo73Ytt1dfX09jYyI4dOygoKOBDH/oQn/vc53j99dcBKC4u3uf0yEIIMd4mbc1+n8axg7b/FMenn346F198MRdeeCHgXsjkxhtvZNOmTXzrW99CKUU4HOa73/0uAJdeeinLli2jurpaOmiFEFnnvymOUynYvgniNajiydteLlMcTw5+isdPsYC/4pEpjgczjjV7IYSYrPyb7GVOeyGE6DOpkv2wmpwC/qjZT+DmNSHEJDSpkn0gECCdTu9nLTXppzlOp9MERnhCmBBCDGVSjcaJxWL09PSQSCRQat8nTzkb34HqqQSiBVks3diw1hIIBIjFYrkuihDCRyZVsldKUVCw/wTu3H87HLWEwOGLslAqIYSY+HzZVqCiUUgmc10MIYSYMPyZ7CNRSEmyF0KIXllrxtFabwLagQyQNsYcO177UpEoNpkYr7cXQohJJ9tt9qcbY8b9lDap2QshxN782YwTjYHU7IUQok82a/YWeFRrbYGfGWOWD1xBa30FcAWAMYZ4PD6qHbVGY4Q62qga5fYTSSgUGvXnMBFJPBOXn2IBf8UzFrFkM9mfbIyp01pXA49prd8yxqzsv4J3AOg9CNjRTmIUCkdId3X5YhIkP03mBBLPROanWMBf8YxwIrRBZa0ZxxhT5903APcCx4/XvqTNXggh9paVZK+1LtJal/Q+Bs4GVo/X/lQkKm32QgjRT7aacWqAe7XWvfu8wxjzp/HamZxUJYQQe8tKsjfGbACyNneB24wjNXshhOjly6GXRKPgONj9zpAphBD5wZfJXkWi7gPppBVCCMD3yV6acoQQAvye7KWTVgghAN8ne6nZCyEE+DTZE/Wu8iRt9kIIAfg02UszjhBC7M3fyV46aIUQAvBrso9KzV4IIfrzZ7L3avZW2uyFEALwebKX0ThCCOHyZbLvG40jzThCCAH4NNlLB60QQuzN38leavZCCAH4NdmHQhAIyElVQgjh8WWyByAsFzARQohe/k32kYiMxhFCCI9/k304Ih20Qgjh8W+yj0gzjhBC9PJxso/IGbRCCOHxb7IPR2Q0jhBCePyb7CNR6aAVQgiPf5N9WEbjCCFEL98meyXNOEII0SeUzZ1prYPAi8B2Y8z547ozGY0jhBB9sl2zvwpYk5U9RaRmL4QQvbKW7LXWM4APADdnZYcyXYIQQvTJZjPOD4F/BUr2tYLW+grgCgBjDPF4fFQ7CoVCFJaV0ZlKUlVVhVJqVO8zEYRCoVF/DhORxDNx+SkW8Fc8YxFLVpK91vp8oMEY85LWeum+1jPGLAeWe09tY2PjqPYXj8fpSmfAydC4cwcqFB7V+0wE8Xic0X4OE5HEM3H5KRbwVzzDjaW2tnafr2WrGedk4EKt9SbgTuAMrfVvxnWPkYh7L005QgiRnZq9MeYa4BoAr2Z/tTFm2bjutO9qVUmgaFx3JYQQE51vx9kTlouOCyFEr6yOswcwxjwBPDHuO+ptxpHhl0II4d+avQpLshdCiF6+TfbSQSuEEHv4N9lLm70QQvTxb7LvG40jyV4IIXyc7N1mHCvNOEII4eNkLx20QgjRx7/JXjpohRCij3+TfVja7IUQopePk31vzV6SvRBC+DbZq1AIgkFpxhFCCHyc7AG3di8dtEIIkQfJXmr2Qgjh82QfiUoHrRBC4PdkLzV7IYQA/J7sIxGsjMYRQgi/J/uodNAKIQR+T/YyGkcIIQC/J/tIVE6qEkIIRnBZQq316cAmY8xGrfU04HtABrjWGLNjvAp4IFQ4gpWavRBCjKhm/2Pc5A7wP0AYsMDysS7UmJHROEIIAYzsguPTjTFbtNYh4BxgNpAE6salZGMhEpFmHCGEYGQ1+zatdQ1wGvCmMabDWx4e+2KNERmNI4QQwMhq9jcCLwAR4EvespOBt8a6UGMmHIVkEmstSqlcl0YIIXJm2MneGPN9rfW9QMYY8463eDvwmf1tq7WOASuBqLfPe4wxXxtFeUcmEgHrQCYNoYn7A0QIIcbbiIZeGmPW9SZ6b3TOVGPM68PYNAGcYYxZBCwGztVaLxlxaUcqLFerEkIIGEGy11qv0Fqf7D3+N+BO4Lda62v3t60xxg5o4+8dyTO+InIdWiGEgJG12S8EnvUefxZYCnQATwHf2d/GWusg8BJwMPAjY8xzg6xzBXAFgDGGeDw+guLtEQqFiMfjdFdW0QZUFBUSGuV75VpvLH4h8UxcfooF/BXPWMSirB1eBVtr3QxUAQcBjxpj5nnL240xJcPdoda6HLgX+IIxZvUQq9q6utGN6ozH4zQ2NuK88CR2+X8TuO4m1PRZo3qvXOuNxS8knonLT7GAv+IZbiy1tbUAg45GGUmb/d+Am4Af4CZrtNbzgBF9msaYFuAJ4NyRbDcaKiIXHRdCCBhZsr8caAFeA67zli0AbtjfhlrrKV6NHq11AXAm2RiyKR20QggBjGzo5W7g2gHLHhzm5tOAX3nt9gF3U/PAsEs5WtJBK4QQwMgmQgsDXwUuA2pxp0m4Dfi2MWbIbGqMeQ046gDKOTphacYRQggY2Wic/wKOBz4HbMadG+c/gFLgy2NftDHg1extMjl4j4UQQuSJkST7DwOLvOYcgLVa61XAq0zUZN/XZi81eyFEfhtJB+2+KscTt9LcNxpH2uyFEPltJDX7u4H7tdZfB7bgNuN81Vs+MUVkNI4QQsDIkv2/4ib3H+F20G7HnTLhm+NQrrEhHbRCCAHsJ9lrrc8YsOgJ76bYM7fNKcDjY12wsaCCQQgGpWYvhMh7+6vZ37KP5b2Jvjfpzx2zEo21cETa7IUQeW/IZG+MOShbBRkLGcfy+Qc2cP7Cbj4wt8BdGJZLEwohxIjms5/oggFFImPZ0tK9Z2EkKs04Qoi856tkD1BTFGZHW8+eBZEoVjpohRB5znfJvro4TH1rv+QejkjNXgiR93yX7GuKwzR0JEhlvD7kiHTQCiGE75J9dVEYCzR2pdwFMhpHCCH8l+xrisMA7Ozwkn0kCglpsxdC5DffJfvqIjfZN3S6yV5FolKzF0LkPd8l+3hhmKDqV7MPR2S6BCFE3vNdsg8GFNUl0b6aPREZjSOEEL5L9gDTSmMDavaS7IUQ+c2nyb5fzT7snkFrrR16IyGE8DGfJvsYzd1pEmnHbcaxDqTTuS6WEELkjG+TPcCurlS/q1VJJ60QIn/5NNm7Cb6hI9XvOrTSbi+EyF8+TfZuzX5nR2rPpQmlk1YIkcd8mezjxRFCAe/Eqt5LE0rNXgiRx0ZyDdpR01rPBH4NTAUcYLkx5obx2l9AKaYUhdnZkUKVRtzLakmbvRAij2WrZp8G/tkYcxiwBLhSa334eO6wpijs1ex72+wl2Qsh8ldWkr0xpt4Ys8p73A6sAaaP5z5riiNuB21EmnGEECIrzTj9aa3nAEcBzw3y2hXAFQDGGOLx+Kj2EQqFmFNdxiNvtxCpnEIPUFIQJTbK98ulUCg06s9hIpJ4Ji4/xQL+imcsYslqstdaFwO/A75kjGkb+LoxZjmw3HtqGxsbR7WfeDxOsXLPoF2/u5OZQFtjIx2jfL9cisfjjPZzmIgknonLT7GAv+IZbiy1tbX7fC1ro3G01mHcRH+7Meb3472/3nntG9JBd4EMvRRC5LGsJHuttQJuAdYYY67Pxj5rvHntdyaVu0CSvRAij2WrGedk4DLgda31K96ya40xD43XDstiQSJBRUPvIBzpoBVC5LGsJHtjzN8AlY199VJKUV0UpqHbcRfI0EshRB7z5Rm0vWqKwzR0piEYkpOqhBB5zdfJvroozM7OlFytSgiR9/yd7IvDdCYdOmMl0kErhMhrvk72fcMvC+NSsxdC5DVfJ/vqoj3J3kqbvRAij/k62dcUu5OgNRTGobUlx6URQojc8XWyL4kEiIUCNMRnwcZ12J7uXBdJCCFywtfJXinlDr8sqoZMGta/kesiCSFETvg62YPbbt+gYhCOYN94OdfFEUKInPB9sq8pDrOzM4M95HDsm6/sfwMhhPAh3yf76qIwPWmHjgXHQP1WbPPuXBdJCCGyzvfJvnes/a7ZCwGwa6R2L4TIP75P9r1j7XcWxqGkDN6QZC+EyD/+T/a9Z9F2pVGHLcaueQXrODkulRBCZJfvk31xJEhRJOBefPyIxdDeCts357pYQgiRVb5P9gC1JRHW7e5BHbYYAPumDMEUQuSXvEj2px9UxjtNPaxNF8K0mTIEUwiRd/Ii2Z8xt4yiSIA/vtWEOuIoWP8mVq5cJYTII3mR7AvCAc6eV84zW9tpPPgod277t9/MdbGEECJr8iLZA3xgfgUADzrTIBiSphwhRF7Jm2Q/pSjMiTNLeGxjB92HvEeSvRAir+RNsge4cEElnSmHJw46FbZuxLY157pIQgiRFXmV7BdMKeDQqhgP2uk4KOya13JdJCGEyIqsJHut9a1a6wat9eps7G8oFyyopK4HVtUeBTLlsRAiT2SrZv9L4Nws7WtIJ80qoaowxAPzzsQ+8ziZG67DrnkVa22uiyaEEOMmK8neGLMSaMrGvvYnFFB84NAKXgvG2XzBZ2DzOzjX/wfOt/4J5/mV2Ewm10UUQogxl1dt9r3OPricaFBxb+WxqO/djLrsSkj0YH/+A5yvfxHb2ZHrIgohxJgK5boA/WmtrwCuADDGEI/HR/U+oVBoyG3jwIcXd/Obl7aRVkGuPVdTfvFHSTzzBK3/+zXC5mbKrv4mSqlR7X8s7S+WyUbimbj8FAv4K56xiEVlq61aaz0HeMAYs3CYm9i6urpR7Ssej9PY2Dj0m1vLg+ua+cWqXZREg/zTSdM4cmoRzsP3YH//a9QnryJw0vtGtf+xNJxYJhOJZ+LyUyzgr3iGG0ttbS3AoLXUvGzGAVBKcf78Sn5w7myKwgH+8y9bue2VXWTOuhgOXYi9Yzm2oT7XxRRCiDGRraGXvwWeAeZrrbdprT+djf0Ox0EVMf7n/XN437wy7nljN195bBsvnn8lTjCAc8v10mErhPCFrLTZG2M+mo39jFYsFOALS6Zx1LQifrmqge+s6mH6Kf/Oha/fx9IHDLGLJnTxhRBivyZUB22unTK7lBNnlvDUlnbufXM3P5l/CXc0tXPmX9dQNrUGpfY0hhWEA7x3dinRUN62hAkhJhFJ9gMEA4pT55Ty3tklvLalmfse3sjv6kqgruFd665r7OH/nTA1B6UUQoiRkWS/D0opFs2u5MhzDqbr1v8j07gTi8ICxAq4+9DzeeDthZy05jGOLEhCUREUl6KOOxVVVJzr4gshxF4k2e+HOugQir55I7anC7ZvwW7fBNs2c2n967wUm8GP7SFc/9RNFHS3AWBXPUPgy9+YEGP0c2lra4LKghBFkWCuiyKEQJL9sKlYIcxbgJq3AIBC4AsNXfz7Y1u44+P/w2cXV2JXPIK9czn2qT+jTjkrtwXOoc5khqv/tImDK2N888xZBPL8wCfERCC9iwfgiOpCzptfwYNrm3mzKYU6/Tw49AisuRXbsntE72WTCezO0Z1ENtGs3NRGT9qyuqGbh9e15Lo4Qggk2R+wyxZNoaY4zE3P1pN0IPDxL0A6hXP7T4c9k6a1FufH38H52uexO7aNc4nH3182tDK7PMpR04r41csN1Lcnc10kIfKeJPsDVBAOcOUJU6lrT3HHa42omlrURR+DV56Dl57aa92MY9namuBvm9t4bls7ibQDgP3bY+7c+o6Dc9fNk3q65U3NPazf3cNZ88q48oSpBAOKG5+tx5nEMQnhB9JmPwYWTS3inIPL+eNbTfSkHSJVJ6EWpwg+sZagncPudIDNLQm2tCRJOXuSXiwU4PgpIU564ikWz19E9MijsXf/Al57ERYdl8OIRu/PG1oJBeC0OaWUxkJ86uhqbnpuBw+ta+b8+ZW5Lp4QeUuS/Ri5/OgpbPFq7Y6FTOUiMuk0mbXtlBeEmF0R4wPzi5hdHmVOeZS2RIa/bW7jmfUNrJz/UQpDsKSohPfPeZV55mYChy9GhcO5DmtEUhmHJza2ccKMEkpj7lfrzHllPL2lnV+/vItjaovxySSEQkw6kuzHSGE4yPfOnr3XMue+32AfNAT+8Suoo0961zZHvvM0n33yR6z+uy/yVPlhPLWlncfnfITDWzZw4UN/5fgLxn5Ej00lwbGoaHTM3/v57R20JzKcOa+sb5lSiiuXTOWLD2zkxmfr+emcaWO+XyHE/kmyH0fqA3+PffV5nJ98D445icCHLkdNcc+4tU2NWHMLoUOP4OhzlnJMIMCnjqnmz++0cP+LnXyvo4iaP6zng0clqAqlqSoMES8KUxIJjHoMv3UyON//CmTSBP79elRobP/8f367larCEIumFu21PF4Y5lPHVHPjszu455U6zpg59gcaIcTQJNmPIxUOE/jKf2EfvQ/7p9/hvPo86ozzUedpnNtugkyGwCe+gAq4/eTFkSAXH1bF+ZVJnrnxJzww/1x+8pSz13tGgop4YZiDK2PMnxJjQbyQORVRQgH3AGCtpak7TX17ih0dSaoKwyysLiAcDGCffAw2v+2u98SDqDMvojOZ4aW6Tho7U8ypiHJQRYyKgpF/LXZ1pni5vpMPL6wiGHj3weh9c93mnJ8+vZn575/D9NLIiPchhBg9SfbjTEVjqAs+gn3vWdj7bsc+9gfsij9Bogf10Sv6avr9hWqmcfIxh3LSQ9/D+dqP2RCrYndXit1daRq70uzoSLK6oYuVm92zdiNBxbzKGD1ph/r2JD3pvUe+xEKKxVOiHP3M6xy94FiIRHjh2fU852xg9e4k6b2PJ1TEghxUEeOI6kIuPryy70AylL9uaMXiJvVBPweluPKEqVz10GZueKae7541a9CDghBifEiyzxJVXoW6/IvYM87H+f2vIBpDLT1v3+ufdwn26b8Q+fX/cujnrkHN2rtn01pLY1eat3Z1s7axm7ebeqgsCLGwupBpJRFqSyNMLQ6zvS3Ji9s7eGH9Dp6dc8GeN6iEaQ0tXHD4DE6YWcyM0iibWxJsaO5hQ1MPG5oT3PbqLjY09/DPJ9cOmZgda/nLhlbeU1PI1JJ919irCsN8eelcvvHIOv7wVhMfPLxq2J9fKuPw5q5u3lNTKGfkCjEKkuyzTM2aS/BLX9//etEYgY9eQfpn34drPoM66kTUGefDIYejlEIpxZSiMFOKwrx3Tuk+32daSYRjVBOfueU6tpzyd6w66nwAjnvzMab/+bcET/4Bako1AAtrCllYU9i37b1v7uaXL+8iqOr50knT9pnwV+/sYkdHio8euf+hNmfPn8Kjb9Zx+6uNHFtbzKzy/bffJ9IO31m5nVfqOzl1TilXnThtWL82hBB7yElVE5g6+kTiPzaoMy/CrnkV57+vwfnGl3CefBS7sw7r7P8qWtZanLtuQcUKOOjii7lkYRWXLKxi1gUXokrLcX77M6zjDLrt3x1exccXT2Hl5jZueKaejDP4iVF/eaeVonCAE2eW7D8mpfjH46dSGA7ww2fqSe/jPXt1pTJ8/a9beW1HJyfPKmHlpiaJB5UAABQlSURBVDa+t3Jb3wlpQojhCV533XW5LsO+XNfe3j6qDQsLC+nq6hrj4uRGcXUN3QfNd2v1VdWwcS387THs4w9gH70X+/Kz8M5b2F07oKQUVTQg4b76PPYhg/rgJwgctqhvsQqHobgM/vogTKlBzZzb95pt2oW973acP97B4ccuJFRRyf1rm2noTHHc9GICSpHKOLy6o5M/rGniiU1tnD63jCXDSPaFhYU4yR6mFoe5f20zoYDa69dEfx2JDNc9vpV1u3v48km1fGzRFMpjQe5/q5k1u7o4cVYJ4WBu6yt++q75KRYY/3istbQnHSJBNe6z3A43lpKSEoBBmw6kGWeSUNEo6tRzsO89G7ZswG7bCNs2Y+s2Y99YBU//BXv3rXD4YgKnnQtHHg/W4phbYNrMQfsH1JKl2BUPY3/3K+ziJdDRin34d9hn/gpYKCjC+f5X+NDHP49z5ELueK2RnrRDQClW1XXSnXaIBhXHTS9CLxx++zvASbNKOXV2B3e93shx04uZWxnb6/XWnjRfe3wrW1uT/Nt7p/cdSN5/aAVFkSA/fLqOr/55K9edPqPvBK7hSjuWp7e089C6ZlIZy4eOqGTJzBLpCzgAiXR2kl4udaUyvL27h7WN3axt7GHd7m5aezKURAIcXFXAIVUxDvXuy0cxom28qQk8D4utqxvdLJDxeJzGxsYxLk5uDDcW29SIffov2CcfgaZGKKuEmXNg9SoCX/o66oijBt9u43qc714NU2fAju0QDKJOOQt17gchHMH52fdh3Ruosy7irvkXcOfqJipiQY6fUcLxM4o5cmohkRHUrvvH057I8IUHNtCZcqgpDlNVEKKqMExVYYhntrazsyPFNadO5+jad18M5sXtHXz/ye1MKQpz4swSQgEIBVTfrbIgxNQSt5O6d079tp40j7zdwsPrWtjdnWZaSZiAUmxvSzK3IsrHjpzCsdOLRpSw8vG71t+6xm7ueWM3z23r4LApBVy6KM57aor2v2EWjMXfJplxeHZrB49vaOXVHZ30tjpOL40wPx5jZlmUurYk63f3sKU10ff6ybNK+PQx1VQVjs1Z8MONpba2FvZcPXUvkuwnuJHGYp0MvP4Szoo/weqXYNEJBK+8dshtnNt/in3mcdRp70eddRGqfM8cNjadxppbsH99EA5bxO5l/0R8SjkBpdwLurQ0QVsLFJVA1RR33v+BZbIWurugeTdV8w6mqWfPLJgbm3t47J1WmrpSNHal2d2Vprk7TWE4wDWnTR8ycaze2cX1T9XR0pMmM8TXuCQapKYozJbWBMmMZdHUQi5cUMnRtUVYCys2tXHX643s6EhxaFWM8+dXUBINEgoowgFFKKhwrHsuwc6O3luS5p4Mh08r47CKIIumFVE+wl8YvRq7Uqze2cWbDd3UdyQJBxThoPLuA5REAhxVW8zC6kLCwdHVnDOOpbHLLXtDZ4qAUkwrCTO9JEJJNIhSaq/vWjLj0NydpjvlUB4LURoL9v3ysdby6o4ufvfGbl7b2UVRxL0e8/PbOmjqTrNoaiGXLprC/HjBqMo6VkabB6y1rN/dw+MbWlm5uY3OpMOUwhCnHVTGEdUFHFpVQHH03Rfl6Uk7bGjq4aU6t3kzFFBcuijOeYdWHPAwY0n2+5DPyb4/29YMBUWo8NAnMFnHASeDCu27FuI89Wfsb34MhcVQUOQm+UT3u1csLIbKKVA1BVJJ91dG8+6+dVVBIZzzQdSZF+1zyoa0Y7HWjqg93rGWjGNJOZZ0xvadj7CjPcWODvcEs6nFEc6fXzHoCKC0Y3l8Qyt3vd5IY1d6yH2VRoPUFIcpjQZZ35Sgrcddf25FlMXTiqguChMNBYiFFLFQgGgoQMaxdKccutOOe59y2NqW4I2GbnZ2pNyPLhxgZlmEtAPpjCXlOCQzlrZEhmTGUhgOcHRtESfMKGHR1EKau9NsaU2ypSXBltYE29uSZKwlqBTBgCIUgIBStCUy7OpMsa++8KJIgNqSCGWFMRraumjqTtOR3LsDPKCgIhaioiBEyrFsbklQURDiogUVnHNIOYXhIIm0w5/Wt3DPG7tpS2Q4bnoxB1VEaU9kaEtk6Ei6t2gw4A4PLokwrSTMtJIIxZEg3WmHrlSm73PKOFAUDlAcDVIUCVAcCVIQCpDKWBIZh0TavU9mLLFQgKJIgMJwgIKQe5Z5sLCU59fX8U5TD283uUOKlYIpRWGqi8JUF7v3APXtKerak9S3J6lvT7kTGgYVJ84s4Yy5ZRw5dWRDfuvbkyx/YSer6js5qCLKPx4/9YAOfpLs90GS/fiwG9fh3H8nKhqD8kr3VlaJKi3HdrbD7gbYvQvbtAuadkE4AhVxVEUVVMShrILI6hdJPLcSyitRF12KOukMVGD/ly60TsY9cAAEQxAMuPehyJjO85PKOGxtTZLMWNLOnhtAvDBEdXGYwvCe8lZUVvH8+m28XN/JK/WdvLWre8hfGf2VRIMcUV3AwupCjqguZHZ5dNAaYCLt8NqOLp7d1s4L2zto7dl7FFZAQW1JhBllESKBAGnvwJd2LBkLpZEg1cVharxbdVEYx7oJqa49SV2bm+RSBCkJWyoL3KReWRCiIBygpTtDU7f7i6u5O01P2mHpQWWcMbd00ANyVyrDA2ubuW9NE90ph6JIkJJIkJKom7C7U+7Jf809+x9NNhoB5c4o25Xac8CqLYkwrzJKUCkaOt1fN03d6b4DYFBBTbF78KktiTCnIsqJM0sO6LKa1lqe3trOLS820NSdJl4YwgEc642S670HrN2zvCwW4ucXz9vrvSTZ78NESpAHyk+xgBvPrmdW4tzzC9iwFqbPdqeQKKuAomL3l0FhMTgZ2LQeu3E9duM62PT24L8kAOYcgjr2ZNQxJ6PiNVmPp//fJ5lx6Eo69KR7b5aetEMwAAWhIAXhAAVhtwYaHUWHZsaxrGvsZs2ubuJFYWaVRZheGhmTUUlj/V3LOBal2GeNuDfp17cn6Uo5bq289xYKEAooOlMO7d6vgs6k+4soElJEgwGiIUU0FCAcUCTSDp0ph45khq6k+wthTnU502IZ5lbEBk3aacfS2On+qppSFB63M7q7Uhn+sKaJhs4UCkXA+0wCir7PRyl3HLxSioJwgI+8Z+9zViZVstdanwvcAASBm40x39vPJpLs8VcssCceay2sehrn97+Ghvp9bxAMwYw5qLmHwoyDIBiETBoybtMTnR3Y117om/OnL/HX1EIwDKEQhLx7x4Fkwm1eSiWxyaS7LBh0O6aDQe9XQ9DbJgzhMIQi7vbgVsHo/Z9RVM2cxe5Ecli/TvbHOhnIZPbb7DZe/PpdGw/WcaCzAzraIJWAVArSKfe7lclATS3UTB+z0UmTJtlrrYPAOuAsYBvwAvBRY8ybQ2wmyR5/xQLvjsdmMrB7J3R2Qmc7tqsDujrAWtSseTBr7rCSn921A/vSU9gXn9qT+LNFBdxfJSVl7i0ag3DEPZchEnUPGsEgoNw2BrwqXaIb29Lk9n+0NEFbs3vwicaguBRKy6HYO3ciGIBA0N1XYMBNKe8+CNEoRAsgVoCKufcEBqn1BwLeQc47uAXDVFRV0tzSQl+u6E1U/Q9wFreMiW7o6YLubrejvrsLEj3e8h5I9GAT3ahgyI0nVuCVKwaFxajiUrdTv6TUjTVW6MaoRj+r60DD+d+xTsZN1MmEe0v0uPfdXdi2FmhtdgcgtLW4fWBtLdDWCh2tblIfSlEJzJ2PmjsfNW+Be55M7+cQiYzLqK+hkn22BoMeD7xtjNkAoLW+E7gIGCrZizyggkGort3zfLTvM2Uq6twPwbkfwjY1uv+M6bRb2+q9DwQgHIVIxO1PiETc5Ok43q+FjPtroXd9r7ZmUynIpHh3EnQoxtKxow7a27AdrdDe6iaIVBLbW9NLJt33tQAWrOM+jkT7+j7U9FnucNlI1K0ttrdi29ugZTe2botbRq8jHevseW7tgNf2VN5GWo3bPcrPfi/BYN/BhmgMm0m7CbSnZ69muCHLFvQOasFgvwNZvwMb7BVn38HI7v24QSkslr6Dq8L7W2f2/L2HU9kNhdwDb0k5lFe5lZDScm9ZGSoS9X4Bht3vlVLY7Zvdkx03rMW+/uK74w0E3M8pHHYP4sHgngNwaTnBf/nu/ss1QtlK9tOBrf2ebwNOGLiS1voK4AoAYwzxUV7WKBQKjXrbicZPsUCW4sni5xUKhShMDz16J1uste5BprsL29ON092F7e5yDwIDOY6biNPpvvsAkOmtrfYmQWu9RKn2HOsCQVSsAFVQhCosIlBQiCoodJ8PcXU16zjYRDe2swOnrQWnrRWnvQXb3obt6nSbRrxE3NukhbXeaDFnz0Gu/0G3r3ag+pVT9c0f5fQeZK11b8GA+2sjGHKv5xAMocJhN55obM+toIhAeQWBiipUYfEofm2cvOej7mgjtf5NnJZm72/j/n1sd5fXlJjpi9dmMgQKCikd8B0ei/+bbCX7wT6pdx3sjDHLgeW9r4+2+cJPTR9+igUknqwJRqA4AsXlw97kgGJJpiHZOtzCQWmVextHY/K36U64twM182CYOfzVB5Z7hM04g8rWxCLb2DvUGcDoGuSFEEKMWLZq9i8Ah2itDwK2Ax8BPpalfQshRN7LSs3eGJMGPg88AqxxF5k3srFvIYQQWZz10hjzEPBQtvYnhBBiD7l4iRBC5AFJ9kIIkQck2QshRB6QZC+EEHlgQs96mesCCCHEJDTo6b4TuWavRnvTWr90INtPpJufYpF4JvbNT7H4LZ4RxjKoiZzshRBCjBFJ9kIIkQf8muyX73+VScNPsYDEM5H5KRbwVzwHHMtE7qAVQggxRvxasxdCCNGPJHshhMgDWZsILRtGcVHzCUVrfStwPtBgjFnoLasE7gLmAJsAbYxpzlUZh0trPRP4NTAVcIDlxpgbJnE8MWAlEMX9v7nHGPM1b9ruO4FKYBVwmTEmmbuSDp93begXge3GmPMneSybgHYgA6SNMcdO1u8agNa6HLgZWIh7ztGngLUcQDy+qdl7X9wfAe8HDgc+qrU+PLelGrFfAucOWPYV4C/GmEOAv3jPJ4M08M/GmMOAJcCV3t9jssaTAM4wxiwCFgPnaq2XAN8H/teLpxn4dA7LOFJX4U453msyxwJwujFmsTHmWO/5ZP2ugVtp/ZMxZgGwCPfvdEDx+CbZ0++i5l5tpPei5pOGMWYl0DRg8UXAr7zHvwIuzmqhRskYU2+MWeU9bsf9sk5n8sZjjTEd3tOwd7PAGcA93vJJE4/WegbwAdzaI1prxSSNZQiT8rumtS4FTgVuATDGJI0xLRxgPH5K9oNd1Hx6jsoylmqMMfXgJlCgOsflGTGt9RzgKOA5JnE8Wuug1voVoAF4DHgHaPEuzgOT6zv3Q+BfcZvYAKqYvLGAe+B9VGv9ktb6Cm/ZZP2uzQV2Ab/QWr+stb5Za13EAcbjp2Q/2GnCMq40x7TWxcDvgC8ZY9pyXZ4DYYzJGGMW415D+XjgsEFWm/DfOa11b7/QS/0WT/b/n5ONMUfjNuNeqbU+NdcFOgAh4GjgJ8aYo4BOxqAJyk/J3q8XNd+ptZ4G4N035Lg8w6a1DuMm+tuNMb/3Fk/aeHp5P6mfwO2LKNda9w50mCzfuZOBC71OzTtxm29+yOSMBQBjTJ133wDci3swnqzftW3ANmPMc97ze3CT/wHF46dk33dRc611BPei5n/McZnGwh+BT3iPPwH8IYdlGTavDfgWYI0x5vp+L03WeKZ4IyTQWhcAZ+L2Q/wVuMRbbVLEY4y5xhgzwxgzB/f/5HFjzKVMwlgAtNZFWuuS3sfA2cBqJul3zRizA9iqtZ7vLXof8CYHGI+vzqDVWp+HW0MJArcaY76d4yKNiNb6t8BSIA7sBL4G3AcYYBawBfiwMWZgJ+6Eo7U+BXgSeJ097cLX4rbbT8Z4jsTtFAviVpKMMeYbWuu57Bmu+DKwzBiTyF1JR0ZrvRS42ht6OSlj8cp9r/c0BNxhjPm21rqKSfhdA9BaL8btPI8AG4BP4n3vGGU8vkr2QgghBuenZhwhhBD7IMleCCHygCR7IYTIA5LshRAiD0iyF0KIPOCrWS+FmEi8aSI2AuF+0xAIkRNSsxdCiDwgyV4IIfKAnFQl8orWuha4EXcK2Q7c+dv/T2t9He6FIjLAecB64JPGmFe97Q4DfoI7l/124BpjzB+91wqAb+FONVCOe9bwWUANbjPO5cA3gUJvf5PqzG7hD5LsRd7QWgdw51D6A/A93Mm+/gz8I3Ai8O/AR73XrwKuBA71Nl8D3Ar8ADjFW+dYY8xarfWPgCOAS4EdwAnAS8A03GR/M/BF772eBxYbY/pfNESIcSfJXuQNrfUJwN3GmFn9ll2Dm4Q3A+caY5Z4ywO4NXjtrXo3UGuMcbzXf4t7mbhv4E5Bu6T3V0C/956Dm+xnGmO2ecueB643xtw5XnEKMRgZjSPyyWygVmvd0m9ZEHfCts30u/iNMcbRWm8Dar1FW3sTvWcz7sU94kAM90Im+7Kj3+MuoHjUEQgxSpLsRT7ZCmz0ruG5F6/Nfma/5wH2ntN9ptY60C/hzwLWAY1ADzAP2KtmL8REIsle5JPngTat9b8B/wckca82VeC9fozW+oO484Z/Efci48/iXsWpE/hXrfX/4F784wLgOO8XwK3A9Vrry3Cnpj4eWJW9sITYPxl6KfKGMSaDm6QX47alN+J2npZ5q/wB+HugGbgM+KAxJuVdwP5C3EveNQI/Bj5ujHnL2+5q3BE4L+BeMP77yP+WmGCkg1YI+ppxDjbGLMt1WYQYD1L7EEKIPCDJXggh8oA04wghRB6Qmr0QQuQBSfZCCJEHJNkLIUQekGQvhBB5QJK9EELkgf8PjD6a/x1jV7wAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()\n",
    "# summarize history for loss\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()\n",
    "#32, 32 lstm, w/ mel, chroma, zcr, mfcc, sp_centroid, sp_rolloff\n",
    "#sgd 0.01\n",
    "#***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def model_analysis()\n",
    "#     lr = [ 10**lr_power for lr_power in range(0, -6,-1)]\n",
    "#     epochs = [10**e_power for e_power in range(1)]\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}