ML_Lab8.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ML_Lab8.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPz5O4Mr3nDolc510c11iqB",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JARACH-209/AI-ML_Lab/blob/master/ML_Lab8.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hg8YhrNMmL0J"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sklearn.datasets import load_iris\n",
        "%matplotlib inline\n",
        "\n",
        "X,Y = load_iris(return_X_y = True)"
      ],
      "execution_count": 186,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3aDPsdcwSL_L"
      },
      "source": [
        "class SOM:\n",
        "    def _init_(self):\n",
        "        self.weights = None\n",
        "        self.score_per_epoch = {}\n",
        "        self.learning_rate = 0.1\n",
        "        self.best_weights = None\n",
        "        self.classes = None\n",
        "\n",
        "    def euclidean_distance(self, p1, p2):   \n",
        "        return np.linalg.norm(p1-p2)\n",
        "    \n",
        "    def weight_updation(self, weights, distances, point):\n",
        "        # best_neuron = np.argmin(weights)    #index of closest neuron\n",
        "        temp = np.array(distances).argsort().argsort()\n",
        "        ranks = [(j+1) for j in temp]\n",
        "        for i in range(len(weights)):\n",
        "            weights[i] += (self.learning_rate/ranks[i]**2)*(point - weights[i])\n",
        "            # Damped Learning rate follows inverse square law\n",
        "        return weights\n",
        "\n",
        "    def predict(self,x):\n",
        "        y = np.zeros(len(x)).astype(int)\n",
        "        distances = np.zeros(self.classes)\n",
        "        for j in range(len(x)): \n",
        "            for i in range(len(self.best_weights)):\n",
        "                distances[i] = self.euclidean_distance(self.best_weights[i],x[j])\n",
        "            y[j] = np.argmin(distances)\n",
        "        return y\n",
        "    def process_predict(self,x):\n",
        "        y = np.zeros(len(x)).astype(int)\n",
        "        distances = np.zeros(self.classes)\n",
        "        for j in range(len(x)): \n",
        "            for i in range(len(self.weights)):\n",
        "                distances[i] = self.euclidean_distance(self.weights[i],x[j])\n",
        "            y[j] = np.argmin(distances)\n",
        "        return y\n",
        "\n",
        "    def fit(self, X, learning_rate = 0.01, iterations = 100,classes = 0):\n",
        "        self.learning_rate = learning_rate\n",
        "        max_sscore = -1\n",
        "\n",
        "        # Assinging random datapoint in train set as weights to neurons\n",
        "        if classes == 0:\n",
        "            neurons = len(X[0])**2 \n",
        "        else: neurons = classes\n",
        "        self.classes = neurons\n",
        "        score_per_epoch = {}\n",
        "        self.weights = np.zeros((classes,len(X[0])))\n",
        "        while True:\n",
        "            random_indexes = np.random.randint(len(X),size=classes).astype(float)\n",
        "            if len(set(random_indexes))==len(random_indexes):\n",
        "                break\n",
        "        p=0\n",
        "        for each in random_indexes:\n",
        "            self.weights[p] = X[int(each)]\n",
        "            p+=1\n",
        "        self.best_weights = self.weights\n",
        "\n",
        "        score_per_epoch = {}\n",
        "        for epoch in range(iterations):\n",
        "            print(\"Iteration \",epoch)\n",
        "            for point in X:\n",
        "                distances = np.zeros(len(X[0]))\n",
        "                old_weights = self.weights\n",
        "                for i in range(len(self.weights)):\n",
        "                    distances[i] = self.euclidean_distance(self.weights[i],point)\n",
        "                self.weights = self.weight_updation(self.weights, distances, point)\n",
        "            sscore = silhouette_score(X,self.process_predict(X))\n",
        "            score_per_epoch[epoch] = sscore\n",
        "            if sscore < max_sscore:\n",
        "                self.best_weights = self.weights \n",
        "        self.score_per_epoch = score_per_epoch\n"
      ],
      "execution_count": 293,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DecO2kChafZv"
      },
      "source": [
        "import math\n",
        "class K_Means():\n",
        "    def __init__(self,k=1,iterations = 100,elbow=False,k_max=10):\n",
        "        self.k = k\n",
        "        self.iterations = iterations\n",
        "        self.elbow_flag = elbow\n",
        "        self.k_max = k_max\n",
        "        self.best_k = None\n",
        "        self.elbow_reductions = None\n",
        "        self.k_centroids = None\n",
        "        self.y = None\n",
        "        self.variances = None\n",
        "\n",
        "    def final_centroids(self):\n",
        "        return np.array(self.k_centroids)\n",
        "\n",
        "    def get_variance(self,X,y,k_centroids):\n",
        "        # sum of squares of distances between points and their centroids\n",
        "        temp = 0\n",
        "        for j in range(len(k_centroids)):\n",
        "            for point,cluster in zip(X,y):\n",
        "                if cluster == j:\n",
        "                    temp += self.euclidean_distance(point,k_centroids[j])**2 \n",
        "        return math.sqrt(temp)\n",
        "\n",
        "    def euclidean_distance(self, p1, p2):\n",
        "        # math.dist can gives distance between points of any dimensionality \n",
        "        # Unfortunately Colab works on python3.6 and dist is in 3.8\n",
        "        #return math.dist(p1,p2)     \n",
        "        return np.linalg.norm(p1-p2)\n",
        "\n",
        "    def get_centroids(self,X,y,k):\n",
        "        k_centroids = []\n",
        "        cluster_indexes = []\n",
        "        for j in range(k):\n",
        "            cluster_indexes.append([i for i in range(len(y)) if y[i] == j])\n",
        "        # Finding means of all the clusters\n",
        "        # Summing all the coordinates in all the dimensions having same cluster \n",
        "        # label and taking a mean\n",
        "        for cluster in cluster_indexes:\n",
        "            cluster_mean = 0\n",
        "            for i in cluster:\n",
        "                 cluster_mean += X[i]\n",
        "            num = len(cluster) if len(cluster) >0 else 1\n",
        "            k_centroids.append(np.array(cluster_mean/num))\n",
        "            \n",
        "            # k = number of clusters and their labels as well.\n",
        "            # Taking mean of all the points having same cluster label \n",
        "            # To get the mean coordinates find the mean of all the dimensional coordinates\n",
        "            # E.g -> [x,y,z] otherwise mean will be a number and for distance dims must be equal\n",
        "            # experession below will give direct mean instead of coordinates.\n",
        "        # k_centroids.append((np.mean([point for point,cluster in zip(X,y) if cluster == j])))\n",
        "        return k_centroids\n",
        "\n",
        "    def get_cluster(self,X,k_centroids):\n",
        "        y = np.zeros(len(X),dtype=int)\n",
        "        min_dist = None\n",
        "        cluster = 0\n",
        "        dist = None\n",
        "        for i in range(len(X)):\n",
        "            \n",
        "            min_dist = self.euclidean_distance(X[i],k_centroids[0])\n",
        "            cluster = 0\n",
        "            for j in range(len(k_centroids)):\n",
        "                dist = self.euclidean_distance(X[i],k_centroids[j])\n",
        "                if dist < min_dist:\n",
        "                    min_dist = dist\n",
        "                    cluster = j\n",
        "            y[i] = int(cluster)\n",
        "        return y\n",
        "\n",
        "    def clustering(self,X, k):\n",
        "        min_variance = None\n",
        "        variance = None\n",
        "        best_centroids = None\n",
        "        for i in range(self.iterations):\n",
        "            y = np.zeros(len(X),dtype=int)\n",
        "            k_centroids = []\n",
        "            variance = []\n",
        "\n",
        "            # intializes distinct random k points from dataset\n",
        "            while True:\n",
        "                rand_points = np.random.randint(len(X),size=(k))\n",
        "                if len(set(rand_points)) == len(rand_points):\n",
        "                    break\n",
        "            for points in rand_points:\n",
        "                k_centroids.append(X[points])\n",
        "            min_variance = self.get_variance(X,y,k_centroids)\n",
        "            check_count = 0\n",
        "            # Clustering Loop\n",
        "            while True:\n",
        "                check_count += 1\n",
        "                # Prevents the loop from going to infinity in any possible case\n",
        "                if check_count > len(X)*10:\n",
        "                    raise Exception(\"Error in Cluster Loop. Infite Looping. Run again.\") \n",
        "                \n",
        "                # cluster labeling with given centroids\n",
        "                y = self.get_cluster(X,k_centroids) \n",
        "                \n",
        "                # Generates new centroids by taking mean of all labels\n",
        "                new_centroids = self.get_centroids(X,y,k)\n",
        "                if np.array_equal(k_centroids,new_centroids):\n",
        "                    variance = self.get_variance(X,y,new_centroids)\n",
        "                    break\n",
        "                else:\n",
        "                    k_centroids = new_centroids\n",
        "\n",
        "            variance = self.get_variance(X,y,new_centroids)\n",
        "            if variance < min_variance:\n",
        "                min_variance = variance\n",
        "                best_centroids = k_centroids\n",
        "        return best_centroids,min_variance\n",
        "\n",
        "    def elbow_clustering(self,X):\n",
        "        var_reductions = np.zeros(self.k_max+1)\n",
        "        variance = None\n",
        "        variances = []\n",
        "        for i in range(1,int(self.k_max+1)):\n",
        "            _, variance = self.clustering(X,i)\n",
        "            variances.append(variance)\n",
        "        for i in range(len(variances)-1):\n",
        "            var_reductions[i+1] = abs(variances[i+1]-variances[i])\n",
        "        self.elbow_reductions = var_reductions\n",
        "        self.variances = variances\n",
        "        return var_reductions\n",
        "    \n",
        "    def predict(self,X):\n",
        "        y = self.get_cluster(X,self.k_centroids)\n",
        "        return np.array(y).astype(int)\n",
        "\n",
        "    def fit(self, X):\n",
        "        best_k = None\n",
        "        k = self.k\n",
        "        centroids = []\n",
        "        y = []\n",
        "        if self.elbow_flag:\n",
        "\n",
        "            #Gives variances for all the values of K\n",
        "            #implement automation later\n",
        "            self.elbow_clustering(X)\n",
        "\n",
        "        else:\n",
        "            centroids, min_var = self.clustering(X,k) #final centroids are stored globally\n",
        "            y = self.get_cluster(X, centroids)\n",
        "            self.k_centroids = centroids\n",
        "            self.y = y\n",
        "            return y\n",
        "            \n"
      ],
      "execution_count": 275,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uTAg1XBdk9Qh"
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import silhouette_score\n",
        "x_train, x_test, y_train, y_test = train_test_split(X,Y,train_size = 1)"
      ],
      "execution_count": 289,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-YKPkYwXkhj_"
      },
      "source": [
        "from sklearn.preprocessing import StandardScaler\n",
        "scaler = StandardScaler().fit(x_train)\n",
        "x_train = scaler.transform(x_train)\n",
        "scaler = StandardScaler().fit(x_test)\n",
        "x_test = scaler.transform(x_test)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G_6vtkPultLx"
      },
      "source": [
        "som = SOM()\n",
        "som.fit(X,classes = 3,iterations=1000)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yzYVVFpjahwT"
      },
      "source": [
        "k_means = K_Means(k=3)\n",
        "k_means.fit(X)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tr5RV9B1EeKW"
      },
      "source": [
        "y_k_pred = k_means.predict(X)\n",
        "y_pred = som.predict(X)"
      ],
      "execution_count": 309,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5B0kZ4yvm7g2",
        "outputId": "bb7ba427-44a5-4926-f100-f312be726ed5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 337
        }
      },
      "source": [
        "xdf = pd.DataFrame(X)\n",
        "plt.style.use('ggplot')\n",
        "\n",
        "fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(18, 5))\n",
        "axes[0].scatter(xdf[0],xdf[2],c=y_pred,cmap='brg')\n",
        "axes[1].scatter(xdf[0],xdf[2],c=Y,cmap='brg')\n",
        "axes[2].scatter(xdf[0],xdf[2],c=y_k_pred,cmap='brg')\n",
        "axes[0].title.set_text(\"Predicted through SOM\")\n",
        "axes[1].title.set_text(\"Actual Plot\")\n",
        "axes[2].title.set_text(\"Predicted through K-Means\")\n",
        "\n",
        "#Colours DO NOT matter"
      ],
      "execution_count": 310,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x360 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EMkWz6B_c852",
        "outputId": "c659005c-3b13-49b7-a773-bc62a5b9f991",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "\n",
        "print(\"Silouhette Coefficient of SOM \\t\\t%0.2f\"%(silhouette_score(X,som.predict(X))*100))\n",
        "print(\"Silouhette Coefficient of K-Means \\t%0.2f\"%(silhouette_score(X,k_means.predict(X))*100))\n",
        "print(\"Silouhette Coefficient of Actual Data \\t%0.2f\"%(silhouette_score(X,Y)*100))"
      ],
      "execution_count": 311,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Silouhette Coefficient of SOM \t\t46.71\n",
            "Silouhette Coefficient of K-Means \t55.12\n",
            "Silouhette Coefficient of Actual Data \t50.35\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}