K-means.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.   4. ]\n",
      " [ 1.7  2.8]\n",
      " [ 7.   8. ]\n",
      " [ 8.6  8. ]\n",
      " [ 3.4  1.5]\n",
      " [ 9.  11. ]]\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.array(\n",
    "    [[2, 4],\n",
    "     [1.7, 2.8],\n",
    "     [7, 8],\n",
    "     [8.6, 8],\n",
    "     [3.4, 1.5],\n",
    "     [9, 11]]\n",
    ")\n",
    "print(X)\n",
    "plt.scatter(X[:, 0], X[:, 1])\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "outputs": [],
   "source": [
    "# Euclidean distance between 2 points.\n",
    "def euclidean_distance(point1, point2):\n",
    "    distance = math.sqrt((point2[0] - point1[0]) ** 2 + (point2[1] - point1[1]) ** 2)\n",
    "    return abs(distance)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "outputs": [],
   "source": [
    "# Assign clusters based on centroids passed. It returns a dictionary of cluster and its associated points\n",
    "def assign_clusters(X, centroids):\n",
    "    clusters_map = {}\n",
    "    for point in X:\n",
    "        distance_points_centroids = []\n",
    "        for centroid in centroids:\n",
    "            distance_points_centroids.append(euclidean_distance(centroid, point))\n",
    "        # Returns the index of the smallest arg which here is the cluster.\n",
    "        clusters_map.setdefault(np.argmin(distance_points_centroids), []).append(point)\n",
    "    return clusters_map"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "outputs": [],
   "source": [
    "# Update the centroid value based on average distance between points.\n",
    "def update_centroid(clusters_map, number_clusters):\n",
    "    new_centroids = []\n",
    "    for c in range(number_clusters):\n",
    "        # Calulate the mean point based on points assigned to that cluster\n",
    "        cluster_mean = np.average(clusters_map[c], axis=0)\n",
    "        new_centroids.append(cluster_mean)\n",
    "    return new_centroids"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "outputs": [],
   "source": [
    "# Utility function to stop the iteration if the assignment does not change.\n",
    "def compare_exact(first, second):\n",
    "    if first.keys() != second.keys():\n",
    "        return False\n",
    "    return all(np.array_equal(first[key], second[key]) for key in first)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial centroid [[2.34092737 4.9508841 ]\n",
      " [4.83174042 2.75945251]]\n",
      "-------------------------Iteration 0 ---------------------------\n",
      "updated centroid [array([4.925, 6.45 ]), array([6.  , 4.75])]\n",
      "cluster[0] - [array([2., 4.]), array([1.7, 2.8]), array([7., 8.]), array([ 9., 11.])]\n",
      "cluster[1] - [array([8.6, 8. ]), array([3.4, 1.5])]\n",
      "-----------------------------------------------------\n",
      "-------------------------Iteration 1 ---------------------------\n",
      "updated centroid [array([6.65, 7.75]), array([2.55, 2.15])]\n",
      "cluster[0] - [array([2., 4.]), array([7., 8.]), array([8.6, 8. ]), array([ 9., 11.])]\n",
      "cluster[1] - [array([1.7, 2.8]), array([3.4, 1.5])]\n",
      "-----------------------------------------------------\n",
      "-------------------------Iteration 2 ---------------------------\n",
      "updated centroid [array([8.2, 9. ]), array([2.36666667, 2.76666667])]\n",
      "cluster[1] - [array([2., 4.]), array([1.7, 2.8]), array([3.4, 1.5])]\n",
      "cluster[0] - [array([7., 8.]), array([8.6, 8. ]), array([ 9., 11.])]\n",
      "-----------------------------------------------------\n",
      "-------------------------Iteration 3 ---------------------------\n",
      "Clusters are same as before, so exiting\n"
     ]
    }
   ],
   "source": [
    "centroids = 10 * np.random.random((2, 2))\n",
    "print(\"Initial centroid {}\".format(centroids))\n",
    "cluster_previous = {}\n",
    "for i in range(10):\n",
    "    print(\"-------------------------Iteration {} ---------------------------\".format(i))\n",
    "    clusters = assign_clusters(X, centroids)\n",
    "    if compare_exact(cluster_previous, clusters):\n",
    "        print(\"Clusters are same as before, so exiting\")\n",
    "        break\n",
    "    cluster_previous = clusters\n",
    "    centroids = update_centroid(clusters, 2)\n",
    "    print(\"updated centroid {}\".format(centroids))\n",
    "    for key in clusters:\n",
    "        print(\"cluster[{}] - {}\".format(key, clusters[key]))\n",
    "    print(\"-----------------------------------------------------\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "outputs": [],
   "source": [
    "# Create a dataframe from clusters for easy manipulation of data.\n",
    "df = pd.DataFrame([(key, var) for (key, L) in clusters.items() for var in L], columns=['label', 'point'])\n",
    "labels = df['label'].unique().tolist()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1080x720 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15, 10))\n",
    "for i in labels:\n",
    "    # filter the points by clusters\n",
    "    points = df[df['label'] == i]['point'].values\n",
    "    # Use zip operation to unpack the points\n",
    "    plt.scatter(*zip(*points), s=100, label=i)\n",
    "plt.scatter(*zip(*centroids), s=120, color='g', label='centroid')\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}