PyTorch_pipeline_kaggle.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__Python VERSION: 3.7.3 (default, Mar 27 2019, 17:13:21) [MSC v.1915 64 bit (AMD64)]\n",
      "__pyTorch VERSION: 1.3.1+cpu\n",
      "__CUDA VERSION\n",
      "__CUDNN VERSION: None\n",
      "__Number CUDA Devices: 0\n",
      "__Devices\n",
      "Available devices  0\n",
      "3.7.3 (default, Mar 27 2019, 17:13:21) [MSC v.1915 64 bit (AMD64)]\n",
      "46.8\n",
      "svmem(total=8471379968, available=4215734272, percent=50.2, used=4255645696, free=4215734272)\n",
      "memory GB: 0.40383148193359375\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import sys\n",
    "import torch\n",
    "from torch.utils.data.dataset import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import transforms\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.autograd import Variable\n",
    "\n",
    "import librosa\n",
    "from scipy import signal\n",
    "from scipy.io import wavfile\n",
    "import IPython.display as ipd\n",
    "import librosa.display\n",
    "\n",
    "from sklearn import model_selection\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import roc_auc_score, log_loss, roc_auc_score, roc_curve, auc\n",
    "from sklearn.model_selection import StratifiedKFold, ShuffleSplit, cross_val_score, train_test_split\n",
    "\n",
    "print('__Python VERSION:', sys.version)\n",
    "print('__pyTorch VERSION:', torch.__version__)\n",
    "print('__CUDA VERSION')\n",
    "from subprocess import call\n",
    "# call([\"nvcc\", \"--version\"]) does not work\n",
    "#! nvcc --version\n",
    "print('__CUDNN VERSION:', torch.backends.cudnn.version())\n",
    "print('__Number CUDA Devices:', torch.cuda.device_count())\n",
    "print('__Devices')\n",
    "# call([\"nvidia-smi\", \"--format=csv\", \"--query-gpu=index,name,driver_version,memory.total,memory.used,memory.free\"])\n",
    "#print('Active CUDA Device: GPU', torch.cuda.current_device())\n",
    "\n",
    "print ('Available devices ', torch.cuda.device_count())\n",
    "#print ('Current cuda device ', torch.cuda.current_device())\n",
    "\n",
    "import numpy\n",
    "import numpy as np\n",
    "\n",
    "use_cuda = torch.cuda.is_available()\n",
    "FloatTensor = torch.cuda.FloatTensor if use_cuda else torch.FloatTensor\n",
    "LongTensor = torch.cuda.LongTensor if use_cuda else torch.LongTensor\n",
    "Tensor = FloatTensor\n",
    "\n",
    "import pandas\n",
    "import pandas as pd\n",
    "\n",
    "import logging\n",
    "handler=logging.basicConfig(level=logging.INFO)\n",
    "lgr = logging.getLogger(__name__)\n",
    "%matplotlib inline\n",
    "\n",
    "# !pip install psutil\n",
    "import psutil\n",
    "import os\n",
    "def cpuStats():\n",
    "        print(sys.version)\n",
    "        print(psutil.cpu_percent())\n",
    "        print(psutil.virtual_memory())  # physical memory usage\n",
    "        pid = os.getpid()\n",
    "        py = psutil.Process(pid)\n",
    "        memoryUse = py.memory_info()[0] / 2. ** 30  # memory use in GB...I think\n",
    "        print('memory GB:', memoryUse)\n",
    "\n",
    "cpuStats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "use_cuda = torch.cuda.is_available()\n",
    "# use_cuda = False\n",
    "\n",
    "FloatTensor = torch.cuda.FloatTensor if use_cuda else torch.FloatTensor\n",
    "LongTensor = torch.cuda.LongTensor if use_cuda else torch.LongTensor\n",
    "Tensor = FloatTensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_ROOT ='G:/tensorflow-speech-recognition-challenge/'\n",
    "IMG_PATH  = DATA_ROOT + '/train/train/pict/'\n",
    "IMG_EXT = '.png'\n",
    "IMG_DATA_LABELS = DATA_ROOT + '/train_v2.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "audio_path = 'G:/tensorflow-speech-recognition-challenge/train/train/audio/'\n",
    "pict_Path = 'G:/tensorflow-speech-recognition-challenge/train/train/pict/'\n",
    "test_pict_Path = 'G:/tensorflow-speech-recognition-challenge/test/test/pict/'\n",
    "test_audio_path = 'G:/tensorflow-speech-recognition-challenge/test/test/audio/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = []\n",
    "\n",
    "if not os.path.exists(pict_Path):\n",
    "    os.makedirs(pict_Path)\n",
    "\n",
    "if not os.path.exists(test_pict_Path):\n",
    "    os.makedirs(test_pict_Path)\n",
    "    \n",
    "subFolderList = []\n",
    "\n",
    "for x in os.listdir(audio_path):\n",
    "    if os.path.isdir(audio_path + '/' + x):\n",
    "        subFolderList.append(x)\n",
    "        if not os.path.exists(pict_Path + '/' + x):\n",
    "            os.makedirs(pict_Path +'/'+ x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 : yes\n",
      "Done for 0 out of 2377.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\arthu\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_axes.py:7609: RuntimeWarning: divide by zero encountered in log10\n",
      "  Z = 10. * np.log10(spec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done for 100 out of 2377.\n",
      "Done for 200 out of 2377.\n",
      "Done for 300 out of 2377.\n",
      "Done for 400 out of 2377.\n",
      "Done for 500 out of 2377.\n",
      "Done for 600 out of 2377.\n",
      "Done for 700 out of 2377.\n",
      "Done for 800 out of 2377.\n",
      "Done for 900 out of 2377.\n",
      "Done for 1000 out of 2377.\n",
      "Done for 1100 out of 2377.\n",
      "Done for 1200 out of 2377.\n",
      "Done for 1300 out of 2377.\n",
      "Done for 1400 out of 2377.\n",
      "Done for 1500 out of 2377.\n",
      "Done for 1600 out of 2377.\n",
      "Done for 1700 out of 2377.\n",
      "Done for 1800 out of 2377.\n",
      "Done for 1900 out of 2377.\n",
      "Done for 2000 out of 2377.\n",
      "Done for 2100 out of 2377.\n",
      "Done for 2200 out of 2377.\n",
      "Done for 2300 out of 2377.\n",
      "1 : zero\n",
      "Done for 0 out of 2376.\n",
      "Done for 100 out of 2376.\n",
      "Done for 200 out of 2376.\n",
      "Done for 300 out of 2376.\n",
      "Done for 400 out of 2376.\n",
      "Done for 500 out of 2376.\n",
      "Done for 600 out of 2376.\n",
      "Done for 700 out of 2376.\n",
      "Done for 800 out of 2376.\n",
      "Done for 900 out of 2376.\n",
      "Done for 1000 out of 2376.\n",
      "Done for 1100 out of 2376.\n",
      "Done for 1200 out of 2376.\n",
      "Done for 1300 out of 2376.\n",
      "Done for 1400 out of 2376.\n",
      "Done for 1500 out of 2376.\n",
      "Done for 1600 out of 2376.\n",
      "Done for 1700 out of 2376.\n",
      "Done for 1800 out of 2376.\n",
      "Done for 1900 out of 2376.\n",
      "Done for 2000 out of 2376.\n",
      "Done for 2100 out of 2376.\n",
      "Done for 2200 out of 2376.\n",
      "Done for 2300 out of 2376.\n",
      "2 : _background_noise_\n",
      "Done for 0 out of 6.\n"
     ]
    }
   ],
   "source": [
    "# #### Function: convert audio to spectogram images\n",
    "# import soundfile as sf\n",
    "# from matplotlib import pyplot as plt\n",
    "\n",
    "# def wav2img(wav_path, targetdir='', figsize=(4,4)):\n",
    "#     \"\"\"\n",
    "#     takes in wave file path\n",
    "#     and the fig size. Default 4,4 will make images 288 x 288\n",
    "#     \"\"\"\n",
    "#     fs = 44100 # sampling frequency\n",
    "    \n",
    "#     # use soundfile library to read in the wave files\n",
    "#     test_sound, samplerate = sf.read(wav_path)\n",
    "    \n",
    "#     # make the plot\n",
    "#     fig = plt.figure(figsize=figsize)\n",
    "#     S, freqs, bins, im = plt.specgram(test_sound, NFFT=1024, Fs=samplerate, noverlap=512)\n",
    "#     plt.show\n",
    "#     plt.axis('off')\n",
    "    \n",
    "#     ## create output path\n",
    "#     output_file = wav_path.split('/')[-1].split('.wav')[0]\n",
    "#     output_file = targetdir +'/'+ output_file\n",
    "#     plt.savefig('%s.png' % output_file)\n",
    "#     plt.close()\n",
    "\n",
    "\n",
    "# def wav2img_waveform(wav_path, targetdir='', figsize=(4,4)):\n",
    "#     test_sound, samplerate = sf.read(sample_audio[0])\n",
    "#     fig = plt.figure(figsize=figsize)\n",
    "#     plt.plot(test_sound)\n",
    "#     plt.axis('off')\n",
    "#     output_file = wav_path.split('/')[-1].split('.wav')[0]\n",
    "#     output_file = targetdir +'/'+ output_file\n",
    "#     plt.savefig('%s.png' % output_file)\n",
    "#     plt.close()\n",
    "\n",
    "# ### Convert Training Audio\n",
    "# #### Loop through source audio and save as pictures \n",
    "# # (may take a while) may also consider running at commandline. \n",
    "# # Code is limited to 3 folders and 10 files each, get rid of array limits to process the entire directory\n",
    "\n",
    "# # c:\\Anaconda3\\lib\\site-packages\\matplotlib\\axes\\_axes.py:7221: RuntimeWarning: divide by zero encountered in log10\n",
    "# #   Z = 10. * np.log10(spec)\n",
    "\n",
    "# for i, x in enumerate(subFolderList[-3:]):\n",
    "#     print(i, ':', x)\n",
    "#     # get all the wave files\n",
    "#     all_files = [y for y in os.listdir(audio_path + x) if '.wav' in y]\n",
    "#     for j,file in enumerate(all_files):\n",
    "#         if j%100 == 0:\n",
    "#             print(f'Done for {j} out of {len(all_files)}.')\n",
    "#         try:\n",
    "#             wav2img(audio_path + x + '/' + file, pict_Path + x)                \n",
    "#         except Exception:\n",
    "#             print('Missed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio controls=\"controls\" >\n",
       "                    <source src=\"data:audio/wav;base64,UklGRtBqAABXQVZFZm10IBAAAAABAAEAgD4AAAB9AAACABAAZGF0YaxqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/f8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9//3/AAAAAAMA/f8AAAMAAAADAP3/AAADAP3/AAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP3/AAAAAAMAAwAAAAAAAAADAAAAAAADAAAAAAD9/wAABgAAAAMA/f/9/wYAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9/wMA+v8GAAMA6f8RAAYA7P8DAAAA/f8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/f8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA/f8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA/f8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9/wAABgD9//r/AwAAAPr//f8GAP3/9v8GAAMA+v8AAAMAAAD6/wMAAwD6//3/AwAAAAAAAAAAAP3/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAADAAAAAAADAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAMAAwAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAADAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAwADAAAAAwAAAAMAAwAAAAMAAAAAAAAAAAAAAAAAAwADAAMAAAADAAMAAAAAAAAAAAADAAAAAAAAAAAAAwAAAAAAAwADAAMAAwAAAAMAAwADAAAAAAAAAAAAAwADAAMAAAAAAAMAAwADAAMAAwAAAAAAAAADAAAAAAADAAAAAAADAAMAAwADAAMAAwADAAAAAwADAAMAAwAAAAAAAwADAAMAAwADAAMAAwADAAMAAwAAAAMAAwADAAAAAAADAAAAAwAAAAMAAwADAAMAAwADAAAAAAAAAAAAAAAAAAAAAAAAAAMAAwADAAAAAwADAAYAAwAAAAMAAwAAAAAAAAAAAAMAAAAAAAAAAwAAAAMAAAAAAAMAAwADAAAAAAAAAAMAAAAAAAAAAAAAAAMAAAADAAAAAAAAAAAAAwAAAAAAAAAAAAMAAAAAAAAAAAADAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAwAAAAMAAwADAAAAAAAAAAMAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAMAAwADAAAAAAAAAAAAAwADAAAAAAAAAAMABgADAAAAAAAAAAMAAAD9//3/AAAAAAAAAAAAAAAAAAAAAAAAAAD9//b/+v8NABEAAAD9//3/EQAeAAoA7//p//3/EQD9/8r/nv+e/7z/0f/H/6v/r//e/yIATgBfAGIAgQC/ANMAqgBzAGYAcABtAFEAMwARAAAAAwADAB4AQABEACUA3v/b/3oAuwCv/1b+NP40/7n/Ff98/g7/FwBmAE4AZgCxAB4BjwGLAfIARwDe/6j/1P9HABcAZ//9/m7/lgBfAQMBaQC/ACUByQANAHj/U/+C/zD/Ev4B/e38jf0g/lP+f/7b/t/+tv4w/ywAkgBEAP3/FAA5AA0A1P8DAFgAXABiAIEAZgAoAAoA8//v/9v/O/8m/un8RfxX/Ez85vvp+4P9HgCcAtYEXgZrB9UIYAo+C1ML2wrHCVoI2QZQBd0DzwJAAt0BkgEeAfUA4AEkA8EDtwNzAw0DSgI2Aez/a/6b/NL6TfnI92L2lfWO9cX1Q/bu9nb3JPg4+Xn6gPs0/MT8Z/1y/Rb85vp8+yr9Xf5F/vr9nv/kAkAEWwJ3AIEBMgQWBTkDXwFwAb4BtAAAAJYAOQCv/j7+Af8c/zH+I/0+/dH+HgB1/7L9x/yU/T7/w/+C/lD9vf3R/j7/H/9T/3j/Xf/A/3cAuABAANv/XABsAbQBAwEKAMr/zADrAQMCfgGqAa0CrQOfA6oCtAHdAKoAyQEoAygDXwEV/7b9Gf0W/Q/9pfwM/Bb7RvqY+qj8KAD4A/cGrAj+CekLXA5VEV8UbBY5FvET5BD5DY0LXQloBzUFegK1/4b9g/wB/Zr+HgD/ACwBtABAAA0AOQBEABX/ovyY+cj2vvR08+jy5PLe8o/yj/Kn85X1nPdX+cT6zvt5/C39D/7f/hL/Rf6i/F773/tr/bL+Ev9d/7EA1gEyAogC6gPjBYAGsAVNBMICLwHp/0//tv6X/SD8DPsI+/D7Pv0j/oL+vP7p/gH/zv5r/nz+kP7R/Wj8P/sF+5v7ZPwg/Qj+uf65/x4BTgJAA+4D+ANUA6MCMgIlAvEBYgEKATYBvgEhAnoCEAP/A+AENQUWBcEEbAQTBJwDRwOIApwAHP5//HL76vkd+GL2fvRm8hvxUvIv9wT/3wcRD0MUpRhrHEEggSPFJFgjbR9/GnoVIhHbDVoK7QUlAZ788fcD9DPyFPKB8gryfvDK7tTtGO5c77jw4fEs8ozxGPFg8fzyjvUX+CD65vvH/RcADQNlBloJqArfCSMItwaYBVQEDQOIAS3//vvx+Iv3DPjn+D/4dva09WX3+/nc+1396f5cAMkAlgDJAFUB3QENAmwBPQB1/wv/Dv9cAFECQAOOAoEBWwG+AYEB1P+y/fr7xPqV+ZH4jvho+Wv6OPuU/JT+bQANAm8DegTxBJgEpgPxAjUDwQNKAwMCfgH8AZUCTQMCBMUExAWKBqUGywZ2B2QHOAY8BeAEGgRpAksAeP44/UL8ivrF97v0APJZ7ybtNO1P8Mj1pfxeAyoJYw++FpMfzygtMBg0oDNqMG4sMijuIvobMhM0CQT/W/VW7ZHn+OOn4WPfPt2o21Pbe9zG3o/hX+Mh5Ofkc+aD6avtUvKO96L8pgHLBiYMFxJNGJ4ddCCkIMMeuRv3FygTwwzjBHL8rfRP7gLphOS14Hjev94N4Q3k8ebO6lXwEPeK/bsCJwdTC7EPsRMuFh0XCRe3FjwWIRWnEq4O4gmbBRAC8/3W+Dbzq+7E60nqKulo6LPoAeqs7Ozv0/NN+Bz90wGKBggLYw7yED0SrRLFEhASThC/DfcKUwgMBq0DiwGJ/9j95vyD/Hn8TPxk/Gf9O//FAOQAav/R/U/+RwHcBJsGZQZUBQYEWAJ4/5H7Q/dV88rviexh67XuRvf8AikPdRmqIXwqIjXUP0BGhUUFPq4ytyaKGhgNPv7K71Xjr9mg0sPNN8wzzkrT4tmk3zLkPOiv7OHxmfbL+Rn7ZPs0/En+5wHEBqgMmRKpF98avBwSHm4eqxzgFlYNfgFH9b3q6OEg2u7TJdDXz5XTqNq34yrtnPbK/zEIdA+fFIcXmxifGDUYgBfWFkMWDBbxFR4V3RLlDqwJnwO9/An1f+zn44bcitem1anW6dkb39Lm/fAj/KIGMw9eFYYZ5hsmHK8ZPBUDEIILfAgnBlsEDQOSAkMDSgS+BFgDVQDc/Fv5Jfb58ibw0e4K8I/z9Phd/0YGag3ME9wYKhxqHd8cihqfFmkR0QqVBOX/Ev0d/Eb7+/hm9FbuTehY4wDgKd142mHZwNzq5mn3GQsSHpoucj3SS0RY8F+9X3tWxUbhMzogTAwk+H3ketNrxy/Bxb8UwWXElMlf0CfYRN/T5Kzo5uu175z0HfuBAmcKjxIgG/wjCCwRMuszvDCfKOIcWQ85AGPwTuBw0ZTGQMGqwfvGnc8W2rflyfGX/dIH3g5EEt0SNhJcEYUQTg83DpoO1xBRFIcX9xisGGgWlhHRCVP/9fNC6TDgONnS1F/TXtWG29Pk7O8x+q0BJAdFC0gOHw+yDBIItAOZASUCBgSUBgEK1A5sFLAYbhrEGOcT9gyRBGH7B/KD6T3k6+PL5x/uBvUS/EADawpOEMUSZhF7DXUJgwftB+0IygkBCxUOsRPVGP4a8BhzE/0MYQbp/5H5hfME7iTov+C219DOcsm5yX7OStX93CDoAftlFr80AU7ZXatlxWl6aylnnFj6QP8lNw1X+T/ogNe5yD2/dLxAvszAfcHdwNPBwcarznnX1+Cs6/f5fwsmHl0vCD2IRXNHtUI5OEMpTRf7A83vzdydzUrEvsFoxHjKktLO22LlH+749BP6Kv6PAVsEugY/CXgNGhTLGtcegh8fHv0bWhjQEL4EYvfA7JHnz+Y46EnrLfD19rL+hAWRCMsGmQGb+qfzje0C6HPkIeUW68n0wP4TBzMO+xSeGkEdCxvdFPkNawgFBXYDkgP0BKwGfAh5CWsILgTw/Nrz8Oq745reAN3l36zntPNwAbIN4BYZHYIgACGyHdwWSw4kB7ADsAOHBYAH7QmXDHQORA6GC3kGAf/M9TvspuQ94eHiqegb8Pz1afdq8v7n1Nss0vbNj8+92IPrfAdKKIhHD2Fuc31+/39xdF5bpjgDE67x49jAyPK+Lbnbt1K8K8WrzvvTqtPa0BvPydA41tffdO9sBQcfMjdzSbJTEVWeTaU9KCYqCkXtetNiwGi27bUivULJXtdz5EHuevRi9773lfZi9Qb2mPnQAHwLIBjJJA4v0DOMME4khRBo+lrp8uEU4cPfHNrd1Fbaf+3xBcEWIxooFe8PEQ33CHMAz/Wo7WTqveqs68Psze8J9qj9tAJAApv9D/vD/sEHrhCcFFsUHhQ1FrAXwRTsDCsCyPfi7lHm797f2onbguA851LuW/ao//AJPROUGPQYhBVtEVkP8g6MDj4NqAuJC6EMNw2NCy4HEAKN/ZH5FPUf8CDsWuvK7Sny2fYC+tL7x/wt/UL9OP07/fP83/v/99TuiOHI1IzNAM4/1t3leP2lHMA+V1xebulywWyYXy5NNjXqF5X5/OC70lXOtc4zz6DO1M1VzaHLXcfdwk3CWsnw1wHsNQOGG2MzYkekU+9UnEovNgsbuf7W5MbPKMKFvGm+zsWuzyPaSuM16jvu/e5Z7gfvA/SX/rkMyhtJKYwyEDbhMhYoYRizCIP6P+v01uDAxLSJvD/Wu/MPCHARxBeuID8opiZ8GTEHhPdW7jjqBegP6G7sQPXs/fb//vlS8W7tfvHx+K/9yv/4BIsRwiGbLNwraiG0En0D2vSY5rnb2ddZ3PvmIvPK/ScG1AySEdYSpw7xBL36FPV99cH6uACpBaEKFBATFKATvA66Bhn+8fdf9GbzTfZk/FcEEgu1DDEICgBo+bv23fU99LHx1/EX+CsDLQ7ME6cStQzgBYEBIgAZ/yf5lOrP1fTDCr/iyTrdgu/b/RgN/CMcQuBcAGmrYyNTT0EmMkEiDg7B9+Dm798f3+zbftEhxOW687k5vyfF5clj0MbdX/MVDuMnfTptQ1VDFjzNL2AgDg+o/FrrY90y1O/Prs+70ZzVa9uB4f/lSejj6YzuZfmGCNIWKSBmJN0lmSW1IRYYngla+unuE+hm4l3aDdKMzzXYWuvkAEcRIxvJIRYpQTBPMYoo8Bj3B0n5Ku525Zbfnd7o4eDmAesO7lXy5vllAyMLIg+PEA0SGhZCG2cdgxqcE70KJQGH93juZejI52TscPPH+qMBOAjvDT0Qsg3EBlr+lffT85LzBvaY+v8ACAjKDfUQ2hFOEXcPZwwICTwGJAa9CPAKlArIBu4Ag/xa+/r7YfxQ+xP5t/iR/JgDLQpCC58EJ/ry8d7vp/R4/cQFEgqRB1f82OoW2bnMdcjAyy7VkeYQA1soKk8Xbad5THRCYrRIiipgC1LvQtu00gLTaNWO1V/T4dDrzxvPdcvExa3DTMvs3gH7RhgOMT5C6klbRzg7nCdYEOr4kuNi0hLHRsOsx07R/dtU5FToFumU6AXpOOyZ85f/6A3YG+cl2SlUKNAhLhZNBh70QOQL3TPefuGq4LLam9f534HzlwmAGeggYiRQKVMtQipjHikN9/sE7ljikdfa0CHSD9vS553yefh1/MwCvAu0E2wWhBMDDwANQQ36C1AHaQD0+m/4MvZq8n/uNO4R8y76T/82AecBhANUBqUHaAV3AOb6u/aS9G30hPaG+7cDUgwhExoXnxe+FkoVNhIjDGUDDPtz9bHzwvMU8wfye/ED8wn2Yvg1+dL4t/gM+m7+bAQZCgcPtBFAE7cTZhBaCGT+9fXw7fjiLNKgvzG3Br/r0hLql/7PEq8sIUt4Y0dsImXsUzRBxi9JHEMGCvIr5Fndudnu0ifIqr6hupa8L8LRyCHSv+GH94IPmSS/M5E7szyqNhopXhdXBY710uiy3sTWi9K+0krV3NjU3KrgZeVC683xGvo8BUASkB5lJ5gpTiUOHcISLgft+WTsd+Em3XvfMuOi5rbqf+8Q9Vv4CfnR/UwMACJHNkhAJz1xMp8lhxUiAHboK9T+yFDIUs4M2B7lwvPkAPMJqwzsCnkJDwriDHQRCRWpFVsU0BDpCW0AqvWQ7M7or+va8QL5hQDEB6sOGxKWDyMItv7x9SbwO+7b7xf1NPyfAjwGTAivCvYNehFmEmYQ2wwgCjgKIwzvDJcKUAWJ/8v6h/c59czzR/T89aL4tvvl/2wFHAtnDqgLsAQI/lP8JQAyBPQEZQIRALb+n/my7G7Z/cn0x0fTR+S082UDBBuePKxdBW/hafZT4DnnI3ARPv/N7QDie950337f7Nq305PON832zafOOdHw2enrIQWMHtAxgDuDO7UzwiU8FAYCVfG75KHb2dVi1MjWQdyx4ablP+jV6sbu3fOz+swDuA8jHKAk2SXsHysWqAt3AVH23+lx31PacdsR4nzqsfMn/Pr/O/0e9VnwW/ddC4sj4TPuN8kxWyivHPAK6PLY2fDI9MMmyUrUo+IN9I4F0BG3FLgOtwaEA0kGggu4Dm0P7w61DtcNgwk2AZn2w+1Q6cfpw+4r9p7+aAYOCwQLQgcNAlr9Sfo5+CH24fSZ9sD7UQNgCiwP+RF6Ej0R8g5FDEIKEglrBmkBs/uY9wz3qfm2+876h/ga95z4BP1KAoAGpQmrC1IMTwz6CmgI5wQyAX/9pvmj9cPwk+4z89/9NQfFBL/yONp7y8LPXOKO9dYAOwlJGQA0809aXmZYVUXKMN4fERDO/X/r2uCF4WXnU+lO4xLZR9Pc1bLcIuLg5JvoFPIlAk0UoyIFKsQpRyKVFUYGPPdQ66DjB9/s3JDdteBK5q/shfLj93/8TP+J/9T+ZgDEBvYPHRZYFToO0gSK/Ij1Z+5U50fi6+Du4w/qJvFv+YsCuQn2DeEOMAwjCEMElQEhA5cJThFiFgwWyQ8CB6X+cPX+6i/i293538Tn9vHj+7oErwvyD/wQww4jC6gIqQeOBucEdgJn/0L89PgQ9aDx5e9+8AP0Gvla/rADqAhIDMYN/QtCB7cBMf1U+hP5K/k1+mH9zwI7CDAMgg1ZC28HgQPv/579tvwt/XX/BgPtBiYKLQzUC6IIrQNC/hP6c/ga+WX6ivu2+9n6V/pX+Z/3Iff4+I3+IAYtCukIzwVhBfoIwwpfAbbr+NRFyh7QMOAR79X5CAhqHjI4wUo8TdtC/zahLlslUBamAh/yvezv77zxZOyq4dzXBtS01LDV2dbf27DmSvbfBlQU+h3aI4EkHx8QFHIFmPc07YvmX+Nb44flyOjm6zDuOvB+8kD1tPf3+VD90wJWCuEQ8RMGE9AOfAg2AbP46O/f6SToNere7TrxevRD+Uz/UQRQBxkIgwnlDCIOrAnR/2n25PTO/M4HSw6aDpMLdQheBk4C3/ol9PzxQPQ5+Mv7zf+ABoUOxRJVD58FHfvP9Ovz2vUo+HL7IgAJBJ8F/wMUAen/SwD1AOQADQFAA4MHJgv9CtwGJQFk/Hb5W/jB+I37KAEuB2ALUgzRCVAG1gM5Ar8AwP96AMUEzQv5EdoTsRAcC8gEI/6S9lnun+jc6AvvAvhI//wCmwXECC0MvAyGCCUCEv5B/8UD1QezB58EuwJpAm0Ao/fL57PW28ygzifYUeOo7bP78hIiMb5LHlh7VBdIYTtjMDojqhDc/DTv2Omp6FvkMdqnzwHLq81l02jXw9qF4gryhwaGGf8lvSrfKa0l2x0vEp8DL/WD6lHkd+ER4EHf2t8K4+3oZ+8i9LT21vg0/dIESA0yEzwV8RPoEKsMJAb6/LXygOoC52znCOm26p7t4fPR/IoFhgofCxwL7ww2EKoRZw7OBt/9RveZ9CH27fqEAc4HdQuCC8QIogX8AjkA8Puw9hTz+fIT9xL9MgI/BdkFLgThAK/8vfkr+sf9egLVBRMH+waUBsEFjgO5/2j7mPgo+OD51fwAAEMD6gVvBkoEwgC5/TH9NP9lAjkFzgZdCEkKYwzvDU8NjQqzBpkCO/9h/ff8NP3R/dz8dvnr9fXy9fIy99/8KAJeBxgNChKwFdYVFBG2CTYB2fhV8tvvoPFN93z+EwMCBQ8G4wb+BUcA8vL54ZHVStKi2KPkM/EZ/xcSgCjmPFhI1kaAPG4w5yWlGzoPkgDW8/rtDu5u7ubq3eJM2lfWwdeQ28PfaeV77mj8xgwFGiwh3iH6HbAXVQ+VBDL4I+1U5Sji9eLM5Jjm++ji7BTyafft+nX8fP6tAu0IpA9sE+QSChASDCQH5wCR+FLvuuif5n3obuyr8Db1O/vxAo0JYw3lDdELJgpJCqEL+gviCUMEzvtt89jtXe1V8tL6iwOQChEP/BAvEQ4PEgppAuP5sfJj7irusfFX+AMAcgaUCcQIXgWBAWD/MP+8/1EAzAEkBNkG9AfjBesBKv3L+bf4EPmi+ob9ZgGOBTsI1QdXBR4Cw/+X/un9D/5T/ysCawbYCRkL6QrwCekJEgprCGwF/wDL/HL5MvaS82Py7vNU+F39zADTAh0FUAn9DtoSXBJjDY4Fof5G+4P7tv1k/tL7rfag8rHzg/lEAIgBm/me69fe/tia25njf+wa9qMCxRTcKqg+hEpbS4VDHjcaKC4XhwT58gzn+OLC5Ofmo+WB4XHeuN/C5P7pPuzK7JPv6vfjBOERnhqJHU8cKxh7ENwEmfZ56T3hXN7G3pngvuPO6afzcf7BBkkKNAnOBn0FDAbOBpQGmAWiBDUEKAMbAHL67vPl7r3syuxF7T7u4fC+9gAAxAlREdYUHhTyEVIPLQ36Cm8FkfyZ8Z/omOYZ7OD2ZQJ/C+gQYhOjE7EQsgpzAmX6cPPH7Zvqiuow74r4YgM3DN4PEQ7+CXYGnwSBA8UBvP/f/Yb8/vul+2/7YfsI+/f6O/v6+27+5AGfBXII0QjmBwIGtANzAgYCRwJOAmkBXABmAEMCgAWeCHUJawjEBgIF+wNlA+cBif98/DL5yPYe9v/36fvrAP8EMQeeB1QGjgRDAxMDLwMGAw0CPQDp/sf9D/2s/G78Fv2a/vr/qP66+VXxs+fJ4Q3iE+jN8O34bv9UBksRACFmMkw/rkJ1PBUw9SFfFKwHxPpg7p/kq95M3JfblNst3RTiNerT8jz4Zfm++HL6cACDCfwRFxaVFTYSbg3cB6YB6vlx8dLpxeMY4N7fROM76jP0x/6NB8AMiQ57DYYLrwkMB3oD5f55+rr3Nfdl+En6ZPtQ+yf6+/ex9S/0fvQy9+b7iwFvBngK0A2MD9oP+Q00ChoGhAE7+yLz1eqE5T/nIvDm/JcJPROzGJ4azhkGFUgMLwFU9SPrOeUy5CDoFPEL/d8I6BHxFZ8UBxC9CUoDof05+OvzpPEK8lT1cvqe/8wCzAP4AtAAjf7R/D/8m/0lAX0FdQnpCwsMDgscCQUG1gF//HP3OfTu8772a/vCANwFVgpPDR8Oqwz0CIcDO/1p97jyMPB38f/1m/z/A5cKkw+0EoETNhHRCwwEqPzd91j2jvem+TH7a/zi/pUBbAMlAhb8NvKp53fgvN0f4F7mFe+p+fgENhHsHdUp6zM4OsQ6bTVdKwAeuA9iAp/2je1v593j1+Gq4LHgheKY5jHsXPFz9JX1gfaA+ez+sAVWDD0RphOOE3oRQQ1QB7EAcvlV8pDrz+WB4rTiHedu7rT2Rf5sBO0IpAsEDZAMZwouB60DPQAx/er6OPnP+Hb5ovpo+wj78fnL+L74P/rL/Dv/fgG+A2gGeQkYDGcNUgzKCpQJ7QZKAbf30exl5Wnlvetf9av/xAcUD+AVpRqXG6kXqw/tBLb6wvFk6zHpwOs285f8EAVdCmoMYwwSC+kHWwKe++v0EfAq7vbvvvQI+/UBawehClYL8Al8B2gE0wDA/Gz54/f7+MD8PQL+BwEMkA36Cx0IwQPl//D8P/rn9332//am+Rn+UQPSBiMICAfIA4UAD/7+/CD9Xf3m/HX8Qv1VAH0FlAp4DYYMSQifAo39IPoX+ED3u/ZA9vj14PXu9sv4DPtF/D/7Nfi+9Hrz+PSV+aH/XgV8CjAOrhEXFT8YEhvbHKscthmLFOwM6gTw/f/3fvM6787q+Obx5BDlgOeU6wrwyfT0+Ib83v+3AicFTQeRCFMI3AaEBPgBqP87/Rn7+Pi09sz06PJZ8YXwG/EK89P1wfha+/395f+mAQIDYgNUA7cC6wHFAH//rP0u/N/7qftF/Mv8qPyi/Dv9Qv6C/1EBRwKjAs8BLwARAAMCbwWYBgIDs/v49NPyPfVN+4sBCQZnCagMNhAGEqcR9g5JCuMD9Pun8zTszugF6ozvtPaU/PwADAQPCLkLkw3iDC4JzwPO/Sv59fWj9JL15/c4+1P+AwHWAlEEawZQCNgIrwcnBfUBq/+v/hL/EQC0ACwBPQG3AbACaQMrA6MBMP9k/If6D/p5+t/77P0zALQCogQuBjUHfAdoByQGwQOSAOb8wfka+Br4TfkF+6j8vP6mAdwEgweeCCcIdgacAwYAovzP+YD35/V+9OTyhfGd8dPzh/ei+3X/4ALqBSMJXQwDD2kRyBP/FSEXyxYyFUcS6A4qC9kG5wFM/Hr2QfGo7VDr9+m66Yrqoeyy79PzHfg4/BcAhwPtBhwJ5gk4CW8HQwWcAmIAHP6U+xb52fZw9YT0p/Tg9S/3aPg8+QX6BfsM/Gv90f4DACwBQAJ6A9IEfQXIBeAFmAWpBLQC/f+l/NL5ZfiY9/v2Avdl+Lr6Qv2h/yUBNQNrBqwJkAs1COEADPo89+f4BP05AqYEbAVCByYKZwxWDIMKXgbuAFD78fXs8M3tl+6B8p/4HP4oAYEC3ARuCPMKwAsgCZ8Dm/1v+v75VPmV+Zj64/vO/YgATQMJBdUGUwgZCP4FfQK8/gj8U/tF/Ln9Rf+LAMwBowM5BZUFkQTPAv8AI//i/X/9zv0w/5UBdgRhBpQGsAVGBK0CFAF4/2796vpe+Rb6f/xx/+ABGgTtBeYG5gd5B0MEQf+K+l73rfXg9Uf2rfXu9Gn0//TB9oD5O/1sAWEFQgjtCXULbg0lEMwTohbjF8EWExQ6Ee8NzgpXB5gDPv8n+iz1e/Cy7MTqCOv666HsEu3R7ezv6/Nh+dT+7gKYBcsHTAn+CfAJlAg/Bn0DgQDz/DL5yPVt88byVfM59C/1F/YX96b4cvpu/CP+TP+BAIQBMgLWAqYDSgS6BCcFpgR9A+QBhQC5/8f+4v0t/bP80vtG+3n7a/zs/av/NgGFADH+xPzH/e//9QJlBi4I9AgxCUwKlwpdCYcHKwRiANz7n/cU9Mnx8vEl9P/3aPvD/SwAowMFB5sJ8wqGCQ8G9QE7/4b95vuf+sj5ivnx+dj7/f2N//gAlQKYBMsF5gUCBf8DRwNHA9IDyAO7AtoAAwCT/0X/Ev9a/iP+Lf7f/vr/uAANAa0BrQKmAy4EtAPnApwBXwARAIUApwDv/4n/wP+WAJIBiwLWAtYBPQHkAHcAYP9y/dz76vrf+gH7ovpN+fv37vcu+QH7NPw+/WT+NgCfAmgF2AeXCagLoA4sEn0UbxW3FMwSzBCrDh8MwQdKAqX8mPe08ybwQu266pvpXepW7MDuuPAD8w32Avoq/r4BHQRlBS4G8AZ2BycHQwZDBDkCMwCh/WH7J/lv9332IfbT9YT1lfXI9ST34/iA+kL8fP3H/uL/DQFUAp8DnARUBS4GcgZNBnYFXgRUA+ABgQA0/5f9J/xa+5H6xPmm+Sr7iv2y/2wBegL1AjkCBgI1AxMEjgRQBWUGUAbLBQUGkQb0BdwEWwSEApf/1fyU+x37zvr0+or72PvO+0L9av/FAPwABgG/AJr/nv5r/nz+CP5P/s3//ACIAZwChAQ1BvAGMQesBrMEiwJiAaAAx/9k/gv9efwx/PP8D/7z/pD/XACjAbQCpgMrBIsErQTxBPsE+AP/Aen/pf4m/lP+T/7w/TH+if/8AbAELgYxBmUFNQSIAm0AZ/3m+UD3ffVc9Ljz/PJq8mbzKPZN+pD+NgLSBD8Hgwq5DQARYhMoFYQW9BaKFpIUoBEiDsMKOAcaAyP+Gvhc8tvtIOvm6V7pD+l56cTq1Oxc8FX0lfi5/F8AqQMPBicIcglWCsMKcgogCX0GdgNHAFb9y/rq+C/3L/V+8zDyv/Hy8eTyUfSB9Qb33PgW+1r9Wf9mAUADbwSYBdwGmAftB4oH4wZbBXMDDQLhAAAAvP7Y/an7mPgo9173nPim+aX7tv39/kcBRgVJCT4LggxqDSMMTAkMB58EvwBT/VP7K/ke9oT0DfVf9qL4Kvx7/90AyQGBA74EswRUBMED4AHY/7L+7P04/f78UP0B/uX+DQBwAY4CowN6BOoE0gSpBNYEugSHBPEDLwOwAtYBYgEXAZkAFABI/3/+sv2o/T7+4v5Z/27/f/+5/0QAowFzA58EMgVXBQIFhwSpBFQFMgXPBFQEHgOtAdYAyQCIAK//qP4g/RP7uvmY+Yf5DPm++Hn4hPjm+UX83/5OAR0E+wYFCWQLGA5SEAMSoxOwFPwTehJfEHENZwpCB6YDYP/7+ur2gfPe8EHvvO437k/uWe/X8CzzPPaD+Xn8/f4GAbsC4AP7BLoFugWiBRMFVAQaA+4B4QCQ/3X+O/0S/Hn6+Pj09wL3rfb79tb3hPgh+QX6J/vw/Lz+PQCEAXACegPSBEMGkQbIBWwFHQVABFQDmQIlAfD+fP5g/2D+gPuw+SH57fgn+4n/yQEGAeAB4ARoBnwHIwmUCPEEwgLTAuEAw/1//DT8vfqK+mj8wPw0/Kz9tABwAgkDdgOOAkQBLAE9AiUCuACQ/7n+lP5T/8kAXwEXAQMBXwElAmUCgQJKAs8BFAKZAuQCtwJpAgMCowF6AVsBDQEbAJP/vP8DAFgAcABiAMD/Z/+r/ywA3QBEAcIB5AHTAVsCzwLTAn0CRwJYAjYCJQINAqMB5wBpAHAA1P+U/q/9bv2o/Zf+wP/p/6v+Xf0+/Xz9uf1g/qX+Lf7z/cr+uf8iANMAbAEDAvECWwTEBZQGUwdkCDsJfAl8CeYIxweiBmUFtANRAY3+r/sy+VH3E/YN9Sj0sfPQ8+v0kvZR+BP6s/tW/ez+hQD/AdMCXgPgAxAE4ANsA7ACqgH1AMUAFAAV/sf7fPod+qz6Hfxy/WH9C/0I/n//0AAvAiEDfQIDAX4AMwBT/9j+Dv9//g/9pfzm/AT9Mf56AKYB3QCIANoA/AD8AR0ERgVGBM8DogTLBOME0gVUBd0CRAGjAE//1f1r/fD8rPuA+3L8r/zi/Hj+PQAhAQYCHgNeAygD3QNlBLcDyAIUAj0BdwCFAHAAhv/K/o3+U/4B/jv+kP5M/kz+HP8AAIUARwEXAl8CmQIJA00D9QJzAj0CvgE5ARQBoACk/8P+eP58/o3+/f5k/1b/NP+Q/xsAVQCZANYA4QADAWYB5wHnAa0BtwHPAaABOQHdACgAVv9Z/83/nv8E//3+Ff+r/gj/DQAsAAMA0ABYAY8AOQDCAIUADQDnAHcB1gDyAOQB6wGLASEC/wFiAH//U/9a/j79Lf29/Hz7ZPtF/Hz8m/yh/XX+lP5I/0QARAANAIEAqgA5AAYAHgDv/7L/zf/D/0j/CP8L/+z+yv79/g7/2P7H/gH/I/9B//P/TgA2AIEA6wA5AWwBwgHWAXoBVQFbAQMBowCqAFUAr/+T/6T/Z/9g/3H/Dv+r/uz+hv/D//r/HgDe/7L/7//v/5r/hv97/zf/Jv9d/1b/NP9q/6H/pP+5/+//vP+X/9H/1P+v/6//mv80/wj/NP9F/zT/Kv8q/xL/Wf+8/9T/2//N/9H/7P89AHMAbQB+AGIAOQAXADYAWAAsAOz/df8+/27/tf/i/83/hv9F/43/NgCnAKcAkgBOADYAvwAoAfIAuADJAHAAPQCqAKMADQDH/+//x//Y/ywAwP9n/9T/ZgBiACwAHgDH/8f/YgDTALsAcwBAACgAfgANAVgBAwFAANT/2/8DAMr/f/80/7b+l/7l/jf/I//9/hn/NP+y/3AAzACqAFEASwCZAMwAsQB+AE4A7/9//27/r/+8/5P/Z/9W/3j/vP/z/wMA/f/9/woA/f/s/+X/AAD9/43/ZP91/3j/Z/+C/9H/q/94/4L/hv91/5P/zf+1/97/RwBYABcARACnAJIAqgDrAPwA5wD/APIAaQBYAIgARADl/+n/wP8q/xn/Z/94/5r/2P/R/57/uf/b/+L/IgAoAOL/yv/A/7X/HgC4ANYAcABfALEAvwDFAMwAmQAAAJr/wP/e/97/qP+8/wAALwCFAJYAdwBHAGIAiwB+ACwAtf+k/3j/hv/Y/+X/7//v/yIARABAAF8ARwANAPr/LAAAAH//mv/i/9j/zf8UAG0AOQAiAHcAcwBtAHcAOQAAAOn/AADv/6T/pP/D/wAALwA9AFUAkgDQAMIAxQCxADYAe/9B/7z/4v+1/57/q/+5/9H/cwDdAJwAcABYAP3/r/8iAIUA/f+8/+L/3v/Y/xEARwA5AEcATgANANH/w/8UAEsA8//H/xsAZgBRADkAmQDaADYA0f8XAOn/yv8DAPr/w/+T/7X/4v/Y/xcAKAAAAAMAFABwAKcAcAAlAPb/FwAbAN7/5f/i/7L/zf/p/+X/+v8eAPr/w//p/ygASwBiAIsAbQAlABcALAAiAAoAaQBwAN7/w/8NACgA3v/U/wYAof97/+n/RwBAADkAlgCLADYAGwANABEAEQAeAC8AFAANADkAOQAsADYA4v+h/7L/2P8bADYAYgCLAF8ALABEAHoAWABLAG0AUQA2AEcAXwBVADMA7/+y/7n/7P8iACwAKAAiABQALABiAHMAXABOACwAKACLAIgALAA5AFEAvP9q/wAAAwCG/8f/YgBEAMr/BgBtAEcADQBHAE4ADQBYAJYAgQBmAFEATgBEADkAFwAAAPr/5f8iAHMAUQANAP3/8/8GAEAAXwB6AIgAaQBYAFUAQAAbAAoADQAKABQAFwAAAAAADQAKABsARwAzAPb/9v89AFwARAB3AGIAAwAiAE4A7P+e/8r/6f/U/wMASwAzAAAA7P/2/yIAKAANABQAMwBEAFEAOQAUAAYACgANAA0A/f/2//r/AwAiACgAGwAGAB4AcwBwADYAGwAeABsAMwBzAFwA7//i/xsA/f/6/0cALwD9/0AAegAzAOz/9v/z//r/IgAbAOn/2P/R/8f/5f8NAAYA+v8GAAoAHgBEAEQAIgAbACUACgDp/+//1P+o/6//1P/i/83/yv/b/+z/DQA5AEcAMwAsAFEAYgBiAHcAXAAUAP3/JQA9APr/vP/K/83/w//R/+L/4v/l/xcAVQBtAGkAYgBmAFwARAAvABQA+v/2/w0ABgDe/9j/9v8DAPb/2//l/wMAFwAzACwACgAKABcAJQAUAPr/+v/s/+//FwAiAP3/zf/R/wMAEQAGAP3/7P/6/xEAHgA2ACgAHgAiABsAHgARAA0ACgD2//b/+v/z/+z/6f8DAAMA8/8DABsAHgANAA0AKAAvADYAQAAlAAoAFAAlAB4A7//K/8r/0f/i/+n/4v/l//r/DQAUABcADQAGAB4AJQAoACUAAwD9/wAAAADb/6j/wP/b//P/AwAGABEAFwA9AEsAKAAXAAYA/f8AAPb/9v/p/83/0f/e/+n/3v/U//r/FAAiAC8AGwARAB4AKAAiAAYAAAAGAP3//f8DAP3/7//p/+//+v/v/+X/8/8GAA0AAADz//3/AAAKABcACgADAAYADQAKAA0AGwAKAPb//f8KABQAFAD2/+z/AAAGAAMA/f8AAP3/7//2//b/7//9/wAABgAXABsAEQAKABcALwAzABsABgAKAAoAAAAAAAMABgADAAAA+v/z/wMABgDv/+//AAD9//b/AAAGAAoAFAANAAYAHgAoABEADQAXABQAAAADAA0AEQAbABQABgD9//3/AwAAAAAA/f/9//r/8/8AAAMA/f8AAAoADQAKABsAGwAKABcAKAAeAB4AFAAGAAYACgAGAP3/AAD6//b//f8AAP3/8//v//b//f8DAAoADQAGAAoAEQANABEAGwAoACUAEQANAAoABgADAAAAAAADAAMAAAAAAAMACgADAAAAAAAGAAYAAAAAAAYABgD9/w0AHgAiACIAFAAUAB4AGwARAA0AFAARAA0ABgD9/wAAAAAAAAAAAAAAAAAAAAAAAAMABgADAAAACgAUAA0ABgANABEAEQANAAYAAwADAAYAAwADAAMABgAKABEAFAANAA0ACgADAAMAAAAAAAAAAAD9/wMACgADAAMABgAAAAoACgADAAYACgAKAAMAAAAAAAAAAwAAAAAAAAAAAAMAAwAGAAYAAwADAAMAAwAAAAAAAAADAAYACgAKAAYABgAGAAYAAwAAAAMAAwADAAMAAwADAAoABgAGAAoAAwAGAAMABgAKAAoACgANAAoABgAAAAAAAAAAAAMABgADAAAAAwAGAAoADQAGAAMAAwADAAMAAwADAAAAAwADAAAAAwAAAAAAAAAAAAMAAwADAAYADQANAA0ABgADAAMAAAAAAAAA/f/9/wAAAAAAAAAAAAAAAAAABgAKAAAAAwAGAAYABgAAAAAAAAADAAMAAAAAAAAAAAAGAAYABgAGAAYABgADAAAAAAAAAAAAAAAAAAAA/f/6//3//f/9/w==\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_audio_path = audio_path\n",
    "filename = 'wow/4a0e2c16_nohash_0.wav'\n",
    "sample_rate, samples = wavfile.read(str(train_audio_path) + filename)\n",
    "ipd.Audio(samples, rate=sample_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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>img</th>\n",
       "      <th>label-str</th>\n",
       "      <th>fullpath</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>00176480_nohash_0.png</td>\n",
       "      <td>down</td>\n",
       "      <td>G:/tensorflow-speech-recognition-challenge/tra...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>004ae714_nohash_0.png</td>\n",
       "      <td>down</td>\n",
       "      <td>G:/tensorflow-speech-recognition-challenge/tra...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>00b01445_nohash_0.png</td>\n",
       "      <td>down</td>\n",
       "      <td>G:/tensorflow-speech-recognition-challenge/tra...</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     img label-str  \\\n",
       "0  00176480_nohash_0.png      down   \n",
       "1  004ae714_nohash_0.png      down   \n",
       "2  00b01445_nohash_0.png      down   \n",
       "\n",
       "                                            fullpath  label  \n",
       "0  G:/tensorflow-speech-recognition-challenge/tra...      0  \n",
       "1  G:/tensorflow-speech-recognition-challenge/tra...      0  \n",
       "2  G:/tensorflow-speech-recognition-challenge/tra...      0  "
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# from sklearn.preprocessing import MultiLabelBinarizer, LabelBinarizer\n",
    "# from sklearn.preprocessing import LabelEncoder\n",
    "# from sklearn.pipeline import Pipeline\n",
    "# from collections import defaultdict\n",
    "# d = defaultdict(LabelEncoder)\n",
    "\n",
    "# # Build the pictures path\n",
    "# subFolderList = []\n",
    "# for x in os.listdir(pict_Path):\n",
    "#     if os.path.isdir(pict_Path + '/' + x):\n",
    "#         subFolderList.append(x)        \n",
    "            \n",
    "# good_labels=['yes', 'no', 'up', 'down', 'left', 'right', 'on', 'off', 'stop', 'go']\n",
    "# POSSIBLE_LABELS = 'yes no up down left right on off stop go silence unknown'.split()\n",
    "\n",
    "# # print (type(POSSIBLE_LABELS))\n",
    "# # print (type(good_labels))\n",
    "# columns = ['img', 'label-str','fullpath']\n",
    "# df_pred=pd.DataFrame(data=np.zeros((0,len(columns))), columns=columns)\n",
    "# # df_pred.id.astype(int)\n",
    "\n",
    "# for i, x in enumerate(subFolderList):\n",
    "#     if (x in POSSIBLE_LABELS):\n",
    "#     #     print(i, ':', x)\n",
    "#         # get all the wave files\n",
    "#         all_files = [y for y in os.listdir(pict_Path + x) if '.png' in y]\n",
    "#         for file in all_files:\n",
    "#     #         print (audio_path + x + '/' + file, pict_Path + x)\n",
    "#             fullPath=pict_Path + x + '/' + file\n",
    "#     #         print (fullPath)\n",
    "#             df_pred = df_pred.append({'img':file, 'label-str':x,'fullpath':fullPath},ignore_index=True)\n",
    "#     #         print (pict_Path + x)    \n",
    "    \n",
    "\n",
    "# # Encode the categorical labels as numeric data\n",
    "# df_pred['label'] = LabelEncoder().fit_transform(df_pred['label-str'])\n",
    "# # Make sure we dont save the header\n",
    "# df_pred.to_csv(IMG_DATA_LABELS, columns=('img','label-str','fullpath', 'label'), index=None, header=False)\n",
    "# df_pred.to_csv(IMG_DATA_LABELS +'_header', columns=('img','label-str','fullpath', 'label'), index=None, header=True)\n",
    "    \n",
    "# df_pred.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from sklearn.preprocessing import MultiLabelBinarizer, LabelBinarizer\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from collections import defaultdict\n",
    "d = defaultdict(LabelEncoder)\n",
    "\n",
    "def encode_onehot(df, cols):  \n",
    "    vec = DictVectorizer()    \n",
    "    vec_data = pd.DataFrame(vec.fit_transform(df[cols].to_dict(outtype='records')).toarray())\n",
    "    vec_data.columns = vec.get_feature_names()\n",
    "    vec_data.index = df.index\n",
    "    \n",
    "    df = df.drop(cols, axis=1)\n",
    "    df = df.join(vec_data)\n",
    "    return df\n",
    "\n",
    "try:\n",
    "    from PIL import Image\n",
    "except ImportError:\n",
    "    import Image\n",
    "    \n",
    "class GenericImageDataset(Dataset):    \n",
    "\n",
    "    def __init__(self, csv_path, img_path, img_ext, transform=None):\n",
    "        \n",
    "        t = time.time()        \n",
    "        lgr.info('CSV path {}'.format(csv_path))\n",
    "        lgr.info('IMG path {}'.format(img_path))        \n",
    "        \n",
    "        assert img_ext in ['.png']\n",
    "        \n",
    "        tmp_df = pd.read_csv(csv_path, header=None) # img,label,fullpath\n",
    "                        \n",
    "        self.mlb = MultiLabelBinarizer()\n",
    "        self.img_path = img_path\n",
    "        self.img_ext = img_ext\n",
    "        self.transform = transform\n",
    "\n",
    "        # Encoding the variables                \n",
    "        lgr.info(\"DF CSV:\\n\" + str (tmp_df.head(3)))\n",
    "                        \n",
    "        self.X_train = tmp_df[2]        \n",
    "        \n",
    "        self.y_train = self.mlb.fit_transform(tmp_df[1].str.split()).astype(np.float32)           \n",
    "        self.y_train=self.y_train.reshape((self.y_train.shape[0]*10,1)) # Must be reshaped for PyTorch!                \n",
    "        \n",
    "#         y_df = encode_onehot(tmp_df, cols=[tmp_df[1]])\n",
    "#         self.y_train = y_df \n",
    "        \n",
    "        lgr.info('y_train {}'.format(self.y_train))\n",
    "                \n",
    "#         self.y_train = tmp_df[3].astype(np.float32)                          \n",
    "#         self.y_train = self.mlb.fit_transform(tmp_df[1].str.split()).astype(np.float32)\n",
    "#         self.y_train = tmp_df[3].astype(np.float32)       \n",
    "#         d = defaultdict(LabelEncoder)\n",
    "#         self.y_train =tmp_df[1].apply(lambda x: d[x].fit_transform(x))\n",
    "    \n",
    "#         tmp_df=one_hot(tmp_df,tmp_df[1])\n",
    "#         self.y_train = tmp_df[1].astype(np.float32)       \n",
    "#         encoder = LabelEncoder()\n",
    "#         encoder.fit(tmp_df[1])\n",
    "#         self.y_train = encoder.transform(tmp_df[1]).astype(np.float32)\n",
    "#         self.y_train=self.y_train.reshape((self.y_train.shape[0],1)) # Must be reshaped for PyTorch!\n",
    "                \n",
    "        lgr.info('[*]Dataset loading time {}'.format(time.time() - t))\n",
    "        lgr.info('[*] Data size is {}'.format(len(self)))\n",
    "        \n",
    "        lgr.info(\"DF CSV:\\n\" + str (tmp_df.head(5)))\n",
    "        \n",
    "        print ()\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "#         lgr.info (\"__getitem__:\" + str(index))\n",
    "        path=self.img_path + self.X_train[index]\n",
    "        path=self.X_train[index]\n",
    "#         lgr.info (\" --- get item path:\" + path)\n",
    "        img = Image.open(path)\n",
    "        img = img.convert('RGB')\n",
    "        if self.transform is not None: # TypeError: batch must contain tensors, numbers, or lists; \n",
    "                                     #found <class 'PIL.Image.Image'>\n",
    "            img = self.transform(img)\n",
    "#             print (str (type(img))) # <class 'torch.FloatTensor'>                \n",
    "#         label = torch.from_numpy(self.y_train[index])\n",
    "        label = (self.y_train[index])\n",
    "        return img, label\n",
    "\n",
    "    def __len__(self):\n",
    "        l=len(self.X_train.index)\n",
    "#         lgr.info (\"Lenght:\" +str(l))\n",
    "        return (l)       \n",
    "\n",
    "    @staticmethod        \n",
    "    def imshow(img):\n",
    "        img = img / 2 + 0.5     # unnormalize\n",
    "        npimg = img.numpy()\n",
    "        plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "\n",
    "    @staticmethod    \n",
    "    def flaotTensorToImage(img, mean=0, std=1):\n",
    "        \"\"\"convert a tensor to an image\"\"\"\n",
    "        img = np.transpose(img.numpy(), (1, 2, 0))\n",
    "        img = (img*std+ mean)*255\n",
    "        img = img.astype(np.uint8)    \n",
    "        return img    \n",
    "    \n",
    "    @staticmethod\n",
    "    def toTensor(img):\n",
    "        \"\"\"convert a numpy array of shape HWC to CHW tensor\"\"\"\n",
    "        img = img.transpose((2, 0, 1)).astype(np.float32)\n",
    "        tensor = torch.from_numpy(img).float()\n",
    "        return tensor/255.0  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "transformations = transforms.Compose([transforms.ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:CSV path G:/tensorflow-speech-recognition-challenge//train_v2.csv\n",
      "INFO:__main__:IMG path G:/tensorflow-speech-recognition-challenge//train/train/pict/\n",
      "INFO:__main__:DF CSV:\n",
      "                       0     1  \\\n",
      "0  00176480_nohash_0.png  down   \n",
      "1  004ae714_nohash_0.png  down   \n",
      "2  00b01445_nohash_0.png  down   \n",
      "\n",
      "                                                   2  3  \n",
      "0  G:/tensorflow-speech-recognition-challenge/tra...  0  \n",
      "1  G:/tensorflow-speech-recognition-challenge/tra...  0  \n",
      "2  G:/tensorflow-speech-recognition-challenge/tra...  0  \n",
      "INFO:__main__:y_train [[1.]\n",
      " [0.]\n",
      " [0.]\n",
      " ...\n",
      " [0.]\n",
      " [0.]\n",
      " [1.]]\n",
      "INFO:__main__:[*]Dataset loading time 0.1310265064239502\n",
      "INFO:__main__:[*] Data size is 23682\n",
      "INFO:__main__:DF CSV:\n",
      "                       0     1  \\\n",
      "0  00176480_nohash_0.png  down   \n",
      "1  004ae714_nohash_0.png  down   \n",
      "2  00b01445_nohash_0.png  down   \n",
      "3  00b01445_nohash_1.png  down   \n",
      "4  00f0204f_nohash_0.png  down   \n",
      "\n",
      "                                                   2  3  \n",
      "0  G:/tensorflow-speech-recognition-challenge/tra...  0  \n",
      "1  G:/tensorflow-speech-recognition-challenge/tra...  0  \n",
      "2  G:/tensorflow-speech-recognition-challenge/tra...  0  \n",
      "3  G:/tensorflow-speech-recognition-challenge/tra...  0  \n",
      "4  G:/tensorflow-speech-recognition-challenge/tra...  0  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "dset_train = GenericImageDataset(IMG_DATA_LABELS,IMG_PATH,IMG_EXT,transformations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Offest:21076\n",
      "<torch.utils.data.dataloader.DataLoader object at 0x000001E2CDE7AAC8>\n",
      "<torch.utils.data.dataloader.DataLoader object at 0x000001E384EF0748>\n"
     ]
    }
   ],
   "source": [
    "batch_size = 16 # on GTX 1080\n",
    "global_epoches = 10\n",
    "LR = 0.0005\n",
    "MOMENTUM = 0.95\n",
    "validationRatio=0.11    \n",
    "\n",
    "class FullTrainningDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, full_ds, offset, length):\n",
    "        self.full_ds = full_ds\n",
    "        self.offset = offset\n",
    "        self.length = length\n",
    "        assert len(full_ds)>=offset+length, Exception(\"Parent Dataset not long enough\")\n",
    "        super(FullTrainningDataset, self).__init__()\n",
    "        \n",
    "    def __len__(self):\n",
    "        return self.length\n",
    "    \n",
    "    def __getitem__(self, i):\n",
    "        return self.full_ds[i+self.offset]\n",
    "    \n",
    "\n",
    "\n",
    "def trainTestSplit(dataset, val_share=validationRatio):\n",
    "    val_offset = int(len(dataset)*(1-val_share))\n",
    "    print(\"Offest:\" + str(val_offset))\n",
    "    return FullTrainningDataset(dataset, 0, val_offset), FullTrainningDataset(dataset, val_offset, len(dataset)-val_offset)\n",
    "\n",
    " \n",
    "train_ds, val_ds = trainTestSplit(dset_train)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=False, num_workers=0)\n",
    "val_loader = torch.utils.data.DataLoader(val_ds, batch_size=batch_size, shuffle=False, num_workers=0)\n",
    "\n",
    "print(train_loader)\n",
    "print(val_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:i=0: \n",
      "INFO:__main__:i=1: \n",
      "INFO:__main__:i=2: \n",
      "INFO:__main__:i=3: \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "imagesToShow=4\n",
    "\n",
    "for i, data in enumerate(train_loader, 0):\n",
    "    lgr.info('i=%d: '%(i))            \n",
    "    images, labels = data            \n",
    "    num = len(images)\n",
    "    \n",
    "    ax = plt.subplot(1, imagesToShow, i + 1)\n",
    "    plt.tight_layout()\n",
    "    ax.set_title('Sample #{}'.format(i))\n",
    "    ax.axis('off')\n",
    "    \n",
    "    for n in range(num):\n",
    "        image=images[n]\n",
    "        label=labels[n]\n",
    "        plt.imshow (GenericImageDataset.flaotTensorToImage(image))\n",
    "        \n",
    "    if i==imagesToShow-1:\n",
    "        break    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:Using the CPU\n",
      "INFO:__main__:Model Net(\n",
      "  (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "  (cnn1): ConvCNN(\n",
      "    (math): Sequential(\n",
      "      (0): Conv2d(3, 32, kernel_size=(7, 7), stride=(1, 1), padding=(2, 2))\n",
      "      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (2): LeakyReLU(negative_slope=0.01)\n",
      "      (3): MaxPool2d(kernel_size=4, stride=4, padding=0, dilation=1, ceil_mode=False)\n",
      "    )\n",
      "    (avgpool): AvgPool2d(kernel_size=4, stride=4, padding=0)\n",
      "  )\n",
      "  (cnn2): ConvCNN(\n",
      "    (math): Sequential(\n",
      "      (0): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (2): LeakyReLU(negative_slope=0.01)\n",
      "      (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    )\n",
      "    (avgpool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
      "  )\n",
      "  (cnn3): ConvCNN(\n",
      "    (math): Sequential(\n",
      "      (0): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (2): LeakyReLU(negative_slope=0.01)\n",
      "      (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    )\n",
      "    (avgpool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
      "  )\n",
      "  (res1): ConvRes(\n",
      "    (math): Sequential(\n",
      "      (0): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (1): Conv2d(32, 64, kernel_size=(2, 2), stride=(1, 1), padding=(2, 2))\n",
      "      (2): PReLU(num_parameters=1)\n",
      "    )\n",
      "  )\n",
      "  (features): Sequential(\n",
      "    (0): ConvCNN(\n",
      "      (math): Sequential(\n",
      "        (0): Conv2d(3, 32, kernel_size=(7, 7), stride=(1, 1), padding=(2, 2))\n",
      "        (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (2): LeakyReLU(negative_slope=0.01)\n",
      "        (3): MaxPool2d(kernel_size=4, stride=4, padding=0, dilation=1, ceil_mode=False)\n",
      "      )\n",
      "      (avgpool): AvgPool2d(kernel_size=4, stride=4, padding=0)\n",
      "    )\n",
      "    (1): Dropout(p=0.3, inplace=False)\n",
      "    (2): ConvCNN(\n",
      "      (math): Sequential(\n",
      "        (0): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (2): LeakyReLU(negative_slope=0.01)\n",
      "        (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "      )\n",
      "      (avgpool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
      "    )\n",
      "    (3): ConvCNN(\n",
      "      (math): Sequential(\n",
      "        (0): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
      "        (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (2): LeakyReLU(negative_slope=0.01)\n",
      "        (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "      )\n",
      "      (avgpool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
      "    )\n",
      "    (4): ConvRes(\n",
      "      (math): Sequential(\n",
      "        (0): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "        (1): Conv2d(32, 64, kernel_size=(2, 2), stride=(1, 1), padding=(2, 2))\n",
      "        (2): PReLU(num_parameters=1)\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (classifier): Sequential(\n",
      "    (0): Linear(in_features=3136, out_features=1, bias=True)\n",
      "  )\n",
      "  (sig): Sigmoid()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "dropout = torch.nn.Dropout(p=0.30)\n",
    "class ConvRes(nn.Module):\n",
    "    def __init__(self, insize, outsize):\n",
    "        super(ConvRes, self).__init__()\n",
    "        drate = .3\n",
    "        self.math = nn.Sequential(\n",
    "            nn.BatchNorm2d(insize),\n",
    "            # nn.Dropout(drate),\n",
    "            torch.nn.Conv2d(insize, outsize, kernel_size=2, padding=2),\n",
    "            nn.PReLU(),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.math(x)\n",
    "\n",
    "\n",
    "class ConvCNN(nn.Module):\n",
    "    def __init__(self, insize, outsize, kernel_size=7, padding=2, pool=2, avg=True):\n",
    "        super(ConvCNN, self).__init__()\n",
    "        self.avg = avg\n",
    "        self.math = torch.nn.Sequential(\n",
    "            torch.nn.Conv2d(insize, outsize, kernel_size=kernel_size, padding=padding),\n",
    "            torch.nn.BatchNorm2d(outsize),\n",
    "            torch.nn.LeakyReLU(),\n",
    "            torch.nn.MaxPool2d(pool, pool),\n",
    "        )\n",
    "        self.avgpool = torch.nn.AvgPool2d(pool, pool)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.math(x)\n",
    "        if self.avg is True:\n",
    "            x = self.avgpool(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self, output_dim):\n",
    "        super(Net, self).__init__()\n",
    "\n",
    "        self.avgpool = nn.AdaptiveAvgPool2d(1)\n",
    "\n",
    "        self.cnn1 = ConvCNN(3, 32, kernel_size=7, pool=4, avg=False)\n",
    "        self.cnn2 = ConvCNN(32, 32, kernel_size=5, pool=2, avg=True)\n",
    "        self.cnn3 = ConvCNN(32, 32, kernel_size=5, pool=2, avg=True)\n",
    "\n",
    "        self.res1 = ConvRes(32, 64)\n",
    "\n",
    "        self.features = nn.Sequential(\n",
    "            self.cnn1, dropout,\n",
    "            self.cnn2,\n",
    "            self.cnn3,\n",
    "            self.res1,\n",
    "        )\n",
    "\n",
    "        self.classifier = torch.nn.Sequential(\n",
    "            nn.Linear(3136, output_dim),\n",
    "        )\n",
    "        self.sig = nn.Sigmoid()\n",
    "  \n",
    "    def forward(self, x):\n",
    "        x = self.features(x)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.classifier(x)\n",
    "        x = self.sig(x)\n",
    "        return x\n",
    "\n",
    "    \n",
    "if use_cuda:\n",
    "    lgr.info (\"Using the GPU\")\n",
    "    model = Net().cuda() # On GPU\n",
    "else:\n",
    "    lgr.info (\"Using the CPU\")\n",
    "    model = Net() # On CPU\n",
    "\n",
    "lgr.info('Model {}'.format(model))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:Adam (\n",
      "Parameter Group 0\n",
      "    amsgrad: False\n",
      "    betas: (0.9, 0.999)\n",
      "    eps: 1e-08\n",
      "    lr: 0.005\n",
      "    weight_decay: 5e-05\n",
      ")\n",
      "INFO:__main__:MultiLabelSoftMarginLoss()\n"
     ]
    }
   ],
   "source": [
    "loss_func=torch.nn.BCELoss()\n",
    "loss_func = nn.MultiLabelSoftMarginLoss()\n",
    "# loss_func = torch.nn.CrossEntropyLoss()\n",
    "# NN params\n",
    "LR = 0.005\n",
    "MOMENTUM= 0.9\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LR,weight_decay=5e-5) #  L2 regularization\n",
    "if use_cuda:\n",
    "    lgr.info (\"Using the GPU\")    \n",
    "    model.cuda()\n",
    "    loss_func.cuda()\n",
    "\n",
    "lgr.info (optimizer)\n",
    "lgr.info (loss_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:Train Epoch: 1 [0/21076 (0%)]\tLoss: 0.693152\n",
      "INFO:__main__:Train Epoch: 1 [1600/21076 (8%)]\tLoss: 0.693154\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-40-23f65f76d246>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     51\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m5\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     52\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Epoch %d\"\u001b[0m \u001b[1;33m%\u001b[0m \u001b[0mepoch\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 53\u001b[1;33m     \u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mepoch\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     54\u001b[0m \u001b[0mend_time\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\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     55\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'{} {:6.3f} seconds'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'GPU:'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mend_time\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mstart_time\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<ipython-input-40-23f65f76d246>\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(epoch)\u001b[0m\n\u001b[0;32m     35\u001b[0m \u001b[1;31m#             loss = F.log_softmax(preds)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     36\u001b[0m \u001b[1;31m#             loss = F.nll_loss(preds, target.long()) # RuntimeError: multi-target not supported at /pytorch/torch/lib/THNN/generic/ClassNLLCriterion.c:22\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 37\u001b[1;33m         \u001b[0mloss\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\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[0m\u001b[0;32m     38\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     39\u001b[0m         \u001b[0mopt\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[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\torch\\tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[0;32m    164\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[1;33m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    165\u001b[0m         \"\"\"\n\u001b[1;32m--> 166\u001b[1;33m         \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\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    167\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    168\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhook\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~\\Anaconda3\\lib\\site-packages\\torch\\autograd\\__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[0;32m     97\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[0;32m     98\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 99\u001b[1;33m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[0;32m    100\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    101\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.autograd import Variable\n",
    "    \n",
    "clf=model \n",
    "opt= optimizer\n",
    "loss_history = []\n",
    "acc_history = []\n",
    " \n",
    "def train(epoch):\n",
    "    clf.train() # set model in training mode (need this because of dropout)\n",
    "     \n",
    "    # dataset API gives us pythonic batching \n",
    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
    "        \n",
    "        if use_cuda:\n",
    "            pass\n",
    "            #data, target = Variable(data.cuda(async=True)), Variable(target.cuda(async=True)) # On GPU                \n",
    "        else:            \n",
    "            data, target = Variable(data), Variable(target) # RuntimeError: expected CPU tensor (got CUDA tensor)                           \n",
    "                 \n",
    "        # forward pass, calculate loss and backprop!\n",
    "        opt.zero_grad()\n",
    "        preds = clf(data)\n",
    "        if use_cuda:\n",
    "            loss = loss_func(preds, target).cuda()\n",
    "#             loss = F.log_softmax(preds).cuda() # TypeError: log_softmax() takes exactly 1 argument (2 given)\n",
    "#             loss = F.nll_loss(preds, target).cuda() # https://github.com/torch/cutorch/issues/227\n",
    "            \n",
    "        else:\n",
    "            loss = loss_func(preds, target)\n",
    "#             loss = F.log_softmax(preds)\n",
    "#             loss = F.nll_loss(preds, target.long()) # RuntimeError: multi-target not supported at /pytorch/torch/lib/THNN/generic/ClassNLLCriterion.c:22\n",
    "        loss.backward()\n",
    "        \n",
    "        opt.step()\n",
    "        \n",
    "        \n",
    "        if batch_idx % 100 == 0:\n",
    "            loss_history.append(loss.data)\n",
    "            lgr.info('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n",
    "            epoch, batch_idx * len(data), len(train_loader.dataset),\n",
    "            100. * batch_idx / len(train_loader), loss.data))              \n",
    "\n",
    "            \n",
    "start_time = time.time()    \n",
    "\n",
    "for epoch in range(1, 5):\n",
    "    print(\"Epoch %d\" % epoch)\n",
    "    train(epoch)    \n",
    "end_time = time.time()\n",
    "print ('{} {:6.3f} seconds'.format('GPU:', end_time-start_time))\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(loss_history)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = loss_func\n",
    "all_losses = []\n",
    "val_losses = []\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "\n",
    "    for epoch in range(global_epoches):\n",
    "        print('Epoch {}'.format(epoch + 1))\n",
    "        print('*' * 5 + ':')\n",
    "        running_loss = 0.0\n",
    "        running_acc = 0.0\n",
    "        for i, data in enumerate(train_loader, 1):\n",
    "    \n",
    "            img, label = data\n",
    "            if use_cuda:\n",
    "                img, label = Variable(img.cuda(async=True)), Variable(label.cuda(async=True))  # On GPU\n",
    "            else:\n",
    "                img, label = Variable(img), Variable(\n",
    "                    label)  # RuntimeError: expected CPU tensor (got CUDA tensor)\n",
    "    \n",
    "            out = model(img)\n",
    "            loss = criterion(out, label)\n",
    "            running_loss += loss.data * label.size(0)\n",
    "    \n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "    \n",
    "            if i % 100 == 0:\n",
    "                all_losses.append(running_loss / (batch_size * i))\n",
    "                print('[{}/{}] Loss: {:.6f}'.format(\n",
    "                    epoch + 1, global_epoches, running_loss / (batch_size * i),\n",
    "                    running_acc / (batch_size * i)))\n",
    "                \n",
    "    \n",
    "#                 loss_cost = loss.data[0]                                \n",
    "#                 # RuntimeError: can't convert CUDA tensor to numpy (it doesn't support GPU arrays). \n",
    "#                 # Use .cpu() to move the tensor to host memory first.        \n",
    "#                 prediction = (model(img).data).float() # probabilities         \n",
    "#         #         prediction = (net(X_tensor).data > 0.5).float() # zero or one\n",
    "#         #         print (\"Pred:\" + str (prediction)) # Pred:Variable containing: 0 or 1\n",
    "#         #         pred_y = prediction.data.numpy().squeeze()            \n",
    "#                 pred_y = prediction.cpu().numpy().squeeze()\n",
    "#                 target_y = label.cpu().data.numpy()\n",
    "\n",
    "#                 tu = (log_loss(target_y, pred_y),roc_auc_score(target_y,pred_y ))\n",
    "#                 print ('LOG_LOSS={}, ROC_AUC={} '.format(*tu))  \n",
    "        \n",
    "    \n",
    "        print('Finish {} epoch, Loss: {:.6f}'.format(epoch + 1, running_loss / (len(train_ds))))\n",
    "    \n",
    "        model.eval()\n",
    "        eval_loss = 0\n",
    "        eval_acc = 0\n",
    "        for data in val_loader:\n",
    "            img, label = data\n",
    "    \n",
    "            if use_cuda:\n",
    "                img, label = Variable(img.cuda(async=True), volatile=True),Variable(label.cuda(async=True), volatile=True)  # On GPU\n",
    "            else:\n",
    "                img = Variable(img, volatile=True)\n",
    "                label = Variable(label, volatile=True)\n",
    "    \n",
    "            out = model(img)\n",
    "            loss = criterion(out, label)\n",
    "            eval_loss += loss.data * label.size(0)\n",
    "    \n",
    "        print('VALIDATION Loss: {:.6f}'.format(eval_loss / (len(val_ds))))\n",
    "        val_losses.append(eval_loss / (len(val_ds)))\n",
    "        print()"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}