test_1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "timit_df_test = pd.read_hdf(\"./features/mfcc/timit_test.hdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "451660\n"
     ]
    }
   ],
   "source": [
    "timit_df_test.head()\n",
    "length = timit_df_test.shape[0]\n",
    "print(length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "labels = np.array(timit_df_test[\"labels\"].tolist())\n",
    "p = list(set(labels))\n",
    "p.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "gmm_models = dict()\n",
    "for i in range(0,40):\n",
    "    filepath = \"./models/mfcc/with_energy_coeff/model_of_\"+p[i]+\".pkl\"\n",
    "    gmm_pickle = open(filepath, 'rb')\n",
    "    gmm_model = pickle.load(gmm_pickle)\n",
    "    gmm_models[p[i]] = gmm_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "len_p = len(p)\n",
    "classified = 0\n",
    "misclassified = 0\n",
    "for i in range(0,length):\n",
    "    x = timit_df_test['features'][i]\n",
    "    label = timit_df_test['labels'][i]\n",
    "    test_data = []\n",
    "    test_data.append(x)\n",
    "    result = dict()\n",
    "    for j in range(0,len_p):\n",
    "        gmm_model = gmm_models[p[j]]\n",
    "        result[p[j]] = gmm_model.score_samples(test_data)\n",
    "    #print(max(result, key=result.get)+\" \"+label)\n",
    "    if(max(result, key=result.get) == label):\n",
    "        classified = classified+1\n",
    "    else:\n",
    "        misclassified = misclassified+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1) MFCC with Energy Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.14323384847008813"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classified/(classified+misclassified)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2) MFCC without Energy Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def test(p,timit_df_test,gmm_models):\n",
    "    len_p = len(p)\n",
    "    classified = 0\n",
    "    misclassified = 0\n",
    "    for i in range(0,length):\n",
    "        x = timit_df_test['features'][i]\n",
    "        label = timit_df_test['labels'][i]\n",
    "        test_data = []\n",
    "        test_data.append(x)\n",
    "        result = dict()\n",
    "        for j in range(0,len_p):\n",
    "            gmm_model = gmm_models[p[j]]\n",
    "            result[p[j]] = gmm_model.score_samples(test_data)\n",
    "    #print(max(result, key=result.get)+\" \"+label)\n",
    "        if(max(result, key=result.get) == label):\n",
    "            classified = classified+1\n",
    "        else:\n",
    "            misclassified = misclassified+1\n",
    "    result = classified/(classified+misclassified)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/shivam/anaconda3/lib/python3.6/site-packages/sklearn/base.py:311: UserWarning: Trying to unpickle estimator GaussianMixture from version 0.20.0 when using version 0.19.1. This might lead to breaking code or invalid results. Use at your own risk.\n",
      "  UserWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1309945534251428\n",
      "0.14063233405659123\n",
      "0.1480826285258823\n",
      "0.1485918611344817\n",
      "0.148339458885002\n",
      "0.14463091706150644\n",
      "0.13939024930257274\n",
      "0.1344108400123987\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "components = [2,4,8,16,32,64,128,256]\n",
    "for comp in components:\n",
    "    gmm_models = dict()\n",
    "    for i in range(0,40):\n",
    "        filepath = \"./models/mfcc/without_energy_coeff/\"+str(comp)+\"/model_of_\"+p[i]+\".pkl\"\n",
    "        gmm_pickle = open(filepath, 'rb')\n",
    "        gmm_model = pickle.load(gmm_pickle)\n",
    "        gmm_models[p[i]] = gmm_model\n",
    "    print(test(p,timit_df_test,gmm_models))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3) MFCC_Delta with Energy Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/shivam/anaconda3/lib/python3.6/site-packages/sklearn/base.py:311: UserWarning: Trying to unpickle estimator GaussianMixture from version 0.20.0 when using version 0.19.1. This might lead to breaking code or invalid results. Use at your own risk.\n",
      "  UserWarning)\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "gmm_models = dict()\n",
    "for i in range(0,40):\n",
    "    filepath = \"./models/mfcc_delta/with_energy_coeff/64/model_of_\"+p[i]+\".pkl\"\n",
    "    gmm_pickle = open(filepath, 'rb')\n",
    "    gmm_model = pickle.load(gmm_pickle)\n",
    "    gmm_models[p[i]] = gmm_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1878138422707346\n"
     ]
    }
   ],
   "source": [
    "len_p = len(p)\n",
    "classified = 0\n",
    "misclassified = 0\n",
    "for i in range(0,length):\n",
    "   # print(str(i)+\" \"+str(length))\n",
    "    x = timit_df_test['features'][i]\n",
    "    label = timit_df_test['labels'][i]\n",
    "    test_data = []\n",
    "    test_data.append(x)\n",
    "    result = dict()\n",
    "    for j in range(0,len_p):\n",
    "        gmm_model = gmm_models[p[j]]\n",
    "        result[p[j]] = gmm_model.score_samples(test_data)\n",
    "    #print(max(result, key=result.get)+\" \"+label)\n",
    "    if(max(result, key=result.get) == label):\n",
    "        classified = classified+1\n",
    "    else:\n",
    "        misclassified = misclassified+1\n",
    "        \n",
    "print(classified/(classified+misclassified))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4) MFCC_Delta without Energy Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/shivam/anaconda3/lib/python3.6/site-packages/sklearn/base.py:311: UserWarning: Trying to unpickle estimator GaussianMixture from version 0.20.0 when using version 0.19.1. This might lead to breaking code or invalid results. Use at your own risk.\n",
      "  UserWarning)\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "gmm_models = dict()\n",
    "for i in range(0,40):\n",
    "    filepath = \"./models/mfcc_delta/without_energy_coeff/64/model_of_\"+p[i]+\".pkl\"\n",
    "    gmm_pickle = open(filepath, 'rb')\n",
    "    gmm_model = pickle.load(gmm_pickle)\n",
    "    gmm_models[p[i]] = gmm_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1436633751051676\n"
     ]
    }
   ],
   "source": [
    "len_p = len(p)\n",
    "classified = 0\n",
    "misclassified = 0\n",
    "for i in range(0,length):\n",
    "    x = timit_df_test['features'][i]\n",
    "    x = np.delete(x,[0,14],axis = 0)\n",
    "    label = timit_df_test['labels'][i]\n",
    "    test_data = []\n",
    "    test_data.append(x)\n",
    "    result = dict()\n",
    "    for j in range(0,len_p):\n",
    "        gmm_model = gmm_models[p[j]]\n",
    "        result[p[j]] = gmm_model.score_samples(test_data)\n",
    "    #print(max(result, key=result.get)+\" \"+label)\n",
    "        if(max(result, key=result.get) == label):\n",
    "            classified = classified+1\n",
    "        else:\n",
    "            misclassified = misclassified+1\n",
    "            \n",
    "print(classified/(classified+misclassified))        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": false
   },
   "source": [
    "# 5) MFCC_Delta_Delta with Energy Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "components = [2,4,8,16,32,64,128,256]\n",
    "for comp in components:\n",
    "    gmm_models = dict()\n",
    "    for i in range(0,40):\n",
    "        filepath = \"./models/mfcc/without_energy_coeff/\"+str(comp)+\"/model_of_\"+p[i]+\".pkl\"\n",
    "        gmm_pickle = open(filepath, 'rb')\n",
    "        gmm_model = pickle.load(gmm_pickle)\n",
    "        gmm_models[p[i]] = gmm_model\n",
    "       # print(test(p,timit_df_test,gmm_models))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.19226409245892928\n"
     ]
    }
   ],
   "source": [
    "len_p = len(p)\n",
    "classified = 0\n",
    "misclassified = 0\n",
    "for i in range(0,length):\n",
    "    x = timit_df_test['features'][i]\n",
    "    label = timit_df_test['labels'][i]\n",
    "    test_data = []\n",
    "    test_data.append(x)\n",
    "    result = dict()\n",
    "    for j in range(0,len_p):\n",
    "        gmm_model = gmm_models[p[j]]\n",
    "        result[p[j]] = gmm_model.score_samples(test_data)\n",
    "    #print(max(result, key=result.get)+\" \"+label)\n",
    "    if(max(result, key=result.get) == label):\n",
    "        classified = classified+1\n",
    "    else:\n",
    "        misclassified = misclassified+1\n",
    "\n",
    "print(classified/(classified+misclassified))        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6) MFCC_Delta_Delta without Energy Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "gmm_models = dict()\n",
    "for i in range(0,40):\n",
    "    filepath = \"./models/mfcc_delta_delta/without_energy_coeff/64/model_of_\"+p[i]+\".pkl\"\n",
    "    gmm_pickle = open(filepath, 'rb')\n",
    "    gmm_model = pickle.load(gmm_pickle)\n",
    "    gmm_models[p[i]] = gmm_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.17335385024133199\n"
     ]
    }
   ],
   "source": [
    "len_p = len(p)\n",
    "classified = 0\n",
    "misclassified = 0\n",
    "for i in range(0,length):\n",
    "    x = timit_df_test['features'][i]\n",
    "    x = np.delete(x,[0,14,27],axis = 0)\n",
    "    label = timit_df_test['labels'][i]\n",
    "    test_data = []\n",
    "    test_data.append(x)\n",
    "    result = dict()\n",
    "    for j in range(0,len_p):\n",
    "        gmm_model = gmm_models[p[j]]\n",
    "        result[p[j]] = gmm_model.score_samples(test_data)\n",
    "    #print(max(result, key=result.get)+\" \"+label)\n",
    "    if(max(result, key=result.get) == label):\n",
    "        classified = classified+1\n",
    "    else:\n",
    "        misclassified = misclassified+1\n",
    "        \n",
    "print(classified/(classified+misclassified))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Phoneme error rate\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = np.array(timit_df_test[\"labels\"].tolist())\n",
    "p = list(set(labels))\n",
    "p.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "gmm_models = dict()\n",
    "for i in range(0,40):\n",
    "    filepath = \"./models/mfcc/without_energy_coeff/64/model_of_\"+p[i]+\".pkl\"\n",
    "    gmm_pickle = open(filepath, 'rb')\n",
    "    gmm_model = pickle.load(gmm_pickle)\n",
    "    gmm_models[p[i]] = gmm_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predicted_truth(p,length,a,s):\n",
    "    len_p = len(p)\n",
    "    for i in range(0,length):\n",
    "        x = a['features'][i]\n",
    "        test_data = []\n",
    "        test_data.append(x)\n",
    "        result = dict()\n",
    "        for j in range(0,len_p):\n",
    "            gmm_model = gmm_models[p[j]]\n",
    "            result[p[j]] = gmm_model.score_samples(test_data)\n",
    "    #print(max(result, key=result.get)+\" \"+label)\n",
    "        b = max(result, key=result.get)\n",
    "        fo = open(s,\"a+\")\n",
    "        fo.write(b+\" \")\n",
    "    fo.write(\"\\n\")\n",
    "    fo.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,1680):\n",
    "    a = timit_df_test.loc[timit_df_test['ids'] == i]\n",
    "    length = a.shape[0]\n",
    "    a = a.reset_index(drop=True)\n",
    "    predicted_truth(p,length,a,\"predicted_truth\")"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}