kmeans and kmeans++.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KMEANS AND KMEANS++"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Qc5iCm1ODnD0"
   },
   "source": [
    "**Part 1:** \n",
    "\n",
    "Use the **Fashion-MNIST** dataset for this question.\n",
    "\n",
    "1) Load the dataset and perform splitting into training and validation sets with 70:30 ratio.\n",
    "\n",
    "> Do we need to normalise data? [If so Does it make any difference?]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "897qJmTt_7n5"
   },
   "source": [
    "Ans.\n",
    "<br> PART 1:\n",
    "a) Some algorithms are influenced by the scale of each independent variables: removing the difference between those scales (i.e. normalizing) might have a negative effect.For example, in k-means, the scale is an implicit weight. As a result, changing the measurement units may even lead one to see a very different clustering structure\n",
    "<br>\n",
    "b) Normalization is usualy not required on image data as the maximum and minimum values of all the columns is same therefore normalization won't make any changes to our original data.\n",
    "\n",
    "PART 2:\n",
    "Normalization is not required here as there is no skewness in the data as all the columns have values in the same range."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0GBOoEb0ZoSr"
   },
   "source": [
    "2) Implement the K Means & K-means++ algorithm. You need to find the optimal number of clusters using the\n",
    "    elbow method and silhouette method. \n",
    "\n",
    "3) Define the initial clusters’ centroids using:</br>\n",
    "> i) Forgy</br>\n",
    "\n",
    "> ii) Random Partition\n",
    "\n",
    "4) Experiment with different distance measures[Euclidean distance, Manhattan distance].\n",
    "\n",
    "5) Plot the error vs number of clusters graph while using the elbow method and silhouette \n",
    "    method. Report the optimal number of clusters found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "aahFlwQcEVgp"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split # to split data into training sets and test sets\n",
    "import matplotlib.pyplot as plt\n",
    "from keras.datasets import fashion_mnist\n",
    "from numpy.linalg import norm\n",
    "import pandas as pd\n",
    "from sklearn.metrics.cluster import homogeneity_score\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "S4DST6eL4EgR",
    "outputId": "8c2d8dba-ee01-4d56-9528-f1c0aec7fbad"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n",
      "32768/29515 [=================================] - 0s 0us/step\n",
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n",
      "26427392/26421880 [==============================] - 0s 0us/step\n",
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n",
      "8192/5148 [===============================================] - 0s 0us/step\n",
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n",
      "4423680/4422102 [==============================] - 0s 0us/step\n"
     ]
    }
   ],
   "source": [
    "(train_x, train_y), (test_x, test_y) = fashion_mnist.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "LB2k-Hse4R0W"
   },
   "outputs": [],
   "source": [
    "x_l=[]\n",
    "\n",
    "for x in train_x:\n",
    "  x_l.append(x.flatten())\n",
    "for x in test_x:\n",
    "  x_l.append(x.flatten())\n",
    "\n",
    "x_l=np.array(x_l)\n",
    "\n",
    "y_l=[]\n",
    "\n",
    "for y in train_y:\n",
    "  y_l.append(y.flatten())\n",
    "for y in test_y:\n",
    "  y_l.append(y.flatten())\n",
    "\n",
    "y_l=np.array(y_l)\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(x_l, y_l, test_size=0.1, random_state=42)\n",
    "\n",
    "# print(x_train.shape)\n",
    "# #print(train_x[0])\n",
    "\n",
    "# print(x_test.shape)\n",
    "# #print(test_x[0])\n",
    "\n",
    "# print(y_train.shape)\n",
    "\n",
    "# print(np.unique(y_train))\n",
    "\n",
    "# print(y_test.shape)\n",
    "# print(test_y[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "3ylJEOJm3U7e"
   },
   "outputs": [],
   "source": [
    "def Euclidean_distance(v1,v2):  \n",
    "    sum=0\n",
    "    for p,q in zip(v1, v2):\n",
    "      sum+=(float(p)- float(q))**2\n",
    "    sum = sum ** .5\n",
    "    return sum  \n",
    "\n",
    "def Manhattan_distance(v1,v2):\n",
    "  sum=0\n",
    "  for p,q in zip(v1, v2):\n",
    "    sum+=abs(float(p)- float(q))\n",
    "  return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "doNUeLV7D1n_"
   },
   "outputs": [],
   "source": [
    "# 1. Kmeans algorithm with Forgy as initial clusters’ centroids with Euclidean Distance\n",
    "\n",
    "class Kmeans1:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Euclidean_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      print()\n",
    "      self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      \n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0][0])\n",
    "        \n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels\n",
    "          break\n",
    "      return self.centroids , self.labels\n",
    "    \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result[0][0])\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "#implement elbow method from scratch\n",
    "def elbow1():\n",
    "  \n",
    "  sse = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k,end =\" Homogeneity Score: \")\n",
    "\n",
    "    obj=Kmeans1(k)\n",
    "    centroids,labels = obj.fit(x_train)\n",
    "    #print(y_train.shape)\n",
    "    #print(len(labels))\n",
    "    print(homogeneity_score(np.squeeze(y_train),labels))\n",
    "    cost=0.0\n",
    "    for i in range(len(x_train)):\n",
    "      temp=Euclidean_distance(x_train[i],centroids[labels[i]])\n",
    "      cost+=temp\n",
    "    sse.append(float(cost))\n",
    "    #print(cost)\n",
    "    del obj\n",
    "    del centroids\n",
    "    del labels\n",
    "    del cost\n",
    "    del temp\n",
    "    \n",
    "  print(sse)\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, sse, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Elbow score with euclidean');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 801
    },
    "id": "ucYBxNyuWwAC",
    "outputId": "aa35d93d-c146-4ba0-9847-2d0523f5e364"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5 Homogeneity Score: \n",
      "0.35644250092543467\n",
      "k= 6 Homogeneity Score: \n",
      "0.42677644197268616\n",
      "k= 7 Homogeneity Score: \n",
      "0.43578861258038953\n",
      "k= 8 Homogeneity Score: \n",
      "0.46861333068923366\n",
      "k= 9 Homogeneity Score: \n",
      "0.4760946628916169\n",
      "k= 10 Homogeneity Score: \n",
      "0.5185286611579639\n",
      "k= 11 Homogeneity Score: \n",
      "0.5103428729890886\n",
      "k= 12 Homogeneity Score: \n",
      "0.5316953774313932\n",
      "k= 13 Homogeneity Score: \n",
      "0.5513233539927705\n",
      "k= 14 Homogeneity Score: \n",
      "0.5613943235766657\n",
      "[98071984.5908077, 96102922.77705336, 94690350.31265843, 91245221.96662189, 89783044.06911378, 88600305.80063525, 87324806.05221438, 86800193.73600122, 85060911.55840126, 84603255.53018007]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "elbow1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7sud6JCFeUVf"
   },
   "source": [
    "The optimal number of clusters from Kmeans algorithm with Forgy as initial clusters’ centroids with Euclidean Distance : K=13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "n_IhyCw96nRY"
   },
   "outputs": [],
   "source": [
    "# 2. Kmeans algorithm with Forgy as initial clusters’ centroids with Manhattan Distance\n",
    "\n",
    "class Kmeans2:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Manhattan_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      print()\n",
    "      self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      \n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0][0])\n",
    "        \n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels\n",
    "          break\n",
    "      return self.centroids , self.labels\n",
    "    \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result[0][0])\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "#implement elbow method from scratch\n",
    "def elbow2(): #kmeans\n",
    "  \n",
    "  sse = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"Homogenity Score for k=\",end=\" \")\n",
    "    print(k,end=\" \")\n",
    "    obj=Kmeans2(k)\n",
    "    centroids,labels = obj.fit(x_train)\n",
    "    #print(y_train.shape)\n",
    "    #print(len(labels))\n",
    "    print(homogeneity_score(np.squeeze(y_train),labels))\n",
    "    cost=0.0\n",
    "    for i in range(len(x_train)):\n",
    "      temp=Manhattan_distance(x_train[i],centroids[labels[i]])\n",
    "      cost+=temp\n",
    "    sse.append(float(cost))\n",
    "    #print(cost)\n",
    "    del obj\n",
    "    del centroids\n",
    "    del labels\n",
    "    del cost\n",
    "    del temp\n",
    "    \n",
    "  print(sse)\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, sse, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Elbow Score with Manhattan Dist');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 801
    },
    "id": "5Q8eX_i09lUw",
    "outputId": "c9b1f554-a192-4350-ed94-2c39102e3b61"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homogenity Score for k= 5 \n",
      "0.3713345813946177\n",
      "Homogenity Score for k= 6 \n",
      "0.42236018378599793\n",
      "Homogenity Score for k= 7 \n",
      "0.41622457628385423\n",
      "Homogenity Score for k= 8 \n",
      "0.48931267548738616\n",
      "Homogenity Score for k= 9 \n",
      "0.49166184206177577\n",
      "Homogenity Score for k= 10 \n",
      "0.5189459302536649\n",
      "Homogenity Score for k= 11 \n",
      "0.5084817213084825\n",
      "Homogenity Score for k= 12 \n",
      "0.5249627322589902\n",
      "Homogenity Score for k= 13 \n",
      "0.5373349185872477\n",
      "Homogenity Score for k= 14 \n",
      "0.5665942963340286\n",
      "[1881159145.7136245, 1789322638.9293015, 1779387740.5738406, 1716197842.4660711, 1660401543.079702, 1616061464.88614, 1579695335.6360784, 1563697533.3342109, 1535673207.4235466, 1497486791.6209607]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "elbow2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2whFycQaDd1f"
   },
   "source": [
    "The optimal number of clusters for Kmeans algorithm with Forgy as initial clusters’ centroids with Manhattan Distance : k=11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KvbkH4-I9lmk"
   },
   "outputs": [],
   "source": [
    "# 3. Kmeans algorithm with Random Partition as initial clusters’ centroids with Euclidean Distance\n",
    "\n",
    "class Kmeans3:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Euclidean_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      print()\n",
    "      #self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      indices = np.random.choice(range(0,self.k), replace = True, size = self.X.shape[0])\n",
    "      mean = []\n",
    "      for count in range(self.k):\n",
    "          mean.append(X[indices == count].mean(axis=0))\n",
    "          \n",
    "      self.centroids= np.concatenate([val[ None, :] for val in mean], axis = 0)\n",
    "\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      \n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0][0])\n",
    "        \n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels\n",
    "          break\n",
    "      return self.centroids , self.labels\n",
    "    \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result[0][0])\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "#implement elbow method from scratch\n",
    "def elbow3(): #kmeans\n",
    "  \n",
    "  sse = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k,end =\" Homogeneity Score: \")\n",
    "    obj=Kmeans3(k)\n",
    "    centroids,labels = obj.fit(x_train)\n",
    "    #print(y_train.shape)\n",
    "    #print(len(labels))\n",
    "    print(homogeneity_score(np.squeeze(y_train),labels))\n",
    "    cost=0.0\n",
    "    for i in range(len(x_train)):\n",
    "      temp=Euclidean_distance(x_train[i],centroids[labels[i]])\n",
    "      cost+=temp\n",
    "    sse.append(float(cost))\n",
    "    #print(cost)\n",
    "    del obj\n",
    "    del centroids\n",
    "    del labels\n",
    "    del cost\n",
    "    del temp\n",
    "    \n",
    "  print(sse)\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, sse, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Elbow score with euclidean dist');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 801
    },
    "id": "iaIVb4xQ-Sic",
    "outputId": "5e682c50-90a7-497b-a5ed-1eea47862770"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5 Homogeneity Score: \n",
      "0.3706721781514885\n",
      "k= 6 Homogeneity Score: \n",
      "0.4265644617245628\n",
      "k= 7 Homogeneity Score: \n",
      "0.47894195028583\n",
      "k= 8 Homogeneity Score: \n",
      "0.48998741508879473\n",
      "k= 9 Homogeneity Score: \n",
      "0.4948954906887299\n",
      "k= 10 Homogeneity Score: \n",
      "0.5188906343548882\n",
      "k= 11 Homogeneity Score: \n",
      "0.5254031575837342\n",
      "k= 12 Homogeneity Score: \n",
      "0.5459254450474184\n",
      "k= 13 Homogeneity Score: \n",
      "0.551258844863086\n",
      "k= 14 Homogeneity Score: \n",
      "0.5857961670084927\n",
      "[98060755.29607524, 96103789.5085273, 92614188.83283955, 91212950.522557, 89713598.79205829, 88508842.48076716, 87456502.9194187, 86377271.02205715, 85060489.65841427, 84159250.03742704]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAF+CAYAAACPqh3rAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhU9dnG8e+ThRDWsCoJIIsKIohAQBZBbK1YF0RQi9bdggutyltpaxe12lYt2rovKOKudUHcBbUiCAiGfRNUQIQgRCGsYQvP+8dMbAhZJpCZk2Tuz3XNlZkzZ87cGXGenPM75/mZuyMiIvErIegAIiISLBUCEZE4p0IgIhLnVAhEROKcCoGISJxTIRARiXNVshCY2ZNmtsHMFkWw7r/NbF74ttzMcmORUUSkqrCqeB2BmfUDtgHPuHvHcrzuN0AXd78iauFERKqYKrlH4O5TgI2Fl5lZWzN738xmm9lUM2tfzEsvAF6MSUgRkSoiKegAFWgMcLW7f2lmJwAPAz8peNLMjgBaA/8NKJ+ISKVULQqBmdUBegOvmFnB4pQiqw0FXnX3/FhmExGp7KpFISB0iCvX3Y8vZZ2hwIgY5RERqTKq5BhBUe6+BVhpZucBWEjngufD4wUNgBkBRRQRqbSqZCEwsxcJfam3M7M1ZnYl8EvgSjObDywGzi70kqHAS14VT5ESEYmyKnn6qIiIVJwquUcgIiIVR4VARCTOVbmzhho3buytWrUKOoaISJUye/bs7929SXHPVblC0KpVK7KysoKOISJSpZjZNyU9p0NDIiJxToVARCTOqRCIiMQ5FQIRkTinQiAiEudUCERE4pwKgYhInFMhEBGJcyoEIiJxrspdWXwwJsxdy+iJy8jOzSM9LZVRA9oxqEtG0LFERCqFqO4RmNn1ZrbIzBab2Q3FPF/fzN4ys/nhdS6v6AwT5q7lpvELWZubhwNrc/O4afxCJsxdW9FvJSJSJUWtEJhZR2AY0APoDJxpZkcWWW0EsMTdOwP9gXvMrEZF5hg9cRl5e/afpjhvTz6jJy6ryLcREamyorlHcAww0913uPte4BNgcJF1HKhroRnn6wAbgb0VGSI7N69cy0VE4k00C8EioK+ZNTKzWsDpQIsi6zxIqGBkAwuB6919X0WGSE9LLddyEZF4E7VC4O5LgbuAScD7wDwgv8hqA8LL04HjgQfNrF7RbZnZcDPLMrOsnJyccuUYNaAdqcmJByz/Vd/W5dqOiEh1FdXBYncf6+7d3L0fsAlYXmSVy4HxHvIVsBJoX8x2xrh7prtnNmlS7LwKJRrUJYM7BnciIy0VA5rWTSEl0Xh19hrydhetSyIi8Seqp4+aWVN332BmLQmND/Qssspq4KfAVDM7DGgHrKjoHIO6ZOx3uuh/v1jPlU9n8bvXFnD/0OMJDVGIiMSnaF9Q9pqZLQHeAka4e66ZXW1mV4efvx3obWYLgY+A37v791HOxE/aH8aNp7bjrfnZPDalwuuOiEiVEtU9AnfvW8yyRwvdzwZOjWaGklzbvy1L123hrve/oP3hdenfrmkQMUREAhe3LSbMjH+eexztD6/Hb16cy4qcbUFHEhEJRNwWAoBaNZIYc3E3khMTGPZMFlt37gk6kohIzMV1IQBo0bAWD13YlVU/7GDkf+axb58HHUlEJKbivhAA9GrbiJvP7MCHSzfw7w+LnuEqIlK9xUX30Uhc0usIlmRv4YH/fsUxzepxeqdmQUcSEYkJ7RGEmRm3DTqWri3T+O3L81m6bkvQkUREYkKFoJCUpEQevagb9VKTGPZMFhu37w46kohI1KkQFNG0Xk0euziTDVt38esX5rA3v0J74ImIVDoqBMU4vkUa/zinE9O//oG/v7s06DgiIlGlweISnNutOUuyt/DktJUc06we52cW7aAtIlI9aI+gFH88vT19jmzEn19fxNzVm4KOIyISFSoEpUhKTODBC7pyWP0Urnp2Nuu37Aw6kohIhVMhKEOD2jV4/JJMtu3ay9XPzWbXXs1hICLViwpBBNofXo97zuvM3NW5/Pn1RbirDYWIVB8qBBH6eadmXPeTI3ll9hqenr4q6DgiIhVGhaAcbjjlaE455jBuf2cp07+O+vw5IiIxoUJQDgkJxr9/0ZnWjWsz4vk5fLtxR9CRREQOmQpBOdWtmczjl2SSv88Z9kwWO3bvDTqSiMghUSE4CK0b1+b+C7qwfP1WRr2yQIPHIlKlqRAcpP7tmvL709rzzsJ1PDz566DjiIgcNBWCQzC8XxsGdk7n7knL+Gjp+qDjiIgcFBWCQ2Bm3DXkOI5Nr8f1L83jqw3bgo4kIlJuKgSHKLVGIo9dnElKUgLDn8lic96eoCOJiJSLCkEFyEhL5ZGLurF64w6uf2ku+fs0eCwiVYcKQQXp0bohtw48lsnLcrh70rKg44iIREzzEVSgi3oeweLsLTwy+Ws6NKvHWZ3Tg44kIlIm7RFUsL8OPJbMIxow6tX5LFq7Oeg4IiJlUiGoYDWSEnjkom40qFWDq56dzQ/bdgUdSUSkVCoEUdCkbgqPXdyN77ft4prn57Anf1/QkURESqRCECXHNU/jziGdmLVyI7e/vSToOCIiJdJgcRSd06U5S7K38PjUlXRoVo+hPVoGHUlE5ADaI4iy35/Wnr5HNeYvbyxi9jcbg44jInIAq2qdMzMzMz0rKyvoGOWyecceBj70KT9s20WdlCTWb9lFeloqowa0Y1CXjKDjiUgcMLPZ7p5Z3HPaI4iB+rWSGdq9Bdt25fPdll04sDY3j5vGL2TC3LVBxxOROBfVQmBm15vZIjNbbGY3lLBOfzObF17nk2jmCdJzn60+YFnennxGT9RVyCISrKgNFptZR2AY0APYDbxvZm+7+1eF1kkDHgZOc/fVZtY0WnmClp2bV67lIiKxEs09gmOAme6+w933Ap8Ag4uscyEw3t1XA7j7hijmCVR6Wmq5louIxEo0C8EioK+ZNTKzWsDpQIsi6xwNNDCzyWY228wuKW5DZjbczLLMLCsnJyeKkaNn1IB2pCYn7rcsJSmBUQPaBZRIRCQkaoeG3H2pmd0FTAK2A/OA/GLevxvwUyAVmGFmn7n78iLbGgOMgdBZQ9HKHE0FZweNnriM7Nw8HOjZpqHOGhKRwEX1gjJ3HwuMBTCzfwBriqyyBvjB3bcD281sCtAZWE41NKhLxo9f/De8NJcPlqxnc94e6qcmB5xMROJZtM8aahr+2ZLQ+MALRVZ5AzjRzJLCh49OAJZGM1NlMaxfG7bvzueFmQeeTSQiEkvRvo7gNTNbArwFjHD3XDO72syuhtDhI+B9YAEwC3jC3RdFOVOlcGx6fU48sjHjpq1k9141pROR4ES1ELh7X3fv4O6d3f2j8LJH3f3RQuuMDq/T0d3vjWaeymZYvzZs2LqLN+dnBx1FROKYriwOUL+jGtP+8Lo8PmUFVa3Vh4hUHyoEATIzhvVtw7L1W/lkedU8LVZEqj4VgoCd1Tmdw+vV5PGpK4KOIiJxSoUgYDWSEri8TyumffWD5jgWkUCoEFQCF5zQkjopSdorEJFAqBBUAvVqhtpUv71gHWvVhE5EYkyFoJK44sTWGPDkpyuDjiIicUaFoJJIT0vlzOOa8dKs1WzO2xN0HBGJIyoElciv+obaTrw4S20nRCR2VAgqkY4Z9elzZCO1nRCRmFIhqGSG92vL+i1qOyEisaNCUMn0O6ox7Q5T2wkRiR0VgkrGzBjWT20nRCR2VAgqoYGd0zmsXoouMBORmFAhqIRCbSdaq+2EiMSECkEldUGPltSukcgT2isQkShTIaik6qcmc0GPlrylthMiEmUqBJXY5Se2BmCc2k6ISBSpEFRiGeG2Ey+q7YSIRJEKQSU3TG0nRCTKVAgqObWdEJFoUyGoAob1bcP6Lbt4S20nRCQKyiwEZvZRJMskek46ukmo7cRUtZ0QkYpXYiEws5pm1hBobGYNzKxh+NYKyIhVQPlf24kvvtvKlC+/DzqOiFQzpe0RXAXMBtqHfxbc3gAejH40KezHthNTdIGZiFSsEguBu9/n7q2BG929jbu3Dt86u7sKQYwVtJ349Kvv1XZCRCpUJIPF35lZXQAz+7OZjTezrlHOJcVQ2wkRiYZICsFf3H2rmZ0InAKMBR6JbiwpTv3UZIaG205kq+2EiFSQSApBfvjnGcAYd38HqBG9SFKay/u0AuBJtZ0QkQoSSSFYa2aPAb8A3jWzlAhfJ1HQvEEttZ0QkQoVyRf6+cBEYIC75wINgVFRTSWlKmg78ZLaTohIBSjtOoJ64bs1gcnAD+HrCnYBWdGPJiXpmFGf3m0bMW7aKrWdEJFDVtoewQvhn7MJffEXvpZAhSBgw/u14bstO9V2QkQOWVJJT7j7meGfrWMXRyJVuO3E4K4ZmFnQkUSkiirt0FDX0m6RbNzMrjezRWa22MxuKGW97ma218zOPZhfIh6ZGb/q21ptJ0TkkJW4RwDcE/5ZE8gE5gMGHEfo0FCv0jZsZh2BYUAPYDfwvpm97e5fFVkvEbgLmHQwv0A8O/v4DO6etIzHp6zgpKObBB1HRKqo0lpMnOzuJwPrgK7ununu3YAuwNoItn0MMNPdd7j7XuATYHAx6/0GeA3YUO70ca5GUgKX9Q61nVicrbYTInJwIjl9tJ27Lyx44O6LCH3Jl2UR0NfMGplZLeB0oEXhFcwsAziHMq5UNrPhZpZlZlk5OTkRvHX8uPCEUNsJNaMTkYMVSSFYYGZPmFn/8O1xYEFZL3L3pfzvkM/7wDz+d5VygXuB37t7qedAuvuY8B5JZpMmOgRSmNpOiMihiqQQXA4sBq4P35aEl5XJ3ce6ezd37wdsApYXWSUTeMnMVgHnAg+b2aAIs0tYQduJcdPUdkJEyq+0wWIA3H0n8O/wrVzMrKm7bzCzloTGB3oW2XbrQus+Bbzt7hPK+z7xrnmDWpzRqRkvzvqW3/z0KOrVTA46kohUIdHuGfSamS0B3gJGuHuumV1tZldH+X3jzvB+bdi2ay8vzlTbCREpnzL3CA6Fu/ctZtmjJax7WTSzVHeF205c3qc1NZLUF1BEIqNvi2pkmNpOiMhBKHOPwMyOJtRt9IjC67v7T6KYSw5Cf7WdEJGDEMmhoVeAR4HHOfD0T6lECtpOjHp1AVO//J5+utpYRCIQyaGhve7+iLvPcvfZBbeoJ5ODMvD4dJrWTeFxzWssIhGKpBC8ZWbXmlkzM2tYcIt6MjkoKUmJXN6nNVO/VNsJEYlMJIXgUkJjBNPRfARVQkHbiSem6gIzESlbmYXA3VsXc2sTi3BycOqnJvOL7i15a3622k6ISJkiOn3UzDqa2flmdknBLdrB5NBccWIrHLWdEJGylVkIzOwW4IHw7WTgn8DAKOeSQ1S47cSWnXuCjiMilVgkewTnAj8FvnP3y4HOQP2oppIKMaxvqO3ES7PUdkJEShZJIcgLt4nea2b1CE0g06KM10gl0Kl5fXq1acSTn65i995SO32LSByLpBBkmVkaoQvKZgNzgBlRTSUVZvhJobYTby9Q2wkRKV4kZw1d6+654WZxPwMuDR8ikiqg/9FNOKppHcZMWYG7Bx1HRCqhSAaLzcwuMrOb3X0VkGtmPaIfTSqCmTGsXxu++G4rU7/8Pug4IlIJRXJo6GGgF3BB+PFW4KGoJZIKd7baTohIKSIpBCe4+whgJ4C7bwJqRDWVVKiUpEQu69OKqV9+z5LsLUHHEZFKJpJCsMfMEgEHMLMmgE5BqWJ+2eMIatVI1F6BiBwgkkJwP/A60NTM/g58CvwjqqmkwtWvlcxQtZ0QkWJEctbQ88DvgDuAdcAgd38l2sGk4l3eJ9R24qnpq4KOIiKVSImFoEjL6Q3Ai8ALwHq1oa6aWjSsxemdmvHCzNVqOyEiPyptj6Cg3fRsIAdYDnwZvq+Jaaqo4Wo7ISJFlFgICrWb/hA4y90bu3sj4ExgUqwCSsXq1Lw+RzapzZ3vfUHrP7xDnzv/y4S5a4OOJSIBimSwuKe7v1vwwN3fA3pHL5JE04S5a1m9MY99HjoNbG1uHjeNX6hiIBLHIikE2Wb2ZzNrFb79CVDjmipq9MRl7M7f/+zfvD35jJ64LKBEIhK0SArBBUATQqeQvg405X9XGUsVU9KpozqlVCR+JZW1grtvBK6PQRaJgfS0VNYW86XfoFZyAGlEpDIo7fTRe8M/3zKzN4veYhdRKtKoAe1ITU7cb5kZbNyxh7GfalpLkXhU2h7Bs+Gfd8ciiMTGoC4ZQGisIDs3j/S0VG445Sg+XLqe299eQnZuHn86/RgSEizgpCISK1bVetRnZmZ6VlZW0DGqnfx9zu1vL+Gp6as4o1Mz7jm/MzWL7DmISNVlZrPdPbO450rcIzCzhYQbzRV9CnB3P66C8kklkJhg3HJWBzLSUvn7u0vJ2bqLMZd0I62WGs2KVHelHRo6M2YppFIomMTmsPo1ufHl+Zz76Ayeurw7zRvUCjqaiERRaVcWf+Pu34TXWV/o8QZCewVSTQ3snM7TV/Rg/ZadnPPwdBZnbw46kohEUSTXEbzC/vMP5IeXSTXWq20jXrumN8kJxvmPzmDK8pygI4lIlERSCJLcfXfBg/D9iA4cm9n1ZrbIzBab2Q3FPP9LM1tgZgvNbLqZdY48ukTb0YfVZfy1fWjRsBZXPPU5r85eE3QkEYmCSApBjpkNLHhgZmcDZc6CbmYdgWFAD6AzcKaZHVlktZXASe7eCbgdGBNpcImNw+vX5OWre3FCm4bc+Mp8HvjoS6ramWYiUrpICsHVwB/NbLWZfQv8HrgqgtcdA8x09x3uvhf4BBhceAV3nx6eAxngM6B55NElVurVTGbcZT04p0sG93ywnD++voi9+ZqtVKS6iKTFxNdATzOrE368LcJtLwL+bmaNgDzgdELzG5TkSuC9CLctMVYjKYF/nd+ZZvVr8vDkr1m/ZScPXtiFWjXK/CckIpVcmf8Xm9nNRR4D4O63lfY6d19qZncRmrtgOzCP0EBzce9xMqFCcGIJzw8HhgO0bNmyrMgSJWbG705rT7O0VG55YxFDx3zG2Eu706RuStDRROQQRHJoaHuhWz7wc6BVJBt397Hu3s3d+wGbCM1yth8zOw54Ajjb3X8oYTtj3D3T3TObNGkSyVtLFF3c8wgeuziT5eu3MuSR6azIiXQnUUQqo3K3mDCzFGCiu/ePYN2m7r7BzFoS2jPo6e65hZ5vCfwXuMTdp0fy/moxUXnMXb2JK5/Owt0Ze1l3urZsEHQkESlBaS0mItkjKKoWkQ/qvmZmS4C3gBHunmtmV5vZ1eHnbwYaAQ+b2Twz0zd8FdKlZQPGX9ObeqnJXDDmMyYt/i7oSCJyEMrcIyjScyiR0CQ1t7n7g1HOViztEVQ+32/bxZVPZ7FwTS5/HXgsF/dqFXQkESnioJrOFVK459BeQu0m9lZIMqkWGtdJ4cVhJ3Ddi3P5yxuLWZu7k98NaKdW1iJVRJmHhsL9hVoAP3H3tUCambWOejKpUmrVSOLRi7px4QktefSTrxn58jx27S32JDERqWQiOX30FiATaAeMI9Re4jmgT3SjSVWTlJjA3wd1JCMtldETl7Fhyy4eu6Qb9WpqGkyRyiySweJzgIGETh/F3bOButEMJVWXmTHi5CP51/md+XzVRs5/dAbrNh84R7KIVB6RFILdHhpRdgAzqx3dSFIdDO7anKcu78GaTXmc89B0vvhuS9CRRKQEkRSCl83sMUJjA8OAD4HHoxtLqoMTj2rMy1f1wnHOe2QG078us1ehiAQgksHiu4FXgdcIjRPc7O4PRDuYVA8d0usx/to+HF6/Jpc+OYs35q0NOpKIFBFRxzB3/wD4IMpZpJrKSEvl1at7M/zZLK5/aR7rNu/kqn5tfuxbJSLBOpgri0XKrX6tZJ65sgdnHteMO9/7glveXEz+Ps1rIFIZqIewxExKUiL3D+1CeloqY6asYM43m9i4fTfrNu8kPS2VUQPaMahLRtAxReKOCoHEVEKC8cfTj+H7rTsZPzf7x+Vrc/O4afxCABUDkRgr89CQmfUxsw/MbLmZrTCzlWa2IhbhpPqauXLTAcvy9uQzeuKyANKIxLdI9gjGAiOB2ZQwsYxIeWXnFn+RWUnLRSR6IikEm91dU0hKhUpPS2VtMV/6mu1MJPZKPDRkZl3NrCvwsZmNNrNeBcvCy0UO2qgB7UhNTjxg+fZde1m0dnMAiUTiV2l7BPcUeVy4j7UDP6n4OBIvCgaER09cRnZuHulpqVzWuxVPTV/FBWM+Y9zl3cls1TDglCLxIZKJadq4+4qylsWKJqap3rJz87joiZms27yTMZd0o+9RmqNapCIc6lSVrxaz7JVDiyRSvPS0VP5zVS9aNa7NlU9l8f4iTX8pEm2ljRG0N7MhQH0zG1zodhlQM2YJJe40qZvCS8N60iG9HiNemMPrc9cEHUmkWittjKAdoWkq04CzCi3fCgyLZiiR+rWSee5XJzDs6SxG/mc+23blc3HPI4KOJVItlVgI3P0N4A0z6+XuM2KYSQSAOilJjLu8OyOen8NfJixi+669XH1S26BjiVQ7JRYCM/udu/8TuNDMLij6vLtfF9VkIkDN5EQevbgbI/8zjzvf+4JtO/fy21OPVudSkQpU2qGhpeGfOkVHApWcmMB9Q7tQJyWJBz/+im279nLzmR1ISFAxEKkIpR0aeit891N3/zpGeUSKlZhg3DG4E7VTkhj76Uq279rLnUOOI1HFQOSQRdJi4kkzaw58DkwFprj7wujGEjmQmfHnM46hTkoS9330JTt25/PvXxxPjSRNqyFyKMosBO5+kpnVALoD/YF3zKyOu+uyT4k5M2Pkz46mTkoSf393Kdt37+WRX3YjtcaB7SpEJDJlFgIzOxHoG76lAW8T2jMQCcywfm2onZLEnyYs5NJxsxh7aSZ1ayYHHUukSork0NBkQi2o7wDedffdUU0kEqELT2hJ7ZREfvvyfC56YiZPXd6DBrVrBB1LpMqJ5OBqY+A2oBfwvpl9aGa3RzeWSGTOPj6DRy/qxtLvtjJ0zGds2LIz6EgiVU6ZhcDdc4EVwEpgHdAW6BflXCIRO6XDYYy7rDvfbtrB+Y/NYM2mHUFHEqlSIpmqcgWhltQNgEeAdu5+UrSDiZRHnyMb8+yVJ7Bx+27Of3QGK3K2BR1JpMqI5NDQke5+urvf4e6faoxAKqtuRzTgxeE92bV3H+c/NoMl2VuCjiRSJURyaGhfLIKIVIRj0+vzn6t6kZyYwNAxM5izelPQkUQqPV2JI9XOkU3r8PJVvWhQuwYXPTGT6V9/H3QkkUotqoXAzK43s0VmttjMbijmeTOz+83sKzNboLmQpaK0aFiLV67qRfMGqVw27nM+Wro+6EgilVYkg8WHmdlYM3sv/LiDmV0Zwes6Epq3oAfQGTjTzI4sstrPgaPCt+GEBqNFKkTTejV5aXgv2h1Wl6uenc1b87ODjiRSKUWyR/AUMBFIDz9eDhzw130xjgFmuvsOd98LfAIMLrLO2cAzHvIZkGZmzSJKLhKBhrVr8MKwE+jasgHXvTSXl2atDjqSSKUT0QVl7v4ysA8g/KWeH8HrFgF9zayRmdUCTgdaFFknA/i20OM14WX7MbPhZpZlZlk5OTkRvLXI/9StmczTV/Sg31FN+MP4hYz9dGXQkUQqlUgKwXYzawQ4gJn1BDaX9SJ3XwrcBUwC3gfmEVkBKW5bY9w9090zmzRpcjCbkDiXWiORMZd04+cdD+f2t5dw34df4u5BxxKpFCIpBP8HvAm0NbNpwDPAbyLZuLuPdfdu7t4P2ETosFJha9l/L6F5eJlIhUtJSuSBC7owpGtz/v3hcv7x7lIVAxHKaDpnZonASeFbO8CAZe6+J5KNm1lTd99gZi0JjQ/0LLLKm8Cvzewl4ARgs7uvK+fvIBKxpMQERp97HHVSEnl86kq27crnb4M6aoIbiWulFgJ3zzezC9z938Dig9j+a+HDSnuAEe6ea2ZXh7f9KPAuobGDr4AdwOUH8R4i5ZKQYNw68FhqpyTx8OSvWbZuC99t3cm63J2kp6UyakA7BnU5YKhKpNqKpA31NDN7EPgPsL1gobvPKeuF7t63mGWPFrrvwIjIoopUHDPjd6e1Z/XG7by94Lsfl6/NzeOm8aEJ+FQMJF5EUgiOD/+8rdAyB35S8XFEYmvu6gPPe8jbk8/oictUCCRuRDJV5cmxCCIShOzcvHItF6mOIrmyuL6Z/avgPH4zu8fM6scinEi0paelFru8dkoie/LVb1HiQySnjz4JbAXOD9+2AOOiGUokVkYNaEdq8v4T3ycmGNt25TN0zGes26w9A6n+IikEbd39FndfEb79FWgT7WAisTCoSwZ3DO5ERloqBmSkpXLPeZ25/4IufLFuC2fc/ylTlutqdqneIhkszjOzE939UwAz6wPozySpNgZ1ySh2YPjY9Hpc+9wcLh03i9+cfCTXn3K0rjeQaimSPYJrgIfMbJWZrQIeBK6OaiqRSqBtkzpMGNGHIV2bc/9/v+LisTPJ2bor6FgiFc4ivcTezOoBuHug8/9lZmZ6VlZWkBEkDr2c9S1/mbCI+qnJPHBBF05o0yjoSCLlYmaz3T2zuOciOWvoH2aW5u5b3H2LmTUws79VfEyRyuv8zBZMGNGH2ilJXPjETB6Z/DX79qlPkVQPkRwa+rm75xY8cPdNhNpCiMSVY5rV481f9+G0Yw/nrve/YNgzWeTu2B10LJFDFkkhSDSzlIIHZpYKpJSyvki1VbdmMg9e2IW/DjyWKV/mcMb9nzLv29yyXyhSiUVSCJ4HPjKzK8NTVH4APB3dWCKVl5lxae9WvHp1bwDOe3Q6T01bqZbWUmVFNFhsZqcBp4QffuDuE6OaqhQaLJbKJHfHbn778nw++mIDZ3Rqxp1DOlG3ZnLQsUQOcKiDxbWBSe5+I/A4kGJm+pcuAqTVqsHjl2Ry08/b8/7i7zjrgU9Zkh3oiXUi5RbJoaEpQE0zyyA05eTFhCa0FxFC8xtcdVJbXhzWk7w9+Zzz8DT+8/lqHSqSKiOSQmDuvoPQDGOPuPt5wLHRjSVS9fRo3ZB3rutL91YN+f1rC/yTtNwAABlASURBVPntK/PZsXtv0LFEyhRRITCzXsAvgXfCyxJLWV8kbjWuk8LTV/TghlOO4vW5axn00DS+2rA16FgipYqkEFwP3AS87u6LzawN8HF0Y4lUXYkJxg2nHM0zV/Tgh227GfjgNN6YtzboWCIlirjFRGWhs4akKvlu805+/cIcsr7ZxEU9W/LnMzpQM1k71BJ7h3TWkIgcvMPr1+TF4T25ql8bnvtsNec+Op3VP+wIOpbIflQIRKIsOTGBm04/hscvyWT1Dzs444GpTFz8XdCxRH4UyXUENWMRRKS6+1mHw3jnur60blybq56dzd/eXqLpMKVSiGSPYJGZTTOzO83sDM1XLHLwWjSsxStX9+KSXkfwxKcr+cVjM8jO1TxPEqxIW0y0BPoCfQh1Hs119+OjnK1YGiyW6uKt+dn84bUF1EhK4N6hXdi0fTejJy4jOzeP9LRURg1oV+zMaSIHo7TB4jKnqjSz5oQKQF+gM7AY+LRCE4rEobM6p9MhvR4jnp/DpU/OIinB2Bue42Btbh43jV8IoGIgURfJoaHVwA3Ae+7ey93PcPc7opxLJC60bVKH16/tQ60aiT8WgQJ5e/IZPXFZQMkknkRSCLoAzwAXmtkMM3sm3I5aRCpAao1E8nbnF/ucxg8kFso8NOTu883sa+BrQoeHLgJOAsZGOZtI3EhPS2VtMV/6TetpDiiJvkhOH80CZgDnAEuBfu5+RLSDicSTUQPakVrMFce523erk6lEXZl7BITmLM6JehKROFYwIFz4rKEr+rTig6Xr+f1rC3l7wTruHHIcGWmpASeV6qjM00fD1w3cAvQLL/oEuM3dN0c5W7F0+qjEk337nOdnfsMd731Bghl/PP0YLujRAjMLOppUMYfaa+hJYCtwfvi2BRhXcfFEpCQJCcbFvVox8YZ+dMqozx9fX8jFY2exZpP6FUnFiWSPYF7Ri8eKWxYr2iOQeLVvn/PCrNXc8e5SAG46/Rgu7NGShATtHUjZDnWPIM/MTiy0sT6AzmkTibGEBOOinkcwcWQ/urRswJ8nLOKisTP5dqP2DuTQRFIIrgEeMrNVZvYN8CBwVSQbN7ORZrbYzBaZ2YtFG9iZWUsz+9jM5prZAjM7vfy/gkh8ad6gFs9e2YM7BndiwZrNDLh3Cs/OWMW+fTqzSA5OxBPTmFk9AHffEuH6GYRaUXRw9zwzexl4192fKrTOGGCuuz9iZh3Cz7cqbbs6NCTyP2tz8/jDawuY+uX39GzTkH8O6UzLRrWCjiWV0CEdGjKzRmZ2PzAZ+NjM7jOzRhG+dxKQamZJQC0gu8jzDtQL369fzPMiUoqMtFSeuaIHdw3pxOK1Wxhw7xSemrZSewdSLpEcGnoJyAGGAOeG7/+nrBe5+1rgbkK9itYBm919UpHVbgUuMrM1wLvAb4rblpkNN7MsM8vKydElDSKFmRm/6N6SiSP70aN1Q259awlDH/+MVd9vDzqaVBGRnDW0yN07Flm20N07lfG6BsBrwC+AXOAV4FV3f67QOv8XznCPmfUi1Laio7uXOFuHDg2JlMzdeWX2Gm4PT3rzuwHtuax3K51ZJId81tAkMxtqZgnh2/nAxAhedwqw0t1z3H0PMB7oXWSdK4GXAdx9BlATaBzBtkWkGGbG+ZktmDSyH73aNOK2t5fwizEzWKm9AylFiYXAzLaa2RZgGPACsCt8ewkYHsG2VwM9zayWhS6D/CmhXkVF1/lp+P2OIVQIdOxH5BA1q5/Kk5d1557zOrPsu62cdu8Unpi6gnyNHUgxSiwE7l7X3euFfya4e3L4luDu9Up6XaHXzwReBeYAC8PvNcbMbjOzgeHVfgsMM7P5wIvAZa7uWiIVwswY0q05H/zfSZx4ZGP+9s5Szn9sBl/nbAs6mlQyJY4RmFnX0l7o7nOikqgMGiMQKT93Z8K8tdz65hJ27snnxlPbccWJrUnU2EHcKG2MoLRC8HEp23R3/0lFhCsvFQKRg7dhy07++PoiPly6ni4t0xh9bmeObFon6FgSAwdVCCorFQKRQ+PuvDk/m1veXMyO3fn838+OZljfNto7qOYO6qwhM/tdofvnFXnuHxUXT0Riycw4+/gMJo3sR/+jm3Dne18w+JHpfLl+a9DRJCClHRqa4+5di94v7nEsaY9ApOK4O28tWMctbyxi+658Tj22KXNW57IudyfpaamMGtDux0lzpGorbY+gtBnKrIT7xT0WkSrIzBjYOZ1ebRpx5dOzeHvBdz8+tzY3j5vGLwRQMajmSrugzEu4X9xjEanCmtRN4Ydtew5Ynrcnn9ETlwWQSGKptD2CzuELyoxQ47iCrqNG6MIvEalGsnOLn2akpOVSfZR2QVlioQvKksL3Cx4nxzKkiERfelpqscsdeHq65juoziLpNSQicWDUgHakJifut6xmUgLtD6/LLW8u5qKxMzVXcjWlQiAiQGhA+I7BnchIS8UIzXVw55DjeO/6vtwxuBPzv83ltHun8nLWt1S164+kdLqgTEQi8u3GHdz4ynxmrtzIT9s35Y7BnWhaT8OFVcWhtqEWEaFFw1q8OKwnN5/ZgU+/+p5T753C2ws0qWB1oEIgIhFLSDCuOLE171zXlyMa1ebXL8zl1y/MYdP23UFHk0OgQiAi5XZk0zq8dnUvRg1ox8TF33HqvVP4aOn6oGPJQVIhEJGDkpSYwIiTj+SNESfSqHYNrnw6i9+9Op+tOw+8ME0qNxUCETkkHdLr8cav+zDi5La8OnsNp907lelffR90LCkHFQIROWQpSYmMGtCe167pTUpSAhc+MZNb31xM3u78oKNJBFQIRKTCdGnZgHeu68vlfVrx1PRVnH7/VGZ/synoWFIGFQIRqVCpNRK55axjeWHYCezeu4/zHp3OXe9/wa692juorFQIRCQqerdtzMSR/fhF9xY8MvlrBj4wjUVrNwcdS4qhQiAiUVMnJYk7Bh/HuMu6s2nHbgY9NI37P/qSPfn7go4mhagQiEjUndy+KZNG9uOM45rxrw+WM0RTY1YqKgQiEhNptWpw39AuPPzLrny7cQdnPPApT0xdQb7aWwdOhUBEYur0Ts2YNPIk+h3VhL+9s5QLxnzG6h/U3jpIKgQiEnNN6qbw+CXduOe8zixdt4XT7pvC8zO/UXvrgKgQiEggzIwh3ZozcWQ/urZswJ9eX8QlT85i3WZNjRlrmo9ARALn7jw3czX/eGcpSYnGwM7NmLwsh+zcnaSnpTJqQDsGdckIOmaVpvkIRKRSMzMu7nkE713fl8a1a/D8zG9Zm7sTB9bm5nHT+IVMmLs26JjVlgqBiFQarRrXZlcx1xjk7cln9MRlASSKDyoEIlKprMvdWezy7FyNHUSLCoGIVCrpaanFLq+dksQ+XXMQFSoEIlKpjBrQjtTkxP2WJSYY23bt5arnZrN9196AklVfKgQiUqkM6pLBHYM7kZGWigEZaancfe5x3HpWBz5aup4hj0xnzSZdgFaRonr6qJmNBH4FOLAQuNzddxZZ53zg1vA68939wtK2qdNHReLXlOU5jHhhDjUSE3js4m5ktmoYdKQqI5DTR80sA7gOyHT3jkAiMLTIOkcBNwF93P1Y4IZo5RGRqq/f0U2YMKIP9VKTufDxmbw6e03QkaqFaB8aSgJSzSwJqAVkF3l+GPCQu28CcPcNUc4jIlVc2yZ1eP3a3nRv3YAbX5nPHe8uVeO6QxS1QuDua4G7gdXAOmCzu08qstrRwNFmNs3MPjOz06KVR0Sqj7RaNXjq8h5c0usIHpuyguHPZLF1556gY1VZ0Tw01AA4G2gNpAO1zeyiIqslAUcB/YELgMfNLK2YbQ03sywzy8rJyYlWZBGpQpITE7jt7I7cPqgjk5fnMOSR6epiepCieWjoFGClu+e4+x5gPNC7yDprgDfdfY+7rwSWEyoM+3H3Me6e6e6ZTZo0iWJkEalqLu55BM9e0YP1W3Zx9kOfMnPFD0FHqnKiWQhWAz3NrJaZGfBTYGmRdSYQ2hvAzBoTOlS0IoqZRKQa6n1kYyaM6EOD2jW4aOxM/vP56qAjVSnRHCOYCbwKzCF06mgCMMbMbjOzgeHVJgI/mNkS4GNglLurnItIubVuXJvXr+1Dr7aN+f1rC7ntrSXs1dzIEVEbahGpVvbm7+Pv7y5l3LRVnHR0Ex64sAv1aiYHHStwakMtInEjKTGBW846ljsGd2LaV99zzkPTWPX99qBjVWoqBCJSLV3QoyXP/eoENm7fzaCHpzH96++DjlRpqRCISLXVs00j3hhxIk3qpHDJ2Fk899k3QUeqlFQIRKRaa9moFuOv7U3foxrz5wmLuOWNRRpELkKFQESqvbo1k3ni0u4M69uap2d8w2XjPmfzDl2JXECFQETiQmKC8aczOvDPc49j5sofOOfhaazI2RZ0rEpBhUBE4sr5mS14YVhPcvP2MOihaUz9Um1rVAhEJO50b9WQN0b0IT0tlcvGfc7T01dR1a6pqkgqBCISl1o0rMWr1/Tm5HZNueXNxfx5wiL2xOkgsgqBiMStOilJjLm4G9f0b8vzM1dzydhZbNq+O+hYMadCICJxLSHB+P1p7fnX+Z2Z/c0mBj08ja82bA06VkypEIiIAIO7NufF4T3Zviufcx6azuRl8TNhoprOiYgUsjY3j2FPZ/HFd1sY2Dmdz1dtJDt3J+lpqYwa0I5BXTKCjnhQ1HRORCRCGWmpvHpNL45Nr8eEedmszd2JEyoQN41fyIS5a4OOWOFUCEREiqhVI4kfihk0ztuTz+iJywJIFF0qBCIixViXu7PY5dm5eTFOEn0qBCIixUhPSy12uQN3vLeUrTurT68iFQIRkWKMGtCO1OTE/ZbVTEqg+xENeOyTFZx892RenLWa/H1V64Sb4qgQiIgUY1CXDO4Y3ImMtFSM0CDynUOO45VrevPmr/vQunFtbhq/kDPun8q0r6r2pDc6fVRE5CC4O+8t+o5/vLuUNZvyOOWYw/jTGcfQunHtoKMVS6ePiohUMDPj9E7N+PD/TuL3p7XnsxU/cOq/P+H2t5dUubkOVAhERA5BzeRErunflo9v7M+53Zrz5LSV9L/7Y56ZsarKzISmQiAiUgGa1E3hjsHH8c5v+tL+8Hrc/MZiTrtvapVoVaFCICJSgTqk1+OFYScw5uJu7M3fx2XjPufSJ2fx5frK28hOhUBEpIKZGaceeziTRp7En884hjmrN3HafVO5+Y1FbKyEba5VCEREoqRGUgK/6tuGT0adzIU9WvL8zNX0H/0xT0xdwe69lWf8QIVARCTKGtauwe2DOvLe9X3p3CKNv72zlAH3TuHDJesrxRSZKgQiIjFy9GF1eeaKHoy7rDsJBr96JouLxs5k6botgeZSIRARiSEz4+T2TXn/hn78deCxLM7ewhn3T+Wm8Qv5ftuuQDKpEIiIBCA5MYFLe7di8o39uax3a17J+pb+oyfz6Cdfs2tvfkyzqBCIiAQorVYNbj6rAxNH9qNnm4bc+d4XnPKvT3hv4bqYjR+o15CISCUy9csc/vb2Upat30qP1g35yxkd+DpnG6MnLiM7N++gp8wsrdeQCoGISCWzN38f/8n6ln9NWs4P23eTaEZ+oe/q1ORE7hjcqVzFQE3nRESqkKTEBH55whF8PKo/dVKS9isCUPFTZka1EJjZSDNbbGaLzOxFM6tZwnpDzMzNrNhqJSISj+rVTGb7rr3FPleRU2ZGrRCYWQZwHZDp7h2BRGBoMevVBa4HZkYri4hIVVXSlJklLT8Y0T40lASkmlkSUAvILmad24G7gOJnihYRiWPFTZmZmpzIqAHtKuw9olYI3H0tcDewGlgHbHb3SYXXMbOuQAt3f6e0bZnZcDPLMrOsnJycaEUWEal0ipsys7wDxWVJqrAtFWFmDYCzgdZALvCKmV3k7s+Fn08A/gVcVta23H0MMAZCZw1FK7OISGU0qEtGhX7xFxXNQ0OnACvdPcfd9wDjgd6Fnq8LdAQmm9kqoCfwpgaMRURiK2p7BIQOCfU0s1pAHvBT4McLANx9M9C44LGZTQZudHddJCAiEkPRHCOYCbwKzAEWht9rjJndZmYDo/W+IiJSPrqyWEQkDujKYhERKZEKgYhInFMhEBGJcyoEIiJxToVARCTOqRCIiMS5Knf6qJnlAN8EneMQNQa+DzpEJaLPY3/6PP5Hn8X+DuXzOMLdmxT3RJUrBNWBmWWVdD5vPNLnsT99Hv+jz2J/0fo8dGhIRCTOqRCIiMQ5FYJgjAk6QCWjz2N/+jz+R5/F/qLyeWiMQEQkzmmPQEQkzqkQxJiZpZnZq2b2hZktNbNeQWcKipmNNLPFZrbIzF40s5pBZ4olM3vSzDaY2aJCyxqa2Qdm9mX4Z4MgM8ZSCZ/H6PD/KwvM7HUzSwsyYywV93kUeu63ZuZm1ri415aXCkHs3Qe87+7tgc7A0oDzBMLMMoDrgEx37wgkAkODTRVzTwGnFVn2B+Ajdz8K+Cj8OF48xYGfxwdAR3c/DlgO3BTrUAF6igM/D8ysBXAqocm/KoQKQQyZWX2gHzAWwN13u3tusKkClQSkmlkSUAvIDjhPTLn7FGBjkcVnA0+H7z8NDIppqAAV93m4+yR33xt++BnQPObBAlLCvw+AfwO/AypsgFeFILZaAznAODOba2ZPmFntoEMFwd3XAncT+qtmHbDZ3ScFm6pSOMzd14XvfwccFmSYSuYK4L2gQwTJzM4G1rr7/IrcrgpBbCUBXYFH3L0LsJ342vX/UfjY99mEimM6UNvMLgo2VeXioVP6dFofYGZ/AvYCzwedJSjh+d//CNxc0dtWIYitNcCa8HzOEJrTuWuAeYJ0CrDS3XPcfQ8wHugdcKbKYL2ZNQMI/9wQcJ7AmdllwJnALz2+z3dvS+gPp/lmtorQYbI5Znb4oW5YhSCG3P074Fszaxde9FNgSYCRgrQa6GlmtczMCH0WcTlwXsSbwKXh+5cCbwSYJXBmdhqh4+ED3X1H0HmC5O4L3b2pu7dy91aE/rDsGv5eOSQqBLH3G+B5M1sAHA/8I+A8gQjvFb0KzAEWEvq3GFdXkZrZi8AMoJ2ZrTGzK4E7gZ+Z2ZeE9pruDDJjLJXweTwI1AU+MLN5ZvZooCFjqITPIzrvFd97WiIioj0CEZE4p0IgIhLnVAhEROKcCoGISJxTIRARiXMqBBJT4Y6J9xR6fKOZ3VpB237KzM6tiG2V8T7nhTvHfhzNXGbWyswuLH/CiLd/Wfg9LPx4spllFlmn4LlbCz+W6kWFQGJtFzC4otrnVpRw47tIXQkMc/eTo5UnrBVQrkIQye9hZhlm9gTQAjgRKO3c/FPN7O9ALTP7FXBDefJI1aBCILG2l9CFYyOLPlH0L2cz2xb+2d/MPjGzN8xshZndaWa/NLNZZrbQzNoW2swpZpZlZsvN7Mzw6xPDfe0/D/e1v6rQdqea2ZsUc4W3mV0Q3v4iM7srvOxmQl+eY81sdDGv+X34NfPN7ICLwcxsVUERNLNMM5scvn9S+IKpeeGGhHUJXUzWN7xsZKS/h5nVNrN3whkWmdkvCmcIN/z7E6GCNhS4pkjGhPB/i7+5+0RgInA90Mjd/130d5Kqrzx/BYlUlIeABWb2z3K8pjNwDKG2vCuAJ9y9h5ldT+hq7YK/VFsBPQj1ZfnYzI4ELiHU3bS7maUA08ysoNNpV0L97lcWfjMzSwfuAroBm4BJZjbI3W8zs58AN7p7VpHX/JxQI70T3H2HmTUsx+93IzDC3aeZWR1gJ6GGhDe6e0FBGx7J72FmQ4Bsdz8j/Lr6xfxufwWeBFYS+u9RUAySCDV2W+TufzeznwH9gfuBH8zsene/rxy/l1QB2iOQmHP3LcAzhCamidTn7r7O3XcBXwMFX4ALCX35F3jZ3fe5+5eECkZ7QpN4XGJm84CZQCPgqPD6s4oWgbDuwORwU7yCrpf9ysh4CjCuoCeOuxfXS74k04B/mdl1QFqhHvyFRfp7LCTUpuIuM+vr7psLb8Tds919GKF+T1OBaws9/RjhIhB+/KG7/wnY7u5PECoIUs2oEEhQ7iV0aKLwfAx7Cf+bNLMEoEah53YVur+v0ON97L9nW7RnigMG/Mbdjw/fWhea+2D7If0W5ffj7wj8ODWnu98J/ApIJfSXfvtiXhvR7+HuywntISwE/hY+nHUAd3/K3VcV6eg5HTjZwtOGFjzn7rcWfizViwqBBCL81/LLhIpBgVWEDsUADASSD2LT54WPcbcF2gDLCB3jvsbMkgHM7Ggre0KgWcBJZtbYzBKBC4BPynjNB8DlFuobTwmHhlbxv99xSMFCM2sb7i55F/A5oT2ZrYQarhWI6PcIH/rZ4e7PAaMpX6vzscC7wMvlHECXKkz/oSVI9wC/LvT4ceANM5sPvM/B/bW+mtCXeD3ganffGT5DphWh3u1GaJa4UqeAdPd1ZvYH4GNCf4m/4+6ltoR29/fN7Hggy8x2E/pC/WOR1f5KaKD5dmByoeU3mNnJhPZwFhOaiWsfkB/+PJ4iNN91JL9HJ2C0me0D9lBkMLgs7v6v8LjCs2b2S3ffV57XS9Wj7qMiInFOh4ZEROKcCoGISJxTIRARiXMqBCIicU6FQEQkzqkQiIjEORUCEZE4p0IgIhLn/h83PZq5w+Q4dQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "elbow3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jLoXe5NXDyQ3"
   },
   "source": [
    "The optimal k for Kmeans algorithm with Random Partition as initial clusters’ centroids with Euclidean Distance : k=13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-S68aH7s-xS2"
   },
   "outputs": [],
   "source": [
    "# 4. Kmeans algorithm with Random Partitioning as initial clusters’ centroids with Manhattan Distance\n",
    "\n",
    "class Kmeans4:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Manhattan_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def nearest_\n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      print()\n",
    "      #self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      indices = np.random.choice(range(0,self.k), replace = True, size = self.X.shape[0])\n",
    "      mean = []\n",
    "      for count in range(self.k):\n",
    "          mean.append(X[indices == count].mean(axis=0))\n",
    "          \n",
    "      self.centroids= np.concatenate([val[ None, :] for val in mean], axis = 0)\n",
    "\n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0][0])\n",
    "        \n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels\n",
    "          break\n",
    "      return self.centroids , self.labels\n",
    "    \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result[0][0])\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "#implement elbow method from scratch\n",
    "def elbow4():\n",
    "  \n",
    "  sse = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"Homogenity Score for k=\",end=\" \")\n",
    "    print(k,end=\" \")\n",
    "    obj=Kmeans4(k)\n",
    "    centroids,labels = obj.fit(x_train)\n",
    "    #print(y_train.shape)\n",
    "    #print(len(labels))\n",
    "    print(homogeneity_score(np.squeeze(y_train),labels))\n",
    "    cost=0.0\n",
    "    for i in range(len(x_train)):\n",
    "      temp=Manhattan_distance(x_train[i],centroids[labels[i]])\n",
    "      cost+=temp\n",
    "    sse.append(float(cost))\n",
    "    #print(cost)\n",
    "    del obj\n",
    "    del centroids\n",
    "    del labels\n",
    "    del cost\n",
    "    del temp\n",
    "    \n",
    "  print(sse)\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, sse, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Elbow Score with manhattan dist');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 801
    },
    "id": "YKCyuQcX_Nc4",
    "outputId": "c2cc05c4-7666-4db0-a528-4b452017069c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Homogenity Score for k= 5 \n",
      "0.3778169552379457\n",
      "Homogenity Score for k= 6 \n",
      "0.42236018378599793\n",
      "Homogenity Score for k= 7 \n",
      "0.4420662112165433\n",
      "Homogenity Score for k= 8 \n",
      "0.47512053132018567\n",
      "Homogenity Score for k= 9 \n",
      "0.47613745551078074\n",
      "Homogenity Score for k= 10 \n",
      "0.5185315551264945\n",
      "Homogenity Score for k= 11 \n",
      "0.5440771784496173\n",
      "Homogenity Score for k= 12 \n",
      "0.5246012130958547\n",
      "Homogenity Score for k= 13 \n",
      "0.5507414955252112\n",
      "Homogenity Score for k= 14 \n",
      "0.568944340133489\n",
      "[1943402389.4610496, 1789322638.9293015, 1745009281.6512604, 1685314873.631742, 1650056329.3582518, 1612624053.717416, 1583033652.8021123, 1551284890.1455877, 1522465647.6294475, 1501267661.1612194]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "elbow4()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IVR40LCtEBeC"
   },
   "source": [
    "The optimal k for Kmeans algorithm with Random Partitioning as initial clusters’ centroids with Manhattan Distance : k=12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "tCUo16MUDzi-"
   },
   "outputs": [],
   "source": [
    "# 5. Kmeans++ algorithm with Euclidean Distance\n",
    "\n",
    "class Kmeansplusplus1:\n",
    "  def __init__(self,k):\n",
    "    self.k=k\n",
    "    self.epoch=90\n",
    "  \n",
    "  def initial_centroid(self,X):\n",
    "    self.centroids = [] \n",
    "    self.centroids.append(X[np.random.randint( X.shape[0]), :]) \n",
    "    for c_id in range(self.k - 1): \n",
    "        dist = [] \n",
    "        for i in range(X.shape[0]): \n",
    "            point = X[i, :] \n",
    "            d = sys.maxsize \n",
    "            for j in range(len(self.centroids)): \n",
    "                temp_dist = Euclidean_distance(point, self.centroids[j]) \n",
    "                d = min(d, temp_dist) \n",
    "            dist.append(d) \n",
    "        dist = np.array(dist) \n",
    "        next_centroid = X[np.argmax(dist), :] \n",
    "        self.centroids.append(next_centroid) \n",
    "    return self.centroids \n",
    "\n",
    "  def calc_dist(self,X):\n",
    "    self.dist=[]\n",
    "    for i in range(X.shape[0]):\n",
    "      d=[]\n",
    "      for j in range(len(self.centroids)):\n",
    "        d.append(Euclidean_distance(X[i] , self.centroids[j]))\n",
    "      self.dist.append(d)\n",
    "      d=[]\n",
    "    return self.dist\n",
    "\n",
    "  def second_nearest_cluster(self):\n",
    "    self.labels2=[]\n",
    "    for i in self.dist:\n",
    "      result = i.index(sorted(i)[1])\n",
    "      self.labels2.append(result)\n",
    "    return self.labels2\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        centroids=np.array(centroids)\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key,:] , axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "        \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return new_centroids\n",
    "\n",
    "  def train_centroids(self,X,centroids):\n",
    "    self.centroids=centroids\n",
    "    for i in range(self.epoch):\n",
    "        self.labels1=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #print(\"***************\")\n",
    "        #print(self.old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels1.append(result[0][0])\n",
    "        \n",
    "        self.centroids=self.calc_centroids(self.labels1,X)\n",
    "\n",
    "        #if np.all(self.old_centroids == self.centroids):\n",
    "          #return self.centroids,self.labels1\n",
    "          #break\n",
    "    return self.centroids , self.labels1\n",
    " \n",
    "\n",
    " #implement elbow method from scratch\n",
    "def elbow5(X): #kmeans++\n",
    "  sse = []\n",
    "  list_k = list(range(5, 15))\n",
    "  #list_k=[7]\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k,end =\" Homogeneity Score: \")\n",
    "    obj=Kmeansplusplus1(k)\n",
    "    centroids=obj.initial_centroid(X)\n",
    "    #print(len(centroids))\n",
    "    #print(len(centroids[0]))\n",
    "    centroids,labels1=obj.train_centroids(X,centroids)\n",
    "    #print(centroids.shape)\n",
    "    dist=obj.calc_dist(X)\n",
    "    label2=obj.second_nearest_cluster()\n",
    "\n",
    "    print(homogeneity_score(np.squeeze(y_test),labels1))\n",
    "    cost=0.0\n",
    "    for i in range(len(X)):\n",
    "      temp=Euclidean_distance(X[i],centroids[labels1[i]])\n",
    "      cost+=temp\n",
    "    sse.append(float(cost))\n",
    "    #print(cost)\n",
    "    del obj\n",
    "    del centroids\n",
    "    del labels1\n",
    "    del dist\n",
    "    del label2\n",
    "    del cost\n",
    "    del temp\n",
    "    \n",
    "  print(sse)\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, sse, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Elbow Score with euclidean dist');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 619
    },
    "id": "99efzfBg9L2O",
    "outputId": "5fcb1c8f-d160-4577-8337-3a3705f670af"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5 Homogeneity Score: 0.31460798876215096\n",
      "k= 6 Homogeneity Score: 0.27300970535125446\n",
      "k= 7 Homogeneity Score: 0.32345475263759216\n",
      "k= 8 Homogeneity Score: 0.40020632269004885\n",
      "k= 9 Homogeneity Score: 0.34973219059353117\n",
      "k= 10 Homogeneity Score: 0.30545732952186555\n",
      "k= 11 Homogeneity Score: 0.41534054665824394\n",
      "k= 12 Homogeneity Score: 0.39414799880934764\n",
      "k= 13 Homogeneity Score: 0.3961911726894886\n",
      "k= 14 Homogeneity Score: 0.37570450275707884\n",
      "[11415096.48915442, 11473901.735877937, 10872213.941953389, 10465240.768764947, 10513702.087887207, 10936487.106885824, 10224353.071338808, 10350127.270538086, 10377149.027743118, 10494998.319395041]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "elbow5(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "saa_YFnVEKfg"
   },
   "source": [
    "Optimal k for Kmeans++ algorithm with Euclidean Distance for elbow: k=13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "qlVTwN4U_ogm"
   },
   "outputs": [],
   "source": [
    "# 6. Kmeans++ algorithm with Manhattan_distance with elbow\n",
    "\n",
    "class Kmeansplusplus2:\n",
    "  def __init__(self,k):\n",
    "    self.k=k\n",
    "    self.epoch=2\n",
    "  \n",
    "  def initial_centroid(self,X):\n",
    "    self.centroids = [] \n",
    "    self.centroids.append(X[np.random.randint( X.shape[0]), :]) \n",
    "    for c_id in range(self.k - 1): \n",
    "        dist = [] \n",
    "        for i in range(X.shape[0]): \n",
    "            point = X[i, :] \n",
    "            d = sys.maxsize \n",
    "            for j in range(len(self.centroids)): \n",
    "                temp_dist = Manhattan_distance(point, self.centroids[j]) \n",
    "                d = min(d, temp_dist) \n",
    "            dist.append(d) \n",
    "        dist = np.array(dist) \n",
    "        next_centroid = X[np.argmax(dist), :] \n",
    "        self.centroids.append(next_centroid) \n",
    "    return self.centroids \n",
    "\n",
    "  def calc_dist(self,X):\n",
    "    self.dist=[]\n",
    "    for i in range(X.shape[0]):\n",
    "      d=[]\n",
    "      for j in range(len(self.centroids)):\n",
    "        d.append(Manhattan_distance(X[i] , self.centroids[j]))\n",
    "      self.dist.append(d)\n",
    "      d=[]\n",
    "    return self.dist\n",
    "\n",
    "  def second_nearest_cluster(self):\n",
    "    self.labels2=[]\n",
    "    for i in self.dist:\n",
    "      result = i.index(sorted(i)[1])\n",
    "      self.labels2.append(result)\n",
    "    return self.labels2\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        centroids=np.array(centroids)\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key,:] , axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "        \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return new_centroids\n",
    "\n",
    "  def train_centroids(self,X,centroids):\n",
    "    self.centroids=centroids\n",
    "    for i in range(self.epoch):\n",
    "        self.labels1=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #print(\"***************\")\n",
    "        #print(self.old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels1.append(result[0][0])\n",
    "        \n",
    "        self.centroids=self.calc_centroids(self.labels1,X)\n",
    "\n",
    "        #if np.all(self.old_centroids == self.centroids):\n",
    "          #return self.centroids,self.labels1\n",
    "          #break\n",
    "    return self.centroids , self.labels1\n",
    " \n",
    "\n",
    " #implement elbow method from scratch\n",
    "def elbow6(X): #kmeans++\n",
    "  sse = []\n",
    "  list_k = list(range(5, 15))\n",
    "  #list_k=[7]\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k,end =\" Homogeneity Score: \")\n",
    "    \n",
    "    obj=Kmeansplusplus2(k)\n",
    "    centroids=obj.initial_centroid(X)\n",
    "    #print(len(centroids))\n",
    "    #print(len(centroids[0]))\n",
    "    centroids,labels1=obj.train_centroids(X,centroids)\n",
    "    #print(centroids.shape)\n",
    "    dist=obj.calc_dist(X)\n",
    "    label2=obj.second_nearest_cluster()\n",
    "\n",
    "    print(homogeneity_score(np.squeeze(y_test),labels1))\n",
    "    cost=0.0\n",
    "    for i in range(len(X)):\n",
    "      temp=Manhattan_distance(X[i],centroids[labels1[i]])\n",
    "      cost+=temp\n",
    "    sse.append(float(cost))\n",
    "    #print(cost)\n",
    "    del obj\n",
    "    del centroids\n",
    "    del labels1\n",
    "    del dist\n",
    "    del label2\n",
    "    del cost\n",
    "    del temp\n",
    "    \n",
    "  print(sse)\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, sse, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Elbow score with manhattan');\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 619
    },
    "id": "GVdWa0agBj6z",
    "outputId": "f17c95b2-aad6-4071-8942-b53238ed15e0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5 Homogeneity Score: 0.18200994345613353\n",
      "k= 6 Homogeneity Score: 0.3701145757618918\n",
      "k= 7 Homogeneity Score: 0.36732837646138233\n",
      "k= 8 Homogeneity Score: 0.3380954311503582\n",
      "k= 9 Homogeneity Score: 0.39049658045671837\n",
      "k= 10 Homogeneity Score: 0.42874051284980036\n",
      "k= 11 Homogeneity Score: 0.3942256272338468\n",
      "k= 12 Homogeneity Score: 0.42360254086307103\n",
      "k= 13 Homogeneity Score: 0.3743964285435551\n",
      "k= 14 Homogeneity Score: 0.4065597472841552\n",
      "[246361580.36061692, 211185498.32167, 206584798.89261863, 208142362.99874213, 196669596.55456224, 191445406.68807888, 196182452.14844656, 192079293.5210059, 199078284.8452176, 193530372.17358586]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "elbow6(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I9mAAl9AEiJz"
   },
   "source": [
    "The optimal k for Kmeans++ algorithm with Manhattan_distance with elbow : k=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "id": "PY69AAyBHqNr"
   },
   "outputs": [],
   "source": [
    "# 7. Kmeans++ algorithm with Euclidean Distance - silhouette\n",
    "class Kmeansplusplus1:\n",
    "  def __init__(self,k):\n",
    "    self.k=k\n",
    "    self.epoch=90\n",
    "  \n",
    "  def initial_centroid(self,X):\n",
    "    self.centroids = [] \n",
    "    self.centroids.append(X[np.random.randint( X.shape[0]), :]) \n",
    "    for c_id in range(self.k - 1): \n",
    "        dist = [] \n",
    "        for i in range(X.shape[0]): \n",
    "            point = X[i, :] \n",
    "            d = sys.maxsize \n",
    "            for j in range(len(self.centroids)): \n",
    "                temp_dist = Euclidean_distance(point, self.centroids[j]) \n",
    "                d = min(d, temp_dist) \n",
    "            dist.append(d) \n",
    "        dist = np.array(dist) \n",
    "        next_centroid = X[np.argmax(dist), :] \n",
    "        self.centroids.append(next_centroid) \n",
    "    return self.centroids \n",
    "\n",
    "  def calc_dist(self,X):\n",
    "    self.dist=[]\n",
    "    for i in range(X.shape[0]):\n",
    "      d=[]\n",
    "      for j in range(len(self.centroids)):\n",
    "        d.append(Euclidean_distance(X[i] , self.centroids[j]))\n",
    "      self.dist.append(d)\n",
    "      d=[]\n",
    "    return self.dist\n",
    "\n",
    "  def second_nearest_cluster(self):\n",
    "    self.labels2=[]\n",
    "    for i in self.dist:\n",
    "      result = i.index(sorted(i)[1])\n",
    "      self.labels2.append(result)\n",
    "    return self.labels2\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        centroids=np.array(centroids)\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key,:] , axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "        \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return new_centroids\n",
    "\n",
    "  def train_centroids(self,X,centroids):\n",
    "    self.centroids=centroids\n",
    "    for i in range(self.epoch):\n",
    "        self.labels1=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #print(\"***************\")\n",
    "        #print(self.old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels1.append(result[0][0])\n",
    "        \n",
    "        self.centroids=self.calc_centroids(self.labels1,X)\n",
    "\n",
    "        #if np.all(self.old_centroids == self.centroids):\n",
    "          #return self.centroids,self.labels1\n",
    "          #break\n",
    "    return self.centroids , self.labels1\n",
    "\n",
    "def silhouette(X): #for kmeans1++\n",
    "  silhouette = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k)\n",
    "    \n",
    "    obj=Kmeansplusplus1(k)\n",
    "    centroids=obj.initial_centroid(X)\n",
    "    centroids,labels1=obj.train_centroids(X,centroids)\n",
    "    dist=obj.calc_dist(X) \n",
    "    label2=obj.second_nearest_cluster()\n",
    "    #labels1=labels1.to_list()\n",
    "    sse1=0\n",
    "    for pt in range(len(X)):\n",
    "      a=0\n",
    "      b=0\n",
    "      cluster_index=labels1[pt]\n",
    "      #print(\"cluster index:\",end=\" \")\n",
    "      #print(cluster_index)\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster_index:\n",
    "          points_idx.append(abc)\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        #print(type(xx))\n",
    "        #print(type(yy))\n",
    "        a = a + Euclidean_distance(xx,yy)\n",
    "      a=a/len(points_idx)\n",
    "\n",
    "      cluster2_index=label2[pt]\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster2_index:\n",
    "          points_idx.append(abc)\n",
    "\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        b = b + Euclidean_distance(xx,yy)\n",
    "      b=b/len(points_idx)\n",
    "      sil_coeff=(b-a)/max(a,b)\n",
    "      sse1+= sil_coeff\n",
    "    sse1=sse1/len(X)\n",
    "    print(sse1)\n",
    "    silhouette.append(sse1)\n",
    "\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, silhouette, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Silhouette Distance');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 752
    },
    "id": "d19uxv8W9M41",
    "outputId": "c3041c17-765b-4cce-f5e8-dd641d007d19"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5\n",
      "0.16754246870262102\n",
      "k= 6\n",
      "0.14580543302759696\n",
      "k= 7\n",
      "0.17462060212854894\n",
      "k= 8\n",
      "0.17511392169859982\n",
      "k= 9\n",
      "0.1666231395605513\n",
      "k= 10\n",
      "0.1508389091498108\n",
      "k= 11\n",
      "0.1534786284802324\n",
      "k= 12\n",
      "0.17337791902996408\n",
      "k= 13\n",
      "0.15711738528604435\n",
      "k= 14\n",
      "0.14776966011757048\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 7th kmeans++ with silhouette\n",
    "silhouette(x_test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "itHrwNtuEpHN"
   },
   "source": [
    "The optimal k for Kmeans++ algorithm with Euclidean Distance - silhouette : k=8 or k=12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "vqwdEmkCH1Kj"
   },
   "outputs": [],
   "source": [
    "# 8. Kmeans algorithm with Forgy as initial clusters’ centroids with Euclidean Distance : Silhouette\n",
    "class Kmeans8:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "    self.labels=[]\n",
    "    self.label2=[]\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Euclidean_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      print()\n",
    "      self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      \n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.label2=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0][0])\n",
    "          self.label2.append(j.tolist().index(sorted(j)[1]))\n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels, self.label2\n",
    "          break\n",
    "      return self.centroids , self.labels, self.label2\n",
    "    \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result[0][0])\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "def silhouette8(X): #for kmeans\n",
    "  silhouette = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k)\n",
    "    \n",
    "    obj=Kmeans8(k)\n",
    "    centroids,labels1,label2 = obj.fit(X)\n",
    "\n",
    "    #labels1=labels1.to_list()\n",
    "    sse1=0\n",
    "    for pt in range(len(X)):\n",
    "      a=0\n",
    "      b=0\n",
    "      cluster_index=labels1[pt]\n",
    "      #print(\"cluster index:\",end=\" \")\n",
    "      #print(cluster_index)\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster_index:\n",
    "          points_idx.append(abc)\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        #print(type(xx))\n",
    "        #print(type(yy))\n",
    "        a = a + Euclidean_distance(xx,yy)\n",
    "      a=a/len(points_idx)\n",
    "\n",
    "      cluster2_index=label2[pt]\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster2_index:\n",
    "          points_idx.append(abc)\n",
    "\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        b = b + Euclidean_distance(xx,yy)\n",
    "      b=b/len(points_idx)\n",
    "      sil_coeff=(b-a)/max(a,b)\n",
    "      sse1+= sil_coeff\n",
    "    sse1=sse1/len(X)\n",
    "    print(sse1)\n",
    "    silhouette.append(sse1)\n",
    "\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, silhouette, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Silhouette Distance');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 935
    },
    "id": "cHe0mRcORl6D",
    "outputId": "8b7cccc2-0854-4715-a8bb-4d24a11dcd61"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5\n",
      "\n",
      "0.1687649141560256\n",
      "k= 6\n",
      "\n",
      "0.16852338177793205\n",
      "k= 7\n",
      "\n",
      "0.16398368889928233\n",
      "k= 8\n",
      "\n",
      "0.16672425038863012\n",
      "k= 9\n",
      "\n",
      "0.13990323432289317\n",
      "k= 10\n",
      "\n",
      "0.15493714535430658\n",
      "k= 11\n",
      "\n",
      "0.14764674512146822\n",
      "k= 12\n",
      "\n",
      "0.1462508403835588\n",
      "k= 13\n",
      "\n",
      "0.14536811463676347\n",
      "k= 14\n",
      "\n",
      "0.14313850118662214\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "silhouette8(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FY4RvMg4E2UA"
   },
   "source": [
    "The optimal k for Kmeans algorithm with Forgy as initial clusters’ centroids with Euclidean Distance : Silhouette : k=8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "id": "Vsncsrzq3Ls2"
   },
   "outputs": [],
   "source": [
    "# 9. Kmeans++ algorithm with Manhattan_distance - silhouette\n",
    "\n",
    "class Kmeansplusplus4:\n",
    "  def __init__(self,k):\n",
    "    self.k=k\n",
    "    self.epoch=90\n",
    "  \n",
    "  def initial_centroid(self,X):\n",
    "    self.centroids = [] \n",
    "    self.centroids.append(X[np.random.randint( X.shape[0]), :]) \n",
    "    for c_id in range(self.k - 1): \n",
    "        dist = [] \n",
    "        for i in range(X.shape[0]): \n",
    "            point = X[i, :] \n",
    "            d = sys.maxsize \n",
    "            for j in range(len(self.centroids)): \n",
    "                temp_dist = Manhattan_distance(point, self.centroids[j]) \n",
    "                d = min(d, temp_dist) \n",
    "            dist.append(d) \n",
    "        dist = np.array(dist) \n",
    "        next_centroid = X[np.argmax(dist), :] \n",
    "        self.centroids.append(next_centroid) \n",
    "    return self.centroids \n",
    "\n",
    "  def calc_dist(self,X):\n",
    "    self.dist=[]\n",
    "    for i in range(X.shape[0]):\n",
    "      d=[]\n",
    "      for j in range(len(self.centroids)):\n",
    "        d.append(Manhattan_distance(X[i] , self.centroids[j]))\n",
    "      self.dist.append(d)\n",
    "      d=[]\n",
    "    return self.dist\n",
    "\n",
    "  def second_nearest_cluster(self):\n",
    "    self.labels2=[]\n",
    "    for i in self.dist:\n",
    "      result = i.index(sorted(i)[1])\n",
    "      self.labels2.append(result)\n",
    "    return self.labels2\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        centroids=np.array(centroids)\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key,:] , axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "        \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return new_centroids\n",
    "\n",
    "  def train_centroids(self,X,centroids):\n",
    "    self.centroids=centroids\n",
    "    for i in range(self.epoch):\n",
    "        self.labels1=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #print(\"***************\")\n",
    "        #print(self.old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels1.append(result[0][0])\n",
    "        \n",
    "        self.centroids=self.calc_centroids(self.labels1,X)\n",
    "\n",
    "        #if np.all(self.old_centroids == self.centroids):\n",
    "          #return self.centroids,self.labels1\n",
    "          #break\n",
    "    return self.centroids , self.labels1\n",
    "\n",
    "def silhouette(X): #for kmeans1++\n",
    "  silhouette = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k)\n",
    "    \n",
    "    obj=Kmeansplusplus4(k)\n",
    "    centroids=obj.initial_centroid(X)\n",
    "    centroids,labels1=obj.train_centroids(X,centroids)\n",
    "    dist=obj.calc_dist(X) \n",
    "    label2=obj.second_nearest_cluster()\n",
    "    #labels1=labels1.to_list()\n",
    "    sse1=0\n",
    "    for pt in range(len(X)):\n",
    "      a=0\n",
    "      b=0\n",
    "      cluster_index=labels1[pt]\n",
    "      #print(\"cluster index:\",end=\" \")\n",
    "      #print(cluster_index)\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster_index:\n",
    "          points_idx.append(abc)\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        #print(type(xx))\n",
    "        #print(type(yy))\n",
    "        a = a + Euclidean_distance(xx,yy)\n",
    "      a=a/len(points_idx)\n",
    "\n",
    "      cluster2_index=label2[pt]\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster2_index:\n",
    "          points_idx.append(abc)\n",
    "\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        b = b + Euclidean_distance(xx,yy)\n",
    "      b=b/len(points_idx)\n",
    "      sil_coeff=(b-a)/max(a,b)\n",
    "      sse1+= sil_coeff\n",
    "    sse1=sse1/len(X)\n",
    "    print(sse1)\n",
    "    silhouette.append(sse1)\n",
    "\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, silhouette, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Silhouette Distance');\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 752
    },
    "id": "BtTjp4dv7vhx",
    "outputId": "50dbf8ca-ca8d-428e-9b4a-39cd67757699"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5\n",
      "0.23556175605776308\n",
      "k= 6\n",
      "0.23952205874400895\n",
      "k= 7\n",
      "0.2624360193217898\n",
      "k= 8\n",
      "0.24344131401528316\n",
      "k= 9\n",
      "0.28485603051189107\n",
      "k= 10\n",
      "0.30180313818749827\n",
      "k= 11\n",
      "0.3243501572615891\n",
      "k= 12\n",
      "0.339873566262845\n",
      "k= 13\n",
      "0.2875343019573284\n",
      "k= 14\n",
      "0.3030965714788555\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "silhouette(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6VlzPzK9E_pq"
   },
   "source": [
    "The optimal k for Kmeans++ algorithm with Manhattan_distance - silhouette: k=12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "h9RhfVsn8LWF"
   },
   "outputs": [],
   "source": [
    "#10. Kmeans algorithm with Random Partitioning as initial clusters’ centroids with Manhattan Distance – silhouette\n",
    "\n",
    "class Kmeans10:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "    self.labels=[]\n",
    "    self.label2=[]\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Manhattan_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      print()\n",
    "      #self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      indices = np.random.choice(range(0,self.k), replace = True, size = self.X.shape[0])\n",
    "      mean = []\n",
    "      for count in range(self.k):\n",
    "          mean.append(X[indices == count].mean(axis=0))\n",
    "          \n",
    "      self.centroids= np.concatenate([val[ None, :] for val in mean], axis = 0)\n",
    "\n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.label2=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0][0])\n",
    "          self.label2.append(j.tolist().index(sorted(j)[1]))\n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels, self.label2\n",
    "          break\n",
    "      return self.centroids , self.labels, self.label2\n",
    "    \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result[0][0])\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "def silhouette10(X): #for kmeans\n",
    "  silhouette = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k)\n",
    "    \n",
    "    obj=Kmeans8(k)\n",
    "    centroids,labels1,label2 = obj.fit(X)\n",
    "\n",
    "    #labels1=labels1.to_list()\n",
    "    sse1=0\n",
    "    for pt in range(len(X)):\n",
    "      a=0\n",
    "      b=0\n",
    "      cluster_index=labels1[pt]\n",
    "      #print(\"cluster index:\",end=\" \")\n",
    "      #print(cluster_index)\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster_index:\n",
    "          points_idx.append(abc)\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        #print(type(xx))\n",
    "        #print(type(yy))\n",
    "        a = a + Manhattan_distance(xx,yy)\n",
    "      a=a/len(points_idx)\n",
    "\n",
    "      cluster2_index=label2[pt]\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster2_index:\n",
    "          points_idx.append(abc)\n",
    "\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        b = b + Manhattan_distance(xx,yy)\n",
    "      b=b/len(points_idx)\n",
    "      sil_coeff=(b-a)/max(a,b)\n",
    "      sse1+= sil_coeff\n",
    "    sse1=sse1/len(X)\n",
    "    print(sse1)\n",
    "    silhouette.append(sse1)\n",
    "\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, silhouette, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Silhouette Distance');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 934
    },
    "id": "lJKWxkBgCNM6",
    "outputId": "0399ed30-4cb9-40b8-b09e-7f0c01a3b873"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5\n",
      "\n",
      "0.2790794848192812\n",
      "k= 6\n",
      "\n",
      "0.29014770396392664\n",
      "k= 7\n",
      "\n",
      "0.24288761250942084\n",
      "k= 8\n",
      "\n",
      "0.22572229867577895\n",
      "k= 9\n",
      "\n",
      "0.2730097890712932\n",
      "k= 10\n",
      "\n",
      "0.25443333140865687\n",
      "k= 11\n",
      "\n",
      "0.24793404432288602\n",
      "k= 12\n",
      "\n",
      "0.25325043775434286\n",
      "k= 13\n",
      "\n",
      "0.24819110313201068\n",
      "k= 14\n",
      "\n",
      "0.26084196847752017\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "silhouette10(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KIZvRcJqFEsE"
   },
   "source": [
    "The optimal k for Kmeans algorithm with Random Partitioning as initial clusters’ centroids with Manhattan Distance – silhouette : k=9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "id": "a5GJ-UzRCh62"
   },
   "outputs": [],
   "source": [
    "#11. Kmeans algorithm with Random Partition as initial clusters’ centroids with Euclidean Distance – Silhoutte\n",
    "\n",
    "class Kmeans11:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "    self.labels=[]\n",
    "    self.label2=[]\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Euclidean_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      #print()\n",
    "      #self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      indices = np.random.choice(range(0,self.k -1), replace = True, size = self.X.shape[0])\n",
    "      mean = []\n",
    "      for count in range(self.k):\n",
    "          mean.append(X[indices == count].mean(axis=0))\n",
    "          \n",
    "      self.centroids= np.concatenate([val[ None, :] for val in mean], axis = 0)\n",
    "\n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.label2=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0])\n",
    "          self.label2.append(j.tolist().index(sorted(j)[1]))\n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels, self.label2\n",
    "          break\n",
    "      return self.centroids , self.labels, self.label2\n",
    "    \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result[0][0])\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "def silhouette11(X): #for kmeans\n",
    "  silhouette = []\n",
    "  list_k = list(range(5, 11))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k)\n",
    "    \n",
    "    obj=Kmeans11(k)\n",
    "    centroids,labels1,label2 = obj.fit(X)\n",
    "\n",
    "    #labels1=labels1.to_list()\n",
    "    sse1=0\n",
    "    for pt in range(len(X)):\n",
    "      a=0\n",
    "      b=0\n",
    "      cluster_index=labels1[pt]\n",
    "      #print(\"cluster index:\",end=\" \")\n",
    "      #print(cluster_index)\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster_index:\n",
    "          points_idx.append(abc)\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        #print(type(xx))\n",
    "        #print(type(yy))\n",
    "        a = a + Euclidean_distance(xx,yy)\n",
    "      a=a/len(points_idx)\n",
    "\n",
    "      cluster2_index=label2[pt]\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster2_index:\n",
    "          points_idx.append(abc)\n",
    "\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        b = b + Euclidean_distance(xx,yy)\n",
    "      b=b/len(points_idx)\n",
    "      sil_coeff=(b-a)/max(a,b)\n",
    "      sse1+= sil_coeff\n",
    "    sse1=sse1/len(X)\n",
    "    print(sse1)\n",
    "    silhouette.append(sse1)\n",
    "\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, silhouette, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Silhouette Distance');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 388
    },
    "id": "4dO4-8R6C7YY",
    "outputId": "c393c40a-d7ee-4b42-cdf5-dd877981a65e"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "silhouette11(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bKm0YH-eFKAs"
   },
   "source": [
    "The optimal k for Kmeans algorithm with Random Partition as initial clusters’ centroids with Euclidean Distance – Silhoutte : k=17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "id": "ciyYepnoEvqh"
   },
   "outputs": [],
   "source": [
    "#12.  Kmeans algorithm with Forgy as initial clusters’ centroids with Manhattan Distance - Silhoutte\n",
    "\n",
    "class Kmeans12:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "    self.labels=[]\n",
    "    self.label2=[]\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Manhattan_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      print()\n",
    "      self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      \n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.label2=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0][0])\n",
    "          self.label2.append(j.tolist().index(sorted(j)[1]))\n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels, self.label2\n",
    "          break\n",
    "      return self.centroids , self.labels, self.label2\n",
    "    \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result[0][0])\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "def silhouette12(X): #for kmeans\n",
    "  silhouette = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k)\n",
    "    \n",
    "    obj=Kmeans8(k)\n",
    "    centroids,labels1,label2 = obj.fit(X)\n",
    "\n",
    "    #labels1=labels1.to_list()\n",
    "    sse1=0\n",
    "    for pt in range(len(X)):\n",
    "      a=0\n",
    "      b=0\n",
    "      cluster_index=labels1[pt]\n",
    "      #print(\"cluster index:\",end=\" \")\n",
    "      #print(cluster_index)\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster_index:\n",
    "          points_idx.append(abc)\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        #print(type(xx))\n",
    "        #print(type(yy))\n",
    "        a = a + Manhattan_distance(xx,yy)\n",
    "      a=a/len(points_idx)\n",
    "\n",
    "      cluster2_index=label2[pt]\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster2_index:\n",
    "          points_idx.append(abc)\n",
    "\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        b = b + Manhattan_distance(xx,yy)\n",
    "      b=b/len(points_idx)\n",
    "      sil_coeff=(b-a)/max(a,b)\n",
    "      sse1+= sil_coeff\n",
    "    sse1=sse1/len(X)\n",
    "    print(sse1)\n",
    "    silhouette.append(sse1)\n",
    "\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, silhouette, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Silhouette Distance');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 934
    },
    "id": "cilG5w8sFpvz",
    "outputId": "055f2417-00d3-405a-a418-18f8b2e40363"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5\n",
      "\n",
      "0.19551376179836166\n",
      "k= 6\n",
      "\n",
      "0.22519747661554015\n",
      "k= 7\n",
      "\n",
      "0.23067909314113696\n",
      "k= 8\n",
      "\n",
      "0.2145150932229864\n",
      "k= 9\n",
      "\n",
      "0.230429281795398\n",
      "k= 10\n",
      "\n",
      "0.20111466810950043\n",
      "k= 11\n",
      "\n",
      "0.19524339154378031\n",
      "k= 12\n",
      "\n",
      "0.20321171588593112\n",
      "k= 13\n",
      "\n",
      "0.2086466484883026\n",
      "k= 14\n",
      "\n",
      "0.17916332528638604\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "silhouette12(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jTqfgv5kFPo3"
   },
   "source": [
    "The optimal k for Kmeans algorithm with Forgy as initial clusters’ centroids with Manhattan Distance - Silhoutte : k=9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Y_GcuETgZQQ4"
   },
   "source": [
    "6) Report the training and the validation accuracy and Compare your trained model with a model trained by the scikit-learn\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WYHsNvSbBdhI"
   },
   "source": [
    "a) The training & validation accuracy is calculated in every part above.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4ER5nmvuZP7a",
    "outputId": "3a2f5304-df6f-4b38-da83-59ff9ff682bc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the homogeneity score for k=1 is  1.4497463971619185e-16\n",
      "the homogeneity score for k=2 is  0.1088167937971938\n",
      "the homogeneity score for k=3 is  0.23331767313934967\n",
      "the homogeneity score for k=4 is  0.31055438154200893\n",
      "the homogeneity score for k=5 is  0.3843342526920181\n",
      "the homogeneity score for k=6 is  0.4247708734291836\n",
      "the homogeneity score for k=7 is  0.4631663123606289\n",
      "the homogeneity score for k=8 is  0.5139710506229429\n",
      "the homogeneity score for k=9 is  0.514815117334776\n",
      "the homogeneity score for k=10 is  0.5312538372831244\n",
      "the homogeneity score for k=11 is  0.5742601189836939\n",
      "the homogeneity score for k=12 is  0.553732594115303\n",
      "the homogeneity score for k=13 is  0.5584329770013573\n",
      "the homogeneity score for k=14 is  0.5837148702690793\n",
      "the homogeneity score for k=15 is  0.5956422077791832\n",
      "the homogeneity score for k=16 is  0.5810037850363586\n",
      "the homogeneity score for k=17 is  0.6210107163273137\n",
      "the homogeneity score for k=18 is  0.6196327274575948\n",
      "the homogeneity score for k=19 is  0.6139214255857238\n",
      "the homogeneity score for k=20 is  0.6267033020304412\n"
     ]
    }
   ],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "from sklearn.metrics.cluster import homogeneity_score\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "for i in range(20):\n",
    "  km=KMeans(n_clusters=i+1, random_state=42).fit(x_train)\n",
    "  clusters=km.labels_\n",
    "  print(\"the homogeneity score for k={0} is \".format(i+1),homogeneity_score(y_train.flatten(),clusters))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "siEiw47u-A3A"
   },
   "source": [
    "**Part 2:**\n",
    "</br>\n",
    "In this task, you will perform operations on `[data.csv](https://drive.google.com/file/d/15NPkfXFoTkiRBlcI4ffe_Lp_BFOyf8UY/view?usp=sharing)`, data.csv is a  latent space representation of  Fashion-MNIST, before doing this task please read about latent space representation.\n",
    "\n",
    "9) Load the data.csv file and apply Kmeans and Kmeans++, You need to find the optimal number of clusters using the elbow method and silhouette method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YKw_O2isNtnk"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.preprocessing import LabelEncoder  #for label encoding\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy.linalg import norm\n",
    "import pandas as pd\n",
    "from sklearn.metrics.cluster import homogeneity_score\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 247
    },
    "id": "dDGPHO0Q9l7I",
    "outputId": "33bb37ac-47f0-4f95-952e-a84e93427967"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "      <th>11</th>\n",
       "      <th>12</th>\n",
       "      <th>13</th>\n",
       "      <th>14</th>\n",
       "      <th>15</th>\n",
       "      <th>16</th>\n",
       "      <th>17</th>\n",
       "      <th>18</th>\n",
       "      <th>19</th>\n",
       "      <th>20</th>\n",
       "      <th>21</th>\n",
       "      <th>22</th>\n",
       "      <th>23</th>\n",
       "      <th>24</th>\n",
       "      <th>25</th>\n",
       "      <th>26</th>\n",
       "      <th>27</th>\n",
       "      <th>28</th>\n",
       "      <th>29</th>\n",
       "      <th>30</th>\n",
       "      <th>31</th>\n",
       "      <th>32</th>\n",
       "      <th>33</th>\n",
       "      <th>34</th>\n",
       "      <th>35</th>\n",
       "      <th>36</th>\n",
       "      <th>37</th>\n",
       "      <th>38</th>\n",
       "      <th>39</th>\n",
       "      <th>40</th>\n",
       "      <th>...</th>\n",
       "      <th>151</th>\n",
       "      <th>152</th>\n",
       "      <th>153</th>\n",
       "      <th>154</th>\n",
       "      <th>155</th>\n",
       "      <th>156</th>\n",
       "      <th>157</th>\n",
       "      <th>158</th>\n",
       "      <th>159</th>\n",
       "      <th>160</th>\n",
       "      <th>161</th>\n",
       "      <th>162</th>\n",
       "      <th>163</th>\n",
       "      <th>164</th>\n",
       "      <th>165</th>\n",
       "      <th>166</th>\n",
       "      <th>167</th>\n",
       "      <th>168</th>\n",
       "      <th>169</th>\n",
       "      <th>170</th>\n",
       "      <th>171</th>\n",
       "      <th>172</th>\n",
       "      <th>173</th>\n",
       "      <th>174</th>\n",
       "      <th>175</th>\n",
       "      <th>176</th>\n",
       "      <th>177</th>\n",
       "      <th>178</th>\n",
       "      <th>179</th>\n",
       "      <th>180</th>\n",
       "      <th>181</th>\n",
       "      <th>182</th>\n",
       "      <th>183</th>\n",
       "      <th>184</th>\n",
       "      <th>185</th>\n",
       "      <th>186</th>\n",
       "      <th>187</th>\n",
       "      <th>188</th>\n",
       "      <th>189</th>\n",
       "      <th>190</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.371966</td>\n",
       "      <td>5.534521</td>\n",
       "      <td>3.771174</td>\n",
       "      <td>1.877307</td>\n",
       "      <td>3.599094</td>\n",
       "      <td>5.784208</td>\n",
       "      <td>3.871398</td>\n",
       "      <td>2.878446</td>\n",
       "      <td>4.109515</td>\n",
       "      <td>5.151511</td>\n",
       "      <td>3.751897</td>\n",
       "      <td>3.556238</td>\n",
       "      <td>3.999945</td>\n",
       "      <td>4.033617</td>\n",
       "      <td>3.463554</td>\n",
       "      <td>0.815792</td>\n",
       "      <td>1.831954</td>\n",
       "      <td>2.790003</td>\n",
       "      <td>2.835154</td>\n",
       "      <td>2.847168</td>\n",
       "      <td>2.992328</td>\n",
       "      <td>2.124879</td>\n",
       "      <td>1.704721</td>\n",
       "      <td>3.592144</td>\n",
       "      <td>3.263506</td>\n",
       "      <td>1.407651</td>\n",
       "      <td>0.792772</td>\n",
       "      <td>2.504661</td>\n",
       "      <td>2.018912</td>\n",
       "      <td>0.874059</td>\n",
       "      <td>0.602102</td>\n",
       "      <td>0.853430</td>\n",
       "      <td>1.155075</td>\n",
       "      <td>1.530042</td>\n",
       "      <td>0.818970</td>\n",
       "      <td>0.941513</td>\n",
       "      <td>1.196730</td>\n",
       "      <td>1.848092</td>\n",
       "      <td>1.000364</td>\n",
       "      <td>0.101884</td>\n",
       "      <td>...</td>\n",
       "      <td>2.595528</td>\n",
       "      <td>1.199002</td>\n",
       "      <td>0.344221</td>\n",
       "      <td>1.873137</td>\n",
       "      <td>2.094620</td>\n",
       "      <td>1.129008</td>\n",
       "      <td>1.337368</td>\n",
       "      <td>1.837140</td>\n",
       "      <td>1.841307</td>\n",
       "      <td>0.778679</td>\n",
       "      <td>2.493860</td>\n",
       "      <td>3.410885</td>\n",
       "      <td>4.817075</td>\n",
       "      <td>1.915310</td>\n",
       "      <td>3.604270</td>\n",
       "      <td>5.053342</td>\n",
       "      <td>5.813587</td>\n",
       "      <td>3.742723</td>\n",
       "      <td>4.704520</td>\n",
       "      <td>5.645797</td>\n",
       "      <td>5.770760</td>\n",
       "      <td>4.435363</td>\n",
       "      <td>5.069113</td>\n",
       "      <td>5.619418</td>\n",
       "      <td>5.546394</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3.526383</td>\n",
       "      <td>3.173435</td>\n",
       "      <td>3.100720</td>\n",
       "      <td>4.561333</td>\n",
       "      <td>4.389340</td>\n",
       "      <td>3.113444</td>\n",
       "      <td>2.403284</td>\n",
       "      <td>4.039598</td>\n",
       "      <td>5.388708</td>\n",
       "      <td>3.305511</td>\n",
       "      <td>2.359617</td>\n",
       "      <td>4.038125</td>\n",
       "      <td>5.575717</td>\n",
       "      <td>3.339931</td>\n",
       "      <td>2.404248</td>\n",
       "      <td>0.994276</td>\n",
       "      <td>0.772501</td>\n",
       "      <td>1.164019</td>\n",
       "      <td>1.013916</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.154526</td>\n",
       "      <td>1.538787</td>\n",
       "      <td>1.013898</td>\n",
       "      <td>0.628898</td>\n",
       "      <td>0.976963</td>\n",
       "      <td>1.260981</td>\n",
       "      <td>0.398027</td>\n",
       "      <td>0.915209</td>\n",
       "      <td>1.075993</td>\n",
       "      <td>0.952253</td>\n",
       "      <td>0.360992</td>\n",
       "      <td>2.014620</td>\n",
       "      <td>1.434731</td>\n",
       "      <td>1.451873</td>\n",
       "      <td>1.603072</td>\n",
       "      <td>2.144488</td>\n",
       "      <td>1.205181</td>\n",
       "      <td>0.529447</td>\n",
       "      <td>1.521376</td>\n",
       "      <td>1.463058</td>\n",
       "      <td>...</td>\n",
       "      <td>2.551724</td>\n",
       "      <td>0.522883</td>\n",
       "      <td>1.889491</td>\n",
       "      <td>2.350907</td>\n",
       "      <td>3.995306</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.764494</td>\n",
       "      <td>2.500885</td>\n",
       "      <td>4.176400</td>\n",
       "      <td>4.328540</td>\n",
       "      <td>4.785938</td>\n",
       "      <td>4.613373</td>\n",
       "      <td>4.575105</td>\n",
       "      <td>4.120614</td>\n",
       "      <td>4.945362</td>\n",
       "      <td>5.024627</td>\n",
       "      <td>4.416818</td>\n",
       "      <td>3.742496</td>\n",
       "      <td>5.187605</td>\n",
       "      <td>5.475689</td>\n",
       "      <td>4.571706</td>\n",
       "      <td>3.445375</td>\n",
       "      <td>5.177875</td>\n",
       "      <td>5.506576</td>\n",
       "      <td>4.554773</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.946491</td>\n",
       "      <td>2.014766</td>\n",
       "      <td>0.606742</td>\n",
       "      <td>1.302111</td>\n",
       "      <td>2.517385</td>\n",
       "      <td>1.538354</td>\n",
       "      <td>0.719057</td>\n",
       "      <td>1.375769</td>\n",
       "      <td>2.441072</td>\n",
       "      <td>1.504012</td>\n",
       "      <td>0.765164</td>\n",
       "      <td>1.472412</td>\n",
       "      <td>2.440190</td>\n",
       "      <td>1.520071</td>\n",
       "      <td>0.794750</td>\n",
       "      <td>0.462368</td>\n",
       "      <td>0.326227</td>\n",
       "      <td>0.021466</td>\n",
       "      <td>0.114557</td>\n",
       "      <td>0.467163</td>\n",
       "      <td>0.482730</td>\n",
       "      <td>0.345495</td>\n",
       "      <td>0.200275</td>\n",
       "      <td>0.497083</td>\n",
       "      <td>0.515072</td>\n",
       "      <td>0.348540</td>\n",
       "      <td>0.177527</td>\n",
       "      <td>0.530037</td>\n",
       "      <td>0.556105</td>\n",
       "      <td>0.371184</td>\n",
       "      <td>0.183986</td>\n",
       "      <td>0.756496</td>\n",
       "      <td>1.232142</td>\n",
       "      <td>1.138340</td>\n",
       "      <td>0.928109</td>\n",
       "      <td>0.767746</td>\n",
       "      <td>0.836496</td>\n",
       "      <td>0.508740</td>\n",
       "      <td>0.718285</td>\n",
       "      <td>0.730288</td>\n",
       "      <td>...</td>\n",
       "      <td>2.025097</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.779589</td>\n",
       "      <td>1.328869</td>\n",
       "      <td>2.031063</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.822838</td>\n",
       "      <td>1.308154</td>\n",
       "      <td>2.011046</td>\n",
       "      <td>1.308188</td>\n",
       "      <td>2.007667</td>\n",
       "      <td>2.612505</td>\n",
       "      <td>1.880480</td>\n",
       "      <td>1.288256</td>\n",
       "      <td>1.852298</td>\n",
       "      <td>2.421364</td>\n",
       "      <td>1.724892</td>\n",
       "      <td>1.318860</td>\n",
       "      <td>1.947480</td>\n",
       "      <td>2.432085</td>\n",
       "      <td>1.778601</td>\n",
       "      <td>1.372086</td>\n",
       "      <td>2.027474</td>\n",
       "      <td>2.441239</td>\n",
       "      <td>1.833839</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.386448</td>\n",
       "      <td>1.852063</td>\n",
       "      <td>1.134460</td>\n",
       "      <td>2.596234</td>\n",
       "      <td>3.389648</td>\n",
       "      <td>1.662953</td>\n",
       "      <td>1.038565</td>\n",
       "      <td>2.676021</td>\n",
       "      <td>3.362122</td>\n",
       "      <td>1.920712</td>\n",
       "      <td>1.499901</td>\n",
       "      <td>3.161449</td>\n",
       "      <td>3.286839</td>\n",
       "      <td>2.157617</td>\n",
       "      <td>2.036724</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.117205</td>\n",
       "      <td>0.143452</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.461451</td>\n",
       "      <td>0.427643</td>\n",
       "      <td>0.255673</td>\n",
       "      <td>0.164487</td>\n",
       "      <td>0.876250</td>\n",
       "      <td>0.560381</td>\n",
       "      <td>0.436125</td>\n",
       "      <td>0.523286</td>\n",
       "      <td>1.043375</td>\n",
       "      <td>0.694227</td>\n",
       "      <td>0.512307</td>\n",
       "      <td>0.499009</td>\n",
       "      <td>1.551288</td>\n",
       "      <td>1.385397</td>\n",
       "      <td>0.882480</td>\n",
       "      <td>1.210409</td>\n",
       "      <td>1.346007</td>\n",
       "      <td>1.316480</td>\n",
       "      <td>0.673251</td>\n",
       "      <td>1.055087</td>\n",
       "      <td>1.016263</td>\n",
       "      <td>...</td>\n",
       "      <td>2.556800</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.174302</td>\n",
       "      <td>1.990459</td>\n",
       "      <td>2.752038</td>\n",
       "      <td>0.216381</td>\n",
       "      <td>1.086999</td>\n",
       "      <td>1.898338</td>\n",
       "      <td>2.957911</td>\n",
       "      <td>2.406755</td>\n",
       "      <td>3.281940</td>\n",
       "      <td>3.422960</td>\n",
       "      <td>2.465468</td>\n",
       "      <td>2.262799</td>\n",
       "      <td>2.927118</td>\n",
       "      <td>3.108559</td>\n",
       "      <td>2.103831</td>\n",
       "      <td>1.763779</td>\n",
       "      <td>3.160302</td>\n",
       "      <td>3.302106</td>\n",
       "      <td>2.497695</td>\n",
       "      <td>1.768548</td>\n",
       "      <td>3.200631</td>\n",
       "      <td>3.456518</td>\n",
       "      <td>2.872745</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.801409</td>\n",
       "      <td>3.549685</td>\n",
       "      <td>1.483723</td>\n",
       "      <td>3.400284</td>\n",
       "      <td>6.017810</td>\n",
       "      <td>3.560772</td>\n",
       "      <td>0.938271</td>\n",
       "      <td>3.958203</td>\n",
       "      <td>6.236764</td>\n",
       "      <td>3.570545</td>\n",
       "      <td>1.322847</td>\n",
       "      <td>4.797732</td>\n",
       "      <td>6.304609</td>\n",
       "      <td>3.528461</td>\n",
       "      <td>2.447520</td>\n",
       "      <td>0.443713</td>\n",
       "      <td>1.214100</td>\n",
       "      <td>0.773076</td>\n",
       "      <td>0.129588</td>\n",
       "      <td>0.767762</td>\n",
       "      <td>0.898237</td>\n",
       "      <td>0.355897</td>\n",
       "      <td>0.291968</td>\n",
       "      <td>1.390222</td>\n",
       "      <td>1.277721</td>\n",
       "      <td>0.606648</td>\n",
       "      <td>0.616740</td>\n",
       "      <td>1.489748</td>\n",
       "      <td>1.172309</td>\n",
       "      <td>0.477964</td>\n",
       "      <td>0.484417</td>\n",
       "      <td>1.798817</td>\n",
       "      <td>2.018017</td>\n",
       "      <td>1.576089</td>\n",
       "      <td>1.636996</td>\n",
       "      <td>1.743922</td>\n",
       "      <td>2.118833</td>\n",
       "      <td>1.429850</td>\n",
       "      <td>1.320268</td>\n",
       "      <td>1.335179</td>\n",
       "      <td>...</td>\n",
       "      <td>4.205501</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.885727</td>\n",
       "      <td>4.131544</td>\n",
       "      <td>4.623601</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.766280</td>\n",
       "      <td>3.891120</td>\n",
       "      <td>5.017716</td>\n",
       "      <td>3.414642</td>\n",
       "      <td>4.076665</td>\n",
       "      <td>5.282783</td>\n",
       "      <td>2.977127</td>\n",
       "      <td>3.245191</td>\n",
       "      <td>4.416250</td>\n",
       "      <td>5.385727</td>\n",
       "      <td>3.051950</td>\n",
       "      <td>3.147260</td>\n",
       "      <td>5.228606</td>\n",
       "      <td>5.652248</td>\n",
       "      <td>3.534677</td>\n",
       "      <td>3.436431</td>\n",
       "      <td>5.685542</td>\n",
       "      <td>5.855291</td>\n",
       "      <td>3.632308</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 190 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        1         2         3         4         5    ...  186  187  188  189  190\n",
       "0  2.371966  5.534521  3.771174  1.877307  3.599094  ...  0.0  0.0  0.0  0.0  0.0\n",
       "1  3.526383  3.173435  3.100720  4.561333  4.389340  ...  0.0  0.0  0.0  0.0  0.0\n",
       "2  2.946491  2.014766  0.606742  1.302111  2.517385  ...  0.0  0.0  0.0  0.0  0.0\n",
       "3  3.386448  1.852063  1.134460  2.596234  3.389648  ...  0.0  0.0  0.0  0.0  0.0\n",
       "4  5.801409  3.549685  1.483723  3.400284  6.017810  ...  0.0  0.0  0.0  0.0  0.0\n",
       "\n",
       "[5 rows x 190 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#df=pd.read_csv(\"drive/MyDrive/data.csv\")\n",
    "#df.head()\n",
    "\n",
    "data = pd.read_csv(\"drive/MyDrive/data.csv\", na_values='?', header=None,) \n",
    "data = data.reset_index(drop=True)\n",
    "y=data.iloc[:,-1]\n",
    "df = data.iloc[:,1:-2]\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 247
    },
    "id": "kzSm4wBXEduP",
    "outputId": "beb63e49-860d-465f-a57a-83e09dcf381f"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "      <th>11</th>\n",
       "      <th>12</th>\n",
       "      <th>13</th>\n",
       "      <th>14</th>\n",
       "      <th>15</th>\n",
       "      <th>16</th>\n",
       "      <th>17</th>\n",
       "      <th>18</th>\n",
       "      <th>19</th>\n",
       "      <th>20</th>\n",
       "      <th>21</th>\n",
       "      <th>22</th>\n",
       "      <th>23</th>\n",
       "      <th>24</th>\n",
       "      <th>25</th>\n",
       "      <th>26</th>\n",
       "      <th>27</th>\n",
       "      <th>28</th>\n",
       "      <th>29</th>\n",
       "      <th>30</th>\n",
       "      <th>31</th>\n",
       "      <th>32</th>\n",
       "      <th>33</th>\n",
       "      <th>34</th>\n",
       "      <th>35</th>\n",
       "      <th>36</th>\n",
       "      <th>37</th>\n",
       "      <th>38</th>\n",
       "      <th>39</th>\n",
       "      <th>40</th>\n",
       "      <th>...</th>\n",
       "      <th>151</th>\n",
       "      <th>152</th>\n",
       "      <th>153</th>\n",
       "      <th>154</th>\n",
       "      <th>155</th>\n",
       "      <th>156</th>\n",
       "      <th>157</th>\n",
       "      <th>158</th>\n",
       "      <th>159</th>\n",
       "      <th>160</th>\n",
       "      <th>161</th>\n",
       "      <th>162</th>\n",
       "      <th>163</th>\n",
       "      <th>164</th>\n",
       "      <th>165</th>\n",
       "      <th>166</th>\n",
       "      <th>167</th>\n",
       "      <th>168</th>\n",
       "      <th>169</th>\n",
       "      <th>170</th>\n",
       "      <th>171</th>\n",
       "      <th>172</th>\n",
       "      <th>173</th>\n",
       "      <th>174</th>\n",
       "      <th>175</th>\n",
       "      <th>176</th>\n",
       "      <th>177</th>\n",
       "      <th>178</th>\n",
       "      <th>179</th>\n",
       "      <th>180</th>\n",
       "      <th>181</th>\n",
       "      <th>182</th>\n",
       "      <th>183</th>\n",
       "      <th>184</th>\n",
       "      <th>185</th>\n",
       "      <th>186</th>\n",
       "      <th>187</th>\n",
       "      <th>188</th>\n",
       "      <th>189</th>\n",
       "      <th>190</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.371966</td>\n",
       "      <td>5.534521</td>\n",
       "      <td>3.771174</td>\n",
       "      <td>1.877307</td>\n",
       "      <td>3.599094</td>\n",
       "      <td>5.784208</td>\n",
       "      <td>3.871398</td>\n",
       "      <td>2.878446</td>\n",
       "      <td>4.109515</td>\n",
       "      <td>5.151511</td>\n",
       "      <td>3.751897</td>\n",
       "      <td>3.556238</td>\n",
       "      <td>3.999945</td>\n",
       "      <td>4.033617</td>\n",
       "      <td>3.463554</td>\n",
       "      <td>0.815792</td>\n",
       "      <td>1.831954</td>\n",
       "      <td>2.790003</td>\n",
       "      <td>2.835154</td>\n",
       "      <td>2.847168</td>\n",
       "      <td>2.992328</td>\n",
       "      <td>2.124879</td>\n",
       "      <td>1.704721</td>\n",
       "      <td>3.592144</td>\n",
       "      <td>3.263506</td>\n",
       "      <td>1.407651</td>\n",
       "      <td>0.792772</td>\n",
       "      <td>2.504661</td>\n",
       "      <td>2.018912</td>\n",
       "      <td>0.874059</td>\n",
       "      <td>0.602102</td>\n",
       "      <td>0.853430</td>\n",
       "      <td>1.155075</td>\n",
       "      <td>1.530042</td>\n",
       "      <td>0.818970</td>\n",
       "      <td>0.941513</td>\n",
       "      <td>1.196730</td>\n",
       "      <td>1.848092</td>\n",
       "      <td>1.000364</td>\n",
       "      <td>0.101884</td>\n",
       "      <td>...</td>\n",
       "      <td>2.595528</td>\n",
       "      <td>1.199002</td>\n",
       "      <td>0.344221</td>\n",
       "      <td>1.873137</td>\n",
       "      <td>2.094620</td>\n",
       "      <td>1.129008</td>\n",
       "      <td>1.337368</td>\n",
       "      <td>1.837140</td>\n",
       "      <td>1.841307</td>\n",
       "      <td>0.778679</td>\n",
       "      <td>2.493860</td>\n",
       "      <td>3.410885</td>\n",
       "      <td>4.817075</td>\n",
       "      <td>1.915310</td>\n",
       "      <td>3.604270</td>\n",
       "      <td>5.053342</td>\n",
       "      <td>5.813587</td>\n",
       "      <td>3.742723</td>\n",
       "      <td>4.704520</td>\n",
       "      <td>5.645797</td>\n",
       "      <td>5.770760</td>\n",
       "      <td>4.435363</td>\n",
       "      <td>5.069113</td>\n",
       "      <td>5.619418</td>\n",
       "      <td>5.546394</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3.526383</td>\n",
       "      <td>3.173435</td>\n",
       "      <td>3.100720</td>\n",
       "      <td>4.561333</td>\n",
       "      <td>4.389340</td>\n",
       "      <td>3.113444</td>\n",
       "      <td>2.403284</td>\n",
       "      <td>4.039598</td>\n",
       "      <td>5.388708</td>\n",
       "      <td>3.305511</td>\n",
       "      <td>2.359617</td>\n",
       "      <td>4.038125</td>\n",
       "      <td>5.575717</td>\n",
       "      <td>3.339931</td>\n",
       "      <td>2.404248</td>\n",
       "      <td>0.994276</td>\n",
       "      <td>0.772501</td>\n",
       "      <td>1.164019</td>\n",
       "      <td>1.013916</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.154526</td>\n",
       "      <td>1.538787</td>\n",
       "      <td>1.013898</td>\n",
       "      <td>0.628898</td>\n",
       "      <td>0.976963</td>\n",
       "      <td>1.260981</td>\n",
       "      <td>0.398027</td>\n",
       "      <td>0.915209</td>\n",
       "      <td>1.075993</td>\n",
       "      <td>0.952253</td>\n",
       "      <td>0.360992</td>\n",
       "      <td>2.014620</td>\n",
       "      <td>1.434731</td>\n",
       "      <td>1.451873</td>\n",
       "      <td>1.603072</td>\n",
       "      <td>2.144488</td>\n",
       "      <td>1.205181</td>\n",
       "      <td>0.529447</td>\n",
       "      <td>1.521376</td>\n",
       "      <td>1.463058</td>\n",
       "      <td>...</td>\n",
       "      <td>2.551724</td>\n",
       "      <td>0.522883</td>\n",
       "      <td>1.889491</td>\n",
       "      <td>2.350907</td>\n",
       "      <td>3.995306</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.764494</td>\n",
       "      <td>2.500885</td>\n",
       "      <td>4.176400</td>\n",
       "      <td>4.328540</td>\n",
       "      <td>4.785938</td>\n",
       "      <td>4.613373</td>\n",
       "      <td>4.575105</td>\n",
       "      <td>4.120614</td>\n",
       "      <td>4.945362</td>\n",
       "      <td>5.024627</td>\n",
       "      <td>4.416818</td>\n",
       "      <td>3.742496</td>\n",
       "      <td>5.187605</td>\n",
       "      <td>5.475689</td>\n",
       "      <td>4.571706</td>\n",
       "      <td>3.445375</td>\n",
       "      <td>5.177875</td>\n",
       "      <td>5.506576</td>\n",
       "      <td>4.554773</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.946491</td>\n",
       "      <td>2.014766</td>\n",
       "      <td>0.606742</td>\n",
       "      <td>1.302111</td>\n",
       "      <td>2.517385</td>\n",
       "      <td>1.538354</td>\n",
       "      <td>0.719057</td>\n",
       "      <td>1.375769</td>\n",
       "      <td>2.441072</td>\n",
       "      <td>1.504012</td>\n",
       "      <td>0.765164</td>\n",
       "      <td>1.472412</td>\n",
       "      <td>2.440190</td>\n",
       "      <td>1.520071</td>\n",
       "      <td>0.794750</td>\n",
       "      <td>0.462368</td>\n",
       "      <td>0.326227</td>\n",
       "      <td>0.021466</td>\n",
       "      <td>0.114557</td>\n",
       "      <td>0.467163</td>\n",
       "      <td>0.482730</td>\n",
       "      <td>0.345495</td>\n",
       "      <td>0.200275</td>\n",
       "      <td>0.497083</td>\n",
       "      <td>0.515072</td>\n",
       "      <td>0.348540</td>\n",
       "      <td>0.177527</td>\n",
       "      <td>0.530037</td>\n",
       "      <td>0.556105</td>\n",
       "      <td>0.371184</td>\n",
       "      <td>0.183986</td>\n",
       "      <td>0.756496</td>\n",
       "      <td>1.232142</td>\n",
       "      <td>1.138340</td>\n",
       "      <td>0.928109</td>\n",
       "      <td>0.767746</td>\n",
       "      <td>0.836496</td>\n",
       "      <td>0.508740</td>\n",
       "      <td>0.718285</td>\n",
       "      <td>0.730288</td>\n",
       "      <td>...</td>\n",
       "      <td>2.025097</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.779589</td>\n",
       "      <td>1.328869</td>\n",
       "      <td>2.031063</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.822838</td>\n",
       "      <td>1.308154</td>\n",
       "      <td>2.011046</td>\n",
       "      <td>1.308188</td>\n",
       "      <td>2.007667</td>\n",
       "      <td>2.612505</td>\n",
       "      <td>1.880480</td>\n",
       "      <td>1.288256</td>\n",
       "      <td>1.852298</td>\n",
       "      <td>2.421364</td>\n",
       "      <td>1.724892</td>\n",
       "      <td>1.318860</td>\n",
       "      <td>1.947480</td>\n",
       "      <td>2.432085</td>\n",
       "      <td>1.778601</td>\n",
       "      <td>1.372086</td>\n",
       "      <td>2.027474</td>\n",
       "      <td>2.441239</td>\n",
       "      <td>1.833839</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.386448</td>\n",
       "      <td>1.852063</td>\n",
       "      <td>1.134460</td>\n",
       "      <td>2.596234</td>\n",
       "      <td>3.389648</td>\n",
       "      <td>1.662953</td>\n",
       "      <td>1.038565</td>\n",
       "      <td>2.676021</td>\n",
       "      <td>3.362122</td>\n",
       "      <td>1.920712</td>\n",
       "      <td>1.499901</td>\n",
       "      <td>3.161449</td>\n",
       "      <td>3.286839</td>\n",
       "      <td>2.157617</td>\n",
       "      <td>2.036724</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.117205</td>\n",
       "      <td>0.143452</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.461451</td>\n",
       "      <td>0.427643</td>\n",
       "      <td>0.255673</td>\n",
       "      <td>0.164487</td>\n",
       "      <td>0.876250</td>\n",
       "      <td>0.560381</td>\n",
       "      <td>0.436125</td>\n",
       "      <td>0.523286</td>\n",
       "      <td>1.043375</td>\n",
       "      <td>0.694227</td>\n",
       "      <td>0.512307</td>\n",
       "      <td>0.499009</td>\n",
       "      <td>1.551288</td>\n",
       "      <td>1.385397</td>\n",
       "      <td>0.882480</td>\n",
       "      <td>1.210409</td>\n",
       "      <td>1.346007</td>\n",
       "      <td>1.316480</td>\n",
       "      <td>0.673251</td>\n",
       "      <td>1.055087</td>\n",
       "      <td>1.016263</td>\n",
       "      <td>...</td>\n",
       "      <td>2.556800</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.174302</td>\n",
       "      <td>1.990459</td>\n",
       "      <td>2.752038</td>\n",
       "      <td>0.216381</td>\n",
       "      <td>1.086999</td>\n",
       "      <td>1.898338</td>\n",
       "      <td>2.957911</td>\n",
       "      <td>2.406755</td>\n",
       "      <td>3.281940</td>\n",
       "      <td>3.422960</td>\n",
       "      <td>2.465468</td>\n",
       "      <td>2.262799</td>\n",
       "      <td>2.927118</td>\n",
       "      <td>3.108559</td>\n",
       "      <td>2.103831</td>\n",
       "      <td>1.763779</td>\n",
       "      <td>3.160302</td>\n",
       "      <td>3.302106</td>\n",
       "      <td>2.497695</td>\n",
       "      <td>1.768548</td>\n",
       "      <td>3.200631</td>\n",
       "      <td>3.456518</td>\n",
       "      <td>2.872745</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.801409</td>\n",
       "      <td>3.549685</td>\n",
       "      <td>1.483723</td>\n",
       "      <td>3.400284</td>\n",
       "      <td>6.017810</td>\n",
       "      <td>3.560772</td>\n",
       "      <td>0.938271</td>\n",
       "      <td>3.958203</td>\n",
       "      <td>6.236764</td>\n",
       "      <td>3.570545</td>\n",
       "      <td>1.322847</td>\n",
       "      <td>4.797732</td>\n",
       "      <td>6.304609</td>\n",
       "      <td>3.528461</td>\n",
       "      <td>2.447520</td>\n",
       "      <td>0.443713</td>\n",
       "      <td>1.214100</td>\n",
       "      <td>0.773076</td>\n",
       "      <td>0.129588</td>\n",
       "      <td>0.767762</td>\n",
       "      <td>0.898237</td>\n",
       "      <td>0.355897</td>\n",
       "      <td>0.291968</td>\n",
       "      <td>1.390222</td>\n",
       "      <td>1.277721</td>\n",
       "      <td>0.606648</td>\n",
       "      <td>0.616740</td>\n",
       "      <td>1.489748</td>\n",
       "      <td>1.172309</td>\n",
       "      <td>0.477964</td>\n",
       "      <td>0.484417</td>\n",
       "      <td>1.798817</td>\n",
       "      <td>2.018017</td>\n",
       "      <td>1.576089</td>\n",
       "      <td>1.636996</td>\n",
       "      <td>1.743922</td>\n",
       "      <td>2.118833</td>\n",
       "      <td>1.429850</td>\n",
       "      <td>1.320268</td>\n",
       "      <td>1.335179</td>\n",
       "      <td>...</td>\n",
       "      <td>4.205501</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.885727</td>\n",
       "      <td>4.131544</td>\n",
       "      <td>4.623601</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.766280</td>\n",
       "      <td>3.891120</td>\n",
       "      <td>5.017716</td>\n",
       "      <td>3.414642</td>\n",
       "      <td>4.076665</td>\n",
       "      <td>5.282783</td>\n",
       "      <td>2.977127</td>\n",
       "      <td>3.245191</td>\n",
       "      <td>4.416250</td>\n",
       "      <td>5.385727</td>\n",
       "      <td>3.051950</td>\n",
       "      <td>3.147260</td>\n",
       "      <td>5.228606</td>\n",
       "      <td>5.652248</td>\n",
       "      <td>3.534677</td>\n",
       "      <td>3.436431</td>\n",
       "      <td>5.685542</td>\n",
       "      <td>5.855291</td>\n",
       "      <td>3.632308</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 190 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        1         2         3         4         5    ...  186  187  188  189  190\n",
       "0  2.371966  5.534521  3.771174  1.877307  3.599094  ...  0.0  0.0  0.0  0.0  0.0\n",
       "1  3.526383  3.173435  3.100720  4.561333  4.389340  ...  0.0  0.0  0.0  0.0  0.0\n",
       "2  2.946491  2.014766  0.606742  1.302111  2.517385  ...  0.0  0.0  0.0  0.0  0.0\n",
       "3  3.386448  1.852063  1.134460  2.596234  3.389648  ...  0.0  0.0  0.0  0.0  0.0\n",
       "4  5.801409  3.549685  1.483723  3.400284  6.017810  ...  0.0  0.0  0.0  0.0  0.0\n",
       "\n",
       "[5 rows x 190 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#for i in range(1,175):\n",
    "#  df[i]=df[i].astype(float)\n",
    "#  df[i]=((df[i]-df[i].min())/(df[i].max()-df[i].min()))*1\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NJgSl6IqFUDQ"
   },
   "outputs": [],
   "source": [
    "##doing label encoding\n",
    "labelencoder = LabelEncoder()\n",
    "# Assigning numerical values and storing in another column\n",
    "y=labelencoder.fit_transform(y)\n",
    "#print(y[:10])\n",
    "\n",
    "x=df.to_numpy()\n",
    "#print(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3L6WjsSxOHVK",
    "outputId": "a96d617b-9f16-47dd-d669-b67996414532"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(y))\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "brlb209AHMU8"
   },
   "outputs": [],
   "source": [
    "def Euclidean_distance(v1,v2):  \n",
    "    sum=0\n",
    "    for p,q in zip(v1, v2):\n",
    "      sum+=(float(p)- float(q))**2\n",
    "    sum = sum ** .5\n",
    "    return sum  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "E6NtdEYFUCPq"
   },
   "outputs": [],
   "source": [
    "# 1. Kmeans algorithm with Forgy as initial clusters’ centroids with Euclidean Distance\n",
    "\n",
    "class Kmeans1:\n",
    "\n",
    "  def __init__(self,k):\n",
    "    self.k = k\n",
    "    self.epoch = 90\n",
    "    self.random_state = 122\n",
    "\n",
    "  def compute_centroids(self, X, labels):\n",
    "        centroids = np.zeros((self.k, X.shape[1]))\n",
    "        for key in range(self.k):\n",
    "            centroids[key, :] = np.mean(X[labels == key, :], axis=0)\n",
    "        return centroids\n",
    "\n",
    "  def compute_distance(self, X, centroids):\n",
    "      distance = np.zeros((X.shape[0], self.k)) # 2d matrx=ix of 70000*k meaning every row has distance with each centroid\n",
    "      for i in range(len(centroids)):\n",
    "        for j in range(len(X)):\n",
    "          distance[i][i]= Euclidean_distance(centroids[i],X[j])\n",
    "      return distance\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key, :], axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "  \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return np.array(new_centroids)\n",
    "\n",
    "  def fit(self, X):\n",
    "      self.X=X\n",
    "      np.random.RandomState(122)\n",
    "      print()\n",
    "      self.centroids = X[np.random.permutation(X.shape[0])[:self.k]]\n",
    "      #print(\"****************\")\n",
    "      #print(self.centroids.shape)\n",
    "      # print(self.centroids)\n",
    "      \n",
    "      for i in range(self.epoch):\n",
    "        self.labels=[]\n",
    "        self.label2=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #distance1 = self.compute_distance(X[:10], old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        #print(distance2)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels.append(result[0][0])\n",
    "          self.label2.append(j.tolist().index(sorted(j)[1]))\n",
    "        # c = np.zeros((self.k, X.shape[1]))\n",
    "        # for key in range(self.k):\n",
    "        #   li=np.where(self.labels==key)\n",
    "        #   for l in li:\n",
    "        #     for p in range(len(X[l])):\n",
    "        #       c[key][p]=c[key][p]+X[l][p]\n",
    "        #   c[key,:] = c[key,:]/len(li)\n",
    "      \n",
    "        self.centroids=self.calc_centroids(self.labels,X)\n",
    "\n",
    "        if np.all(self.old_centroids == self.centroids):\n",
    "          return self.centroids,self.labels, self.label2\n",
    "          break\n",
    "      return self.centroids , self.labels, self.label2\n",
    "        \n",
    "  def predict(self, X):\n",
    "    #print(self.centroids)\n",
    "    distance = self.compute_distance1(X, self.centroids)\n",
    "    #print(distance)\n",
    "    self.new_labels=[]\n",
    "    for j in distance:\n",
    "      min_ele=np.min(j)\n",
    "      result = np.where(j == min_ele)\n",
    "      #print(result)\n",
    "      self.new_labels.append(result)\n",
    "    return self.new_labels\n",
    "  \n",
    "  def error(self):\n",
    "    error = self.compute_sse()\n",
    "    return error\n",
    "\n",
    "\n",
    "#implement elbow method from scratch\n",
    "def elbow1(xx,yy):\n",
    "  \n",
    "  sse = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k,end =\" Homogeneity Score: \")\n",
    "\n",
    "    obj=Kmeans1(k)\n",
    "    centroids,labels,not_req = obj.fit(xx)\n",
    "    #print(y_train.shape)\n",
    "    # print(\"******************\")\n",
    "    # print(len(labels))\n",
    "    # print(labels[0])\n",
    "    new_labels=[]\n",
    "    for val in labels:\n",
    "      for value in val:\n",
    "        new_labels.append(value)\n",
    "    print(homogeneity_score(np.squeeze(yy),new_labels))\n",
    "    cost=0.0\n",
    "    for i in range(len(xx)):\n",
    "      temp=Euclidean_distance(xx[i],centroids[new_labels[i]])\n",
    "      cost+=temp\n",
    "    sse.append(float(cost))\n",
    "    #print(cost)\n",
    "    del obj\n",
    "    del centroids\n",
    "    del labels\n",
    "    del cost\n",
    "    del temp\n",
    "    \n",
    "  print(sse)\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, sse, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Elbow score with euclidean');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 790
    },
    "id": "FB83oawEHn6U",
    "outputId": "ad3b893c-7515-4e4e-a7db-9f889dedb98c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5 Homogeneity Score: \n",
      "0.3205653340320163\n",
      "k= 6 Homogeneity Score: \n",
      "0.36850499179291357\n",
      "k= 7 Homogeneity Score: \n",
      "0.41428790382560016\n",
      "k= 8 Homogeneity Score: \n",
      "0.45168711851866455\n",
      "k= 9 Homogeneity Score: \n",
      "0.4643289060006521\n",
      "k= 10 Homogeneity Score: \n",
      "0.4897440660752845\n",
      "k= 11 Homogeneity Score: \n",
      "0.47858983112788067\n",
      "k= 12 Homogeneity Score: \n",
      "0.5043392315041522\n",
      "k= 13 Homogeneity Score: \n",
      "0.5184737176780071\n",
      "k= 14 Homogeneity Score: \n",
      "0.5011573616650739\n",
      "[511577.17568465904, 481604.0373668253, 472724.7524538396, 442126.762015392, 433169.3790436621, 419785.7954304929, 410891.99579027656, 403830.8382499829, 398215.37023837713, 387559.375380335]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "elbow1(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EBLkIP3oTmoW"
   },
   "source": [
    "The optimal number of clusters for Kmeans algorithm with Forgy as initial clusters’ centroids with Euclidean Distance as seen by Elbow Score Graph is k= 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Spz_Z86oG4zZ"
   },
   "outputs": [],
   "source": [
    "def silhouette1(X): #for kmeans\n",
    "  silhouette = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k)\n",
    "    \n",
    "    obj=Kmeans1(k)\n",
    "    centroids,labels1,label2 = obj.fit(X)\n",
    "\n",
    "    #labels1=labels1.to_list()\n",
    "    sse1=0\n",
    "    for pt in range(len(X)):\n",
    "      a=0\n",
    "      b=0\n",
    "      cluster_index=labels1[pt]\n",
    "      #print(\"cluster index:\",end=\" \")\n",
    "      #print(cluster_index)\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster_index:\n",
    "          points_idx.append(abc)\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        #print(type(xx))\n",
    "        #print(type(yy))\n",
    "        a = a + Euclidean_distance(xx,yy)\n",
    "      a=a/len(points_idx)\n",
    "\n",
    "      cluster2_index=label2[pt]\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster2_index:\n",
    "          points_idx.append(abc)\n",
    "\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        b = b + Euclidean_distance(xx,yy)\n",
    "      b=b/len(points_idx)\n",
    "      sil_coeff=(b-a)/max(a,b)\n",
    "      sse1+= sil_coeff\n",
    "    sse1=sse1/len(X)\n",
    "    print(sse1)\n",
    "    silhouette.append(sse1)\n",
    "\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, silhouette, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Silhouette Distance');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 934
    },
    "id": "cOzUy1RtMf7_",
    "outputId": "ff8988b0-fb71-4b43-98df-8bf087f79654"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5\n",
      "\n",
      "0.2672118952777017\n",
      "k= 6\n",
      "\n",
      "0.274179400826857\n",
      "k= 7\n",
      "\n",
      "0.29391899783428677\n",
      "k= 8\n",
      "\n",
      "0.2948001993592122\n",
      "k= 9\n",
      "\n",
      "0.2836652052306619\n",
      "k= 10\n",
      "\n",
      "0.2848901314905615\n",
      "k= 11\n",
      "\n",
      "0.2940349183487409\n",
      "k= 12\n",
      "\n",
      "0.2892802450094181\n",
      "k= 13\n",
      "\n",
      "0.28996389321385013\n",
      "k= 14\n",
      "\n",
      "0.31071700132510166\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "silhouette1(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fmvf2uJsT7Bb"
   },
   "source": [
    "The optimal number of clusters for Kmeans algorithm with Forgy as initial clusters’ centroids with Euclidean Distance as seen by Silhouette Score Graph is k=8 or k=11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "FmZYY9i9b7rt"
   },
   "outputs": [],
   "source": [
    "#Kmeans++ algorithm with Euclidean Distance\n",
    "\n",
    "class Kmeansplusplus1:\n",
    "  def __init__(self,k):\n",
    "    self.k=k\n",
    "    self.epoch=2\n",
    "  \n",
    "  def initial_centroid(self,X):\n",
    "    self.centroids = [] \n",
    "    self.centroids.append(X[np.random.randint( X.shape[0]), :]) \n",
    "    for c_id in range(self.k - 1): \n",
    "        dist = [] \n",
    "        for i in range(X.shape[0]): \n",
    "            point = X[i, :] \n",
    "            d = sys.maxsize \n",
    "            for j in range(len(self.centroids)): \n",
    "                temp_dist = Euclidean_distance(point, self.centroids[j]) \n",
    "                d = min(d, temp_dist) \n",
    "            dist.append(d) \n",
    "        dist = np.array(dist) \n",
    "        next_centroid = X[np.argmax(dist), :] \n",
    "        self.centroids.append(next_centroid) \n",
    "    return self.centroids \n",
    "\n",
    "  def calc_dist(self,X):\n",
    "    self.dist=[]\n",
    "    for i in range(X.shape[0]):\n",
    "      d=[]\n",
    "      for j in range(len(self.centroids)):\n",
    "        d.append(Euclidean_distance(X[i] , self.centroids[j]))\n",
    "      self.dist.append(d)\n",
    "      d=[]\n",
    "    return self.dist\n",
    "\n",
    "  def second_nearest_cluster(self):\n",
    "    self.labels2=[]\n",
    "    for i in self.dist:\n",
    "      result = i.index(sorted(i)[1])\n",
    "      self.labels2.append(result)\n",
    "    return self.labels2\n",
    "\n",
    "  def compute_distance1(self, X, centroids):\n",
    "        centroids=np.array(centroids)\n",
    "        distance = np.zeros((X.shape[0], self.k))\n",
    "        for key in range(self.k):\n",
    "            row_norm = norm(X - centroids[key,:] , axis=1)\n",
    "            distance[:, key] = np.square(row_norm)\n",
    "        return distance\n",
    "        \n",
    "  def calc_centroids(self,labels, X):\n",
    "    new_centroids = []\n",
    "    new_df = pd.concat([pd.DataFrame(X), pd.DataFrame(labels, columns=['labels'])], axis=1)\n",
    "    for c in set(new_df['labels']):\n",
    "        current_labels = new_df[new_df['labels'] == c][new_df.columns[:-1]]\n",
    "        new_centroids.append(current_labels.mean(axis=0))\n",
    "    return new_centroids\n",
    "\n",
    "  def train_centroids(self,X,centroids):\n",
    "    self.centroids=centroids\n",
    "    for i in range(self.epoch):\n",
    "        self.labels1=[]\n",
    "        self.old_centroids = self.centroids\n",
    "        #print(\"***************\")\n",
    "        #print(self.old_centroids)\n",
    "        distance2 = self.compute_distance1(X, self.old_centroids)\n",
    "        for j in distance2:\n",
    "          min_ele=np.min(j)\n",
    "          result = np.where(j == min_ele)\n",
    "          self.labels1.append(result[0])\n",
    "        \n",
    "        self.centroids=self.calc_centroids(self.labels1,X)\n",
    "\n",
    "        #if np.all(self.old_centroids == self.centroids):\n",
    "          #return self.centroids,self.labels1\n",
    "          #break\n",
    "    return self.centroids , self.labels1\n",
    " \n",
    "\n",
    " #implement elbow method from scratch\n",
    "def elbow5(X): #kmeans++\n",
    "  sse = []\n",
    "  list_k = list(range(5, 15))\n",
    "  #list_k=[7]\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k,end =\" Homogeneity Score: \")\n",
    "    obj=Kmeansplusplus1(k)\n",
    "    centroids=obj.initial_centroid(X)\n",
    "    #print(len(centroids))\n",
    "    #print(len(centroids[0]))\n",
    "    centroids,labels1=obj.train_centroids(X,centroids)\n",
    "    #print(centroids.shape)\n",
    "    dist=obj.calc_dist(X)\n",
    "    label2=obj.second_nearest_cluster()\n",
    "    new_labels=[]\n",
    "    for val in labels1:\n",
    "      for value in val:\n",
    "        new_labels.append(value)\n",
    "    \n",
    "    print(homogeneity_score(y,new_labels))\n",
    "    cost=0.0\n",
    "    for i in range(len(X)):\n",
    "      temp=Euclidean_distance(X[i],centroids[new_labels[i]])\n",
    "      cost+=temp\n",
    "    sse.append(float(cost))\n",
    "    #print(cost)\n",
    "    del obj\n",
    "    del centroids\n",
    "    del labels1\n",
    "    del dist\n",
    "    del label2\n",
    "    del cost\n",
    "    del temp\n",
    "    \n",
    "  print(sse)\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, sse, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Elbow Score with euclidean dist');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "background_save": true,
     "base_uri": "https://localhost:8080/"
    },
    "id": "g-EDHFhYb8m5",
    "outputId": "d1e480c5-02ae-4578-fec5-6b9684880e27"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5 Homogeneity Score: 0.24654198732400942\n",
      "k= 6 Homogeneity Score: 0.2723195006379487\n",
      "k= 7 Homogeneity Score: 0.36273408842458915\n",
      "k= 8 Homogeneity Score: 0.38881615431578553\n",
      "k= 9 Homogeneity Score: 0.387524109575675\n",
      "k= 10 Homogeneity Score: 0.41458934753354576\n",
      "k= 11 Homogeneity Score: 0.40055076812898766\n",
      "k= 12 Homogeneity Score: 0.4415700759676392\n",
      "k= 13 Homogeneity Score: 0.39643284562872355\n",
      "k= 14 Homogeneity Score: 0.42086160526258776\n",
      "[551439.8926652385, 557160.4203616587, 484506.27385902876, 489487.5334293403, 469944.5298337359, 445550.983938624, 459629.31809957867, 432163.5093755788, 437028.852007846, 430533.90774205985]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "elbow5(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xV5jq9PxUH6X"
   },
   "source": [
    "The optimal number of clusters for Kmeans++ algorithm with Euclidean Distance as seen by Elbow Score Graph is k="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8EIWJIHGM_Ra"
   },
   "outputs": [],
   "source": [
    "def silhouette(X): #for kmeans1++\n",
    "  silhouette = []\n",
    "  list_k = list(range(5, 15))\n",
    "  for k in list_k:\n",
    "    print(\"k=\",end=\" \")\n",
    "    print(k)\n",
    "    \n",
    "    obj=Kmeansplusplus1(k)\n",
    "    centroids=obj.initial_centroid(X)\n",
    "    centroids,labels1=obj.train_centroids(X,centroids)\n",
    "    dist=obj.calc_dist(X) \n",
    "    label2=obj.second_nearest_cluster()\n",
    "    #labels1=labels1.to_list()\n",
    "    sse1=0\n",
    "    for pt in range(len(X)):\n",
    "      a=0\n",
    "      b=0\n",
    "      cluster_index=labels1[pt]\n",
    "      #print(\"cluster index:\",end=\" \")\n",
    "      #print(cluster_index)\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster_index:\n",
    "          points_idx.append(abc)\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        #print(type(xx))\n",
    "        #print(type(yy))\n",
    "        a = a + Euclidean_distance(xx,yy)\n",
    "      a=a/len(points_idx)\n",
    "\n",
    "      cluster2_index=label2[pt]\n",
    "      points_idx=[]\n",
    "      for abc in range(len(labels1)):\n",
    "        if labels1[abc]==cluster2_index:\n",
    "          points_idx.append(abc)\n",
    "\n",
    "      for p in points_idx:\n",
    "        xx=pd.Series(X[pt])\n",
    "        yy=pd.Series(X[p])\n",
    "        b = b + Euclidean_distance(xx,yy)\n",
    "      b=b/len(points_idx)\n",
    "      sil_coeff=(b-a)/max(a,b)\n",
    "      sse1+= sil_coeff\n",
    "    sse1=sse1/len(X)\n",
    "    print(sse1)\n",
    "    silhouette.append(sse1)\n",
    "\n",
    "  plt.figure(figsize=(6, 6))\n",
    "  plt.plot(list_k, silhouette, '-o')\n",
    "  plt.xlabel(r'Number of clusters *k*')\n",
    "  plt.ylabel('Silhouette Distance');\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 752
    },
    "id": "ewvpjxWyNWLj",
    "outputId": "198d96e6-528a-4127-ee5b-dc97adb75232"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k= 5\n",
      "0.26921802882814605\n",
      "k= 6\n",
      "0.26552544652463045\n",
      "k= 7\n",
      "0.2607134986791845\n",
      "k= 8\n",
      "0.27091763281415815\n",
      "k= 9\n",
      "0.28995512025098596\n",
      "k= 10\n",
      "0.28300534742094813\n",
      "k= 11\n",
      "0.2827781662606681\n",
      "k= 12\n",
      "0.2976762827062338\n",
      "k= 13\n",
      "0.2711491453764634\n",
      "k= 14\n",
      "0.28409911057435755\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "silhouette(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rZa-xta0UNP4"
   },
   "source": [
    "The optimal number of clusters for Kmeans++ algorithm with Euclidean Distance as seen by Silhouette Score Graph is k=12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1qA4FdFHZdUT"
   },
   "source": [
    "**From these experiments(Part 1 and Part 2), report which one is better and why?** <br><br>\n",
    "Ans. Part 2 is better. as data is more compresses and better. "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "smai a2 q1.ipynb",
   "provenance": []
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}