kmc.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import matplotlib.pyplot as plt \n",
    "import pandas as pd \n",
    "import librosa "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = np.load('X_train.npy')\n",
    "y_train = np.load('y_train.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train test split \n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_part, y_train, y_part = train_test_split(X_train, y_train, test_size=0.2, random_state=42)\n",
    "X_valid, X_test, y_valid, y_test = train_test_split(X_part, y_part, test_size=0.5, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of clusters \n",
    "K = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def assign_centroid(X_train, centroids, distance_type = \"l2\"):\n",
    "\n",
    "    m = X_train.shape[0]\n",
    "    idx = np.zeros((m,))\n",
    "    \n",
    "    if distance_type == \"l2\":\n",
    "        for i in range(m):\n",
    "            min_idx = np.argmin(np.linalg.norm(centroids - X_train[i], axis=1))\n",
    "            idx[i] = min_idx\n",
    "        return idx\n",
    "    elif distance_type == \"inf\":\n",
    "        for i in range(m):\n",
    "            min_idx = np.argmin(np.linalg.norm(centroids - X_train[i], axis=1, ord=\"inf\"))\n",
    "            idx[i] = min_idx\n",
    "        return idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_centroid(X_train, idx, K):\n",
    "    m, n = X_train.shape\n",
    "    centroids = np.zeros((K, n))\n",
    "\n",
    "    for i in range(K):\n",
    "        curr_len = len(X_train[idx == i])\n",
    "        if curr_len == 0:\n",
    "            centroids[i] = X_train[np.random.choice(m, 1)]\n",
    "        else :\n",
    "            centroids[i] = np.sum(X_train[idx == i], axis=0)/curr_len\n",
    "\n",
    "    return centroids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(X_train, idx, centroids):\n",
    "    m = X_train.shape[0]\n",
    "    K = centroids.shape[0]\n",
    "    loss = 0\n",
    "    for i  in range(K):\n",
    "        loss += np.sum((X_train[idx == i] - centroids[i])**2)\n",
    "\n",
    "    return loss/m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "losses = []\n",
    "centroids_hist = []\n",
    "\n",
    "for i in range(10):   ## Using 10 random Initializations corrs. to 10 independent runs of KMeans\n",
    "    c0, c1, c2 = np.random.choice(X_train.shape[0], 3)\n",
    "    centroids = X_train[[c0,c1,c2]]\n",
    "    \n",
    "    for iter in range(20):    ## Iterating over the dataset 20 times\n",
    "        idx = assign_centroid(X_train, centroids)\n",
    "        centroids = update_centroid(X_train, idx, 3)\n",
    "    loss = compute_cost(X_train, idx, centroids)\n",
    "    losses.append(loss)\n",
    "    centroids_hist.append(centroids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = np.argmin(losses) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "centroid = centroids_hist[index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving the centroids "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('saved_model/kmc/centroid', centroid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6430921052631579\n"
     ]
    }
   ],
   "source": [
    "# finding out the cluster for music \n",
    "total = 0 \n",
    "correct = 0 \n",
    "\n",
    "for i in range(X_valid.shape[0]):\n",
    "    if(y_valid[i][0] != 1):\n",
    "        continue \n",
    "    else : \n",
    "        total += 1 \n",
    "        x = X_valid[i] \n",
    "        d0 = np.linalg.norm(centroid[0] - x)\n",
    "        d1 = np.linalg.norm(centroid[1] - x)\n",
    "        d2 = np.linalg.norm(centroid[2] - x)\n",
    "        if d2 <= d0 and d2 <= d1 : \n",
    "            correct += 1 \n",
    "        \n",
    "print(correct/total)\n",
    "\n",
    "# We get the best accuracy for music = centroid 2 cluster \n",
    "# for music = centroid 0, accuracy = 0\n",
    "# music = centroid 1, accuracy = 0.36\n",
    "# music = centroid 2, accuracy = 0.64\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7028571428571428\n"
     ]
    }
   ],
   "source": [
    "# finding out the cluster for speech \n",
    "total = 0 \n",
    "correct = 0 \n",
    "\n",
    "for i in range(X_valid.shape[0]):\n",
    "    if(y_valid[i][1] != 1):\n",
    "        continue \n",
    "    else : \n",
    "        total += 1 \n",
    "        x = X_valid[i] \n",
    "        d0 = np.linalg.norm(centroid[0] - x)\n",
    "        d1 = np.linalg.norm(centroid[1] - x)\n",
    "        d2 = np.linalg.norm(centroid[2] - x)\n",
    "        if d1 <= d2 and d1 <= d0 : \n",
    "            correct += 1 \n",
    "        \n",
    "print(correct/total)\n",
    "\n",
    "# We get the best accuracy for speech = centroid 1 cluster \n",
    "# for speech = centroid 0, accuracy = 0\n",
    "# speech = centroid 1, accuracy = 0.70\n",
    "# speech = centroid 2, accuracy = 0.29\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above analysis we get that the music is the centroid 2, speech is the centroid 1 and silence is the centroid 0 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7759290072102052\n"
     ]
    }
   ],
   "source": [
    "total = 0 \n",
    "correct = 0 \n",
    "\n",
    "for i in range(X_test.shape[0]):\n",
    "    total += 1 \n",
    "    x = X_test[i] \n",
    "    d0 = np.linalg.norm(centroid[0] - x)\n",
    "    d1 = np.linalg.norm(centroid[1] - x)\n",
    "    d2 = np.linalg.norm(centroid[2] - x)\n",
    "    \n",
    "    if y_test[i][0] == 1:\n",
    "        if d2 <= d1 and d2 <= d0 : \n",
    "            correct += 1 \n",
    "        \n",
    "    if y_test[i][1] == 1:\n",
    "        if d1 <= d0 and d1 <= d2 : \n",
    "            correct += 1 \n",
    "\n",
    "    if y_test[i][2] == 1:\n",
    "        if d0 <= d1 and d0 <= d2 : \n",
    "            correct += 1 \n",
    "\n",
    "print(correct/total)\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "5cc71acb9da8a628b75f40db50cc39e280e3dc99ec6abc765b4a72693f1bb475"
  },
  "kernelspec": {
   "display_name": "Python 3.6.13 64-bit ('MLSP': conda)",
   "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.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}