Attempt 5 With New Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/lucaslyon/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "import keras\n",
    "from keras.datasets import cifar10\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Activation, Flatten\n",
    "from keras.layers import Conv1D, MaxPooling1D\n",
    "\n",
    "import pandas as pd\n",
    "import json\n",
    "import librosa\n",
    "#import librosa.display\n",
    "import numpy as np\n",
    "#import matplotlib.pyplot as plt\n",
    "#from matplotlib.pyplot import specgram\n",
    "import os\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Begin Importing Data for Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/fear/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "    sample_rate = np.array(sampling_rate)\n",
    "    mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                        sr=sample_rate, \n",
    "                                        n_mfcc=13),\n",
    "                    axis=0)\n",
    "    feature = mfccs\n",
    "    df.loc[bookmark] = [feature]\n",
    "    bookmark+=1\n",
    "fearDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#fearDf['label'] = \"fear\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/angry/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "    sample_rate = np.array(sampling_rate)\n",
    "    mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                        sr=sample_rate, \n",
    "                                        n_mfcc=13),\n",
    "                    axis=0)\n",
    "    feature = mfccs\n",
    "    df.loc[bookmark] = [feature]\n",
    "    bookmark+=1\n",
    "angryDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#angryDf['label'] = \"angry\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/disgust/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "    sample_rate = np.array(sampling_rate)\n",
    "    mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                        sr=sample_rate, \n",
    "                                        n_mfcc=13),\n",
    "                    axis=0)\n",
    "    feature = mfccs\n",
    "    df.loc[bookmark] = [feature]\n",
    "    bookmark+=1\n",
    "disgustDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#disgustDf['label'] = \"disgust\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/happy/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "    except:\n",
    "        pass\n",
    "happyDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#happyDf['label'] = \"happy\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/neutral/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "    except:\n",
    "        pass\n",
    "neutralDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#neutralDf['label'] = \"neutral\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/surprise/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "    except:\n",
    "        pass\n",
    "surpriseDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#surpriseDf['label'] = \"surprise\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/sad/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "    except:\n",
    "        pass\n",
    "sadDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#sadDf['label'] = \"sad\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/AudioData/DC/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "dc_feeling_list = []\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    \n",
    "    emotion = file[0]\n",
    "    \n",
    "    if emotion == 'a':\n",
    "        dc_feeling_list.append('angry')\n",
    "    elif emotion == 'd':\n",
    "        dc_feeling_list.append('disgust')\n",
    "    elif emotion == 'f':\n",
    "        dc_feeling_list.append('fear')\n",
    "    elif emotion == 'h':\n",
    "        dc_feeling_list.append('happy')\n",
    "    elif emotion == 'n':\n",
    "        dc_feeling_list.append('neutral')\n",
    "    elif emotion == 's' and file[1] == 'a':\n",
    "        dc_feeling_list.append('sad')\n",
    "    else: dc_feeling_list.append('surprise')\n",
    "    \n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "        \n",
    "    except:\n",
    "        pass\n",
    "#labels = pd.DataFrame(dc_feeling_list)\n",
    "dcDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#dcDf = pd.concat([dcDf, labels], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/AudioData/JE/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "je_feeling_list = []\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    \n",
    "    emotion = file[0]\n",
    "    \n",
    "    if emotion == 'a':\n",
    "        je_feeling_list.append('angry')\n",
    "    elif emotion == 'd':\n",
    "        je_feeling_list.append('disgust')\n",
    "    elif emotion == 'f':\n",
    "        je_feeling_list.append('fear')\n",
    "    elif emotion == 'h':\n",
    "        je_feeling_list.append('happy')\n",
    "    elif emotion == 'n':\n",
    "        je_feeling_list.append('neutral')\n",
    "    elif emotion == 's' and file[1] == 'a':\n",
    "        je_feeling_list.append('sad')\n",
    "    else: je_feeling_list.append('surprise')\n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "    except:\n",
    "        pass\n",
    "jeDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#labels = pd.DataFrame(je_feeling_list)\n",
    "#jeDf = pd.concat([jeDf, labels], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/AudioData/JK/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "jk_feeling_list = []\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    \n",
    "    emotion = file[0]\n",
    "    \n",
    "    if emotion == 'a':\n",
    "        jk_feeling_list.append('angry')\n",
    "    elif emotion == 'd':\n",
    "        jk_feeling_list.append('disgust')\n",
    "    elif emotion == 'f':\n",
    "        jk_feeling_list.append('fear')\n",
    "    elif emotion == 'h':\n",
    "        jk_feeling_list.append('happy')\n",
    "    elif emotion == 'n':\n",
    "        jk_feeling_list.append('neutral')\n",
    "    elif emotion == 's' and file[1] == 'a':\n",
    "        jk_feeling_list.append('sad')\n",
    "    else: jk_feeling_list.append('surprise')\n",
    "    \n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "    except:\n",
    "        pass\n",
    "jkDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#labels = pd.DataFrame(jk_feeling_list)\n",
    "#jkDf = pd.concat([jkDf, labels], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/AudioData/KL/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "kl_feeling_list = []\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    \n",
    "    emotion = file[0]\n",
    "    \n",
    "    if emotion == 'a':\n",
    "        kl_feeling_list.append('angry')\n",
    "    elif emotion == 'd':\n",
    "        kl_feeling_list.append('disgust')\n",
    "    elif emotion == 'f':\n",
    "        kl_feeling_list.append('fear')\n",
    "    elif emotion == 'h':\n",
    "        kl_feeling_list.append('happy')\n",
    "    elif emotion == 'n':\n",
    "        kl_feeling_list.append('neutral')\n",
    "    elif emotion == 's' and file[1] == 'a':\n",
    "        kl_feeling_list.append('sad')\n",
    "    else: kl_feeling_list.append('surprise')\n",
    "        \n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "    except:\n",
    "        pass\n",
    "klDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#labels = pd.DataFrame(kl_feeling_list)\n",
    "#klDf = pd.concat([klDf, labels], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/AudioWAV/\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "wav_feeling_list = []\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    try:\n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "        \n",
    "        emotion = file[9:12] \n",
    "        \n",
    "        if emotion == \"ANG\":\n",
    "            wav_feeling_list.append(\"angry\")\n",
    "        elif emotion == \"DIS\":\n",
    "            wav_feeling_list.append(\"disgust\")\n",
    "        elif emotion == \"FEA\":\n",
    "            wav_feeling_list.append(\"fear\")\n",
    "        elif emotion == \"HAP\":\n",
    "            wav_feeling_list.append(\"happy\")\n",
    "        elif emotion == \"NEU\":\n",
    "            wav_feeling_list.append(\"neutral\")\n",
    "        elif emotion == \"SAD\":\n",
    "            wav_feeling_list.append(\"sad\")\n",
    "        else:\n",
    "            print(\"      \", emotion)\n",
    "    except:\n",
    "        pass\n",
    "wavDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#labelsDf = pd.DataFrame(feeling_list)\n",
    "#wavDf = pd.concat([wavDf, labelsDf], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDir = \"./training_audio_files/emodb/wav\"\n",
    "trainFileList = os.listdir(trainDir)\n",
    "trainFileList.sort()\n",
    "emo_feeling_list = []\n",
    "\n",
    "df = pd.DataFrame(columns=['feature'])\n",
    "bookmark=0\n",
    "for file in trainFileList:\n",
    "    \n",
    "    try:\n",
    "        \n",
    "        X, sampling_rate = librosa.load(trainDir+file, duration=5.0)\n",
    "        sample_rate = np.array(sampling_rate)\n",
    "        mfccs = np.mean(librosa.feature.mfcc(y=X, \n",
    "                                            sr=sample_rate, \n",
    "                                            n_mfcc=13),\n",
    "                        axis=0)\n",
    "        feature = mfccs\n",
    "        df.loc[bookmark] = [feature]\n",
    "        bookmark+=1\n",
    "        \n",
    "        emotion = file[5]\n",
    "        if emotion == 'A':\n",
    "            emo_feeling_list.append(\"fear\")\n",
    "        elif emotion == 'W':\n",
    "            emo_feeling_list.append(\"angry\")\n",
    "        elif emotion == 'L':\n",
    "            emo_feeling_list.append(\"bored\")\n",
    "        elif emotion == 'E':\n",
    "            emo_feeling_list.append(\"disgust\")\n",
    "        elif emotion == 'F':\n",
    "            emo_feeling_list.append(\"happy\")\n",
    "        elif emotion == 'T':\n",
    "            emo_feeling_list.append(\"sad\")\n",
    "        elif emotion == 'N':\n",
    "            emo_feeling_list.append(\"neutral\")\n",
    "        else:\n",
    "            print(\"error\", emotion)\n",
    "    except:\n",
    "        pass\n",
    "emoDf = pd.DataFrame(df['feature'].values.tolist())\n",
    "#labelDf = pd.DataFrame(feeling_list)\n",
    "#emoDf = pd.concat([emoDf, labelDf], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "concat2 = pd.concat([dcDf,jeDf, jkDf, klDf])\n",
    "concatenatedDf = pd.concat([angryDf, fearDf, disgustDf, happyDf, sadDf, neutralDf, surpriseDf, concat2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making a list of emotion labels for each audio file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "compiled_feeling_list = []\n",
    "for file in range(len(angryDf)):\n",
    "    compiled_feeling_list.append(0)\n",
    "for file in range(len(fearDf)):\n",
    "    compiled_feeling_list.append(1)\n",
    "for file in range(len(disgustDf)):\n",
    "    compiled_feeling_list.append(2)\n",
    "for file in range(len(happyDf)):\n",
    "    compiled_feeling_list.append(3)\n",
    "for file in range(len(sadDf)):\n",
    "    compiled_feeling_list.append(4)\n",
    "for file in range(len(neutralDf)):\n",
    "    compiled_feeling_list.append(5)\n",
    "for file in range(len(surpriseDf)):\n",
    "    compiled_feeling_list.append(6)\n",
    "\n",
    "dcjejkkl_feeling_list = dc_feeling_list + je_feeling_list + jk_feeling_list + kl_feeling_list\n",
    "for emo in range(len(dcjejkkl_feeling_list)):\n",
    "    if dcjejkkl_feeling_list[emo] == \"angry\":\n",
    "        compiled_feeling_list.append(0)\n",
    "    elif dcjejkkl_feeling_list[emo] == \"fear\":\n",
    "        compiled_feeling_list.append(1)\n",
    "    elif dcjejkkl_feeling_list[emo] == \"disgust\":\n",
    "        compiled_feeling_list.append(2)\n",
    "    elif dcjejkkl_feeling_list[emo] == \"happy\":\n",
    "        compiled_feeling_list.append(3)\n",
    "    elif dcjejkkl_feeling_list[emo] == \"sad\":\n",
    "        compiled_feeling_list.append(4)\n",
    "    elif dcjejkkl_feeling_list[emo] == \"neutral\":\n",
    "        compiled_feeling_list.append(5)\n",
    "    elif dcjejkkl_feeling_list[emo] == \"surprise\":\n",
    "        compiled_feeling_list.append(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making Pandas DataFrame with emotion labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "labelDf = pd.DataFrame(compiled_feeling_list)\n",
    "\n",
    "concatenatedDf = concatenatedDf.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "concatenatedDf = pd.concat([concatenatedDf, labelDf], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "concatenatedDf = concatenatedDf.fillna(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exported the labeled Pandas DataFrame for easier import of data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "concatenatedDf.to_csv(\"9_24_2018_1_43_pm_emotions_and_speakers.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up the training and testing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (2948, 217)\n",
      "2948 train samples\n",
      "332 test samples\n"
     ]
    }
   ],
   "source": [
    "emotionsDf = pd.read_csv(\"9_24_2018_1_43_pm_emotions_and_speakers.csv\")\n",
    "\n",
    "from sklearn.utils import shuffle\n",
    "shuffledDf = shuffle(emotionsDf)\n",
    "\n",
    "divider = np.random.rand(len(shuffledDf)) < 0.9\n",
    "train = shuffledDf[divider]\n",
    "test = shuffledDf[~divider]\n",
    "\n",
    "trainfeatures = train.iloc[:, :-1]\n",
    "trainlabels = train.iloc[:, -1:]\n",
    "\n",
    "testfeatures = test.iloc[:, :-1]\n",
    "testlabels = test.iloc[:, -1:]\n",
    "\n",
    "x_train = np.array(trainfeatures)\n",
    "y_train = np.array(trainlabels)\n",
    "x_test = np.array(testfeatures)\n",
    "y_test = np.array(testlabels)\n",
    "\n",
    "#flattening the arrays\n",
    "y_train = np.hstack(y_train)\n",
    "y_test = np.hstack(y_test)\n",
    "\n",
    "#convert class vectors to binary class matrices.\n",
    "num_classes = 7\n",
    "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
    "y_test = keras.utils.to_categorical(y_test, num_classes)\n",
    "\n",
    "print('x_train shape:', x_train.shape)\n",
    "print(x_train.shape[0], 'train samples')\n",
    "print(x_test.shape[0], 'test samples')\n",
    "x_test = np.expand_dims(x_test, axis=2)\n",
    "x_train = np.expand_dims(x_train, axis=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting up the Keras Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "\n",
    "model.add(Conv1D(32, 5, padding='same',input_shape=(217,1)))\n",
    "model.add(Activation('relu'))\n",
    "model.add(MaxPooling1D(pool_size=2))\n",
    "\n",
    "model.add(Conv1D(64, 5, padding='same'))\n",
    "model.add(Activation('relu'))\n",
    "model.add(MaxPooling1D(pool_size=2))\n",
    "\n",
    "# model.add(Conv1D(128, 5, padding='same'))\n",
    "# model.add(Activation('relu'))\n",
    "# model.add(MaxPooling1D(pool_size=2))\n",
    "\n",
    "# model.add(Conv1D(256, 5, padding='same'))\n",
    "# model.add(Activation('relu'))\n",
    "# model.add(MaxPooling1D(pool_size=2))\n",
    "\n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "model.add(Flatten())\n",
    "\n",
    "model.add(Dense(128))\n",
    "model.add(Activation('relu'))\n",
    "\n",
    "model.add(Dropout(0.5))\n",
    "\n",
    "model.add(Dense(num_classes))\n",
    "model.add(Activation('softmax'))\n",
    "\n",
    "# initiate RMSprop optimizer\n",
    "opt = keras.optimizers.Adadelta()\n",
    "\n",
    "# Let's train the model using RMSprop\n",
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer=opt,\n",
    "metrics=['accuracy'])\n",
    "\n",
    "from keras.utils.vis_utils import plot_model\n",
    "plot_model(model, to_file='Attempt5Architecture.png', show_shapes=True, show_layer_names=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "epochs = 100\n",
    "\n",
    "cnnhistory = model.fit(x_train, y_train,\n",
    "              batch_size=batch_size,\n",
    "              epochs=epochs,\n",
    "              validation_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import matplotlib.pyplot as plt\n",
    "# # Plot training & validation accuracy values\n",
    "# plt.plot(cnnhistory.history['acc'])\n",
    "# plt.plot(cnnhistory.history['val_acc'])\n",
    "# plt.title('Model accuracy')\n",
    "# plt.ylabel('Accuracy')\n",
    "# plt.xlabel('Epoch')\n",
    "# plt.legend(['Train', 'Test'], loc='upper left')\n",
    "# plt.savefig(\"Attempt5Acc.png\")\n",
    "\n",
    "# Plot training & validation loss values\n",
    "plt.plot(cnnhistory.history['loss'])\n",
    "plt.plot(cnnhistory.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.savefig(\"Attempt5Loss.png\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"model2.h5\")"
   ]
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}