Extending_K_means.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.7.3"
    },
    "colab": {
      "name": "Extending_K-means.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sayarghoshroy/Extending_K-means/blob/master/Extending_K_means.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xaYR4HAEX8H7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Extending K-means Clustering Algorithm"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BnML0iNKX8IS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.colors as color"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EmpMFLnnX8In",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Two Lines: (a) y = x\n",
        "#            (b) y = (-1).x\n",
        "# We'll have n_a points on line_(a) and (1000 - n_a) = n_b points on line_(b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5oxCfgpxX8I9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_a = 500 # to ensure uniform distribution on the 'x'\n",
        "n_b = 1000 - n_a\n",
        "\n",
        "x_a = (np.random.random(n_a) - np.ones(n_a) * 0.5) * 10\n",
        "x_b = (np.random.random(n_b) - np.ones(n_b) * 0.5) * 10\n",
        "y_a = x_a\n",
        "y_b = (-1) * x_b\n",
        "# The implementation is perfectly generic, any valid equation of the form 'y = m.x + c' can be used here"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S2LVv0ULX8JK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "points_a = [ [x_a[i], y_a[i]] for i in range(n_a)]\n",
        "points_b = [ [x_b[i], y_b[i]] for i in range(n_b)]\n",
        "all_points = points_a + points_b"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Y2zbavwX8JZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Partitioning the data into 2 random subsets\n",
        "set_A = []\n",
        "set_B = []\n",
        "for i in range(n_a + n_b):\n",
        "    toss = np.random.random()\n",
        "    if toss > 0.5:\n",
        "        set_A.append(all_points[i])\n",
        "    else:\n",
        "        set_B.append(all_points[i])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O8R3kDZzX8Jm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_line(points):\n",
        "    # getting the equation of a straight line for the subset of points\n",
        "    eigvals, eigvecs = np.linalg.eig(np.cov(np.asarray(points).T))\n",
        "    best_index = np.flip(np.argsort(eigvals))[0]\n",
        "    vec = eigvecs[best_index]\n",
        "    mean = np.mean(np.asarray(points), axis = 1)\n",
        "    params = {'direction': vec, 'centre': mean}\n",
        "    # Expressing equation in form y = mx + c\n",
        "    m = vec[1] / vec[0]\n",
        "    c = mean[1] - m * mean[0]\n",
        "    return {'m': m, 'c': c}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "immNHAC7X8Jv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def distance(line, point):\n",
        "    # compute distance from point to the line\n",
        "    # line is a dictionary of the form {'m': _, 'c': _}\n",
        "    return np.abs(line['c'] + line['m'] * point[0] - point[1]) / np.sqrt(1 + np.power(line['m'], 2))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dcyFKS-aX8J5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "num_iter = 0\n",
        "max_iter = 10000\n",
        "\n",
        "while num_iter < max_iter:\n",
        "    num_iter += 1\n",
        "    if(len(set_A) == 0 or len(set_B) == 0):\n",
        "        # all points have been placed into a single cluster\n",
        "        break\n",
        "    \n",
        "    line_A = get_line(set_A)\n",
        "    line_B = get_line(set_B)\n",
        "    # fitting staright lines for subsets A and B\n",
        "    new_A = []\n",
        "    new_B = []\n",
        "    \n",
        "    for point in all_points:\n",
        "        dist_A = distance(line_A, point)\n",
        "        dist_B = distance(line_B, point)\n",
        "        \n",
        "        # re-assigning points based on distance from their representative line\n",
        "        if dist_A < dist_B:\n",
        "            new_A.append(point)\n",
        "        else:\n",
        "            new_B.append(point)\n",
        "    \n",
        "    if set_A == new_A or set_A == new_B:\n",
        "        # convergence achieved\n",
        "        # set_A == new_B takes care of cluster renaming\n",
        "        break\n",
        "    \n",
        "    set_A = new_A\n",
        "    set_B = new_B"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xcxQ_TCZX8KJ",
        "colab_type": "code",
        "colab": {},
        "outputId": "807b82b9-09da-46b5-a439-9586f9179db6"
      },
      "source": [
        "# Plotting the results of the clustering\n",
        "plt.figure()\n",
        "plt.title('Clustering using an extended K-means algorithm')\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('y')\n",
        "plt.scatter([i[0] for i in set_A], [i[1] for i in set_A], color = 'red', label = 'Red Cluster')\n",
        "plt.scatter([i[0] for i in set_B], [i[1] for i in set_B], color = 'blue', label = 'Blue Cluster')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOn5QCzbX8Ka",
        "colab_type": "code",
        "colab": {},
        "outputId": "6401c541-e3e7-45df-d3c9-2a44568384bf"
      },
      "source": [
        "print(\"The final straight lines found:\")\n",
        "line_red = get_line(set_A)\n",
        "line_blue = get_line(set_B)\n",
        "print(line_red)\n",
        "print(line_blue)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The final straight lines found:\n",
            "{'m': -1.0000064843373864, 'c': 0.5822311646342548}\n",
            "{'m': 1.0, 'c': 0.0}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s7X5hMdUX8Kt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The number of iterations needed for convergence vary greatly\n",
        "# with the random creation of set_A and set_B from all_points"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AWktlTYNX8K6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Thank You ^_^"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}