mainv2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import torch \n",
    "import torch.nn as nn\n",
    "\n",
    "from torch.autograd import Variable\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# Hyper Parameters\n",
    "\n",
    "input_size = 13\n",
    "hidden_size = 60\n",
    "num_layers = 2\n",
    "num_classes = 2\n",
    "batch_size = 1\n",
    "num_epochs = 2\n",
    "learning_rate = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from python_speech_features import mfcc\n",
    "from python_speech_features import delta\n",
    "from python_speech_features import logfbank\n",
    "import scipy.io.wavfile as wav\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def audio_to_mfcc(fileurl):\n",
    "    rate, sig = wav.read(fileurl)\n",
    "    mfcc_feat = mfcc(sig,rate)\n",
    "#d_mfcc_feat = delta(mfcc_feat, 2)\n",
    "#fbank_feat = logfbank(sig,rate)\n",
    "\n",
    "    return mfcc_feat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_layers, num_classes):\n",
    "        super(RNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.num_layers = num_layers\n",
    "        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)\n",
    "        self.fc = nn.Linear(hidden_size, num_classes)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        # Set initial states \n",
    "        h0 = Variable(torch.zeros(self.num_layers, x.size(0), self.hidden_size)) \n",
    "        c0 = Variable(torch.zeros(self.num_layers, x.size(0), self.hidden_size))\n",
    "        \n",
    "        # Forward propagate RNN\n",
    "        out, _ = self.lstm(x, (h0, c0))  \n",
    "        \n",
    "       # print (out.size())\n",
    "        # Decode hidden state of last time step\n",
    "        out = self.fc(out[:, -1, :])  \n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# create a many to one LSTM , just take last output timestep as output \n",
    "rnn = RNN(input_size, hidden_size, num_layers, num_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Loss and Optimizer\n",
    "#criterion = nn.NLLLoss()\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "\n",
    "optimizer = torch.optim.Adam(rnn.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6428278684616089\n",
      "0.7358896732330322\n",
      "0.475163996219635\n",
      "0.7055583000183105\n",
      "0.2999621033668518\n",
      "0.5358971953392029\n",
      "0.13674023747444153\n",
      "0.3297620117664337\n",
      "0.047070927917957306\n",
      "0.16023163497447968\n",
      "0.01566590927541256\n",
      "0.06110032647848129\n",
      "0.005697252228856087\n",
      "0.018987460061907768\n",
      "0.0023355071898549795\n",
      "0.005547746084630489\n",
      "0.001067026169039309\n",
      "0.0017001732485368848\n",
      "0.0005294483271427453\n",
      "0.0005983618320897222\n"
     ]
    }
   ],
   "source": [
    "mfcc1 = audio_to_mfcc('/home/saurabh/Documents/audio_classification/data/lizzie.wav')\n",
    "#print(mfcc1.shape)\n",
    "mfcc2 = audio_to_mfcc('/home/saurabh/Documents/audio_classification/data/boy.wav')\n",
    "#print(mfcc2.shape)\n",
    "\n",
    "\n",
    "\n",
    "temp =  mfcc1[ : , np.newaxis , :]\n",
    "temp2=  mfcc2[ : , np.newaxis , :]\n",
    "\n",
    "#print(temp2.shape)\n",
    "input_var = Variable(torch.Tensor(temp))\n",
    "input2_var = Variable(torch.Tensor(temp2))\n",
    "\n",
    "for epoch in range(10):\n",
    "    outputs = rnn(input_var)\n",
    "    outputs2= rnn(input2_var)\n",
    "   # print(outputs[999])\n",
    "\n",
    "    t1=outputs[999]\n",
    "    t1=t1.unsqueeze(0)\n",
    "  #  print(t1)\n",
    "    \n",
    "    t2=outputs2[998]\n",
    "    t2=t2.unsqueeze(0)\n",
    "  #  print(t2)\n",
    "                    \n",
    "    #final_output = Variable( t1 , requires_grad =True)\n",
    "    #final_output2= Variable(  t2 , requires_grad =True)\n",
    "    \n",
    "   # final_output.unsqueeze(0)\n",
    "   # final_output2.unsqueeze(0)\n",
    "    \n",
    "   # final_output_numpy=final_output.data.numpy()[np.newaxis,:]\n",
    "   # final_output = torch.from_numpy(final_output_numpy)\n",
    "    \n",
    "   # final_output_numpy2=final_output2.data.numpy()[np.newaxis,:]\n",
    "   # final_output2 = torch.from_numpy(final_output_numpy2)\n",
    "    \n",
    "#print(final_output_numpy.shape)\n",
    "\n",
    "   # print(final_output.size())\n",
    "\n",
    "    label = Variable(torch.LongTensor([0]))\n",
    "    label2 = Variable(torch.LongTensor([1]))\n",
    "#print (label.size())\n",
    "    loss = criterion( t1, label)\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    print(loss.data[0])\n",
    "    \n",
    "    loss2=criterion( t2, label2)\n",
    "    optimizer.zero_grad()\n",
    "    loss2.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    print(loss2.data[0])\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable containing:\n",
      " 0.1091\n",
      "-0.2374\n",
      "[torch.FloatTensor of size 2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# testing trained network \n",
    "\n",
    "mfcc3 = audio_to_mfcc('/home/saurabh/Documents/audio_classification/test/boy.wav')\n",
    "temp3 =  mfcc3[ : , np.newaxis , :]\n",
    "\n",
    "input_var3 = Variable(torch.Tensor(temp3))\n",
    "\n",
    "outputs3 = rnn(input_var3)\n",
    "\n",
    "print(outputs3[998])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:flowers]",
   "language": "python",
   "name": "conda-env-flowers-py"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}