Clustering-kmeans-HC.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mrzResearchArena/esm-embedding-clustering/blob/main/Clustering-kmeans-HC.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Hierarchical Clustering (Agglomerative Clustering)"
      ],
      "metadata": {
        "id": "Bgi7VjYxnd_V"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {
        "id": "nzikJC9Tk2Fw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "30187236-a412-4c16-c1dc-d38140c3364a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /drive; to attempt to forcibly remount, call drive.mount(\"/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {
        "id": "Jljeiq0alckl"
      },
      "outputs": [],
      "source": [
        "from sklearn.cluster import AgglomerativeClustering\n",
        "import numpy as np\n",
        "from sklearn.metrics.pairwise import cosine_similarity\n",
        "import time"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {
        "id": "HXY9bO3nlYVE"
      },
      "outputs": [],
      "source": [
        "# # X = np.array([[1, 2],\n",
        "#               [1, 4],\n",
        "#               [1, 0],\n",
        "#               [10, 2],\n",
        "#               [10, 4],\n",
        "#               [10, 0]])\n",
        "# X"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 94,
      "metadata": {
        "id": "YnOeEEDwmJ5S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3cd932c1-d6f8-4dd3-a5c0-c49386760579"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "PyTorchKMeans+ESM1b.npy  PyTorchKMeans+ESM1v.npy  sample_data\n"
          ]
        }
      ],
      "source": [
        "!ls"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 95,
      "metadata": {
        "id": "yUU-qavLmNlq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b1368b4f-8a32-4b67-a275-f33dee15079f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content\n"
          ]
        }
      ],
      "source": [
        "!pwd"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {
        "id": "fEWlZar0l5vU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c412e935-cb9c-40dd-f9d9-f090940cf3eb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(24578, 1280)\n",
            "(24578,)\n"
          ]
        }
      ],
      "source": [
        "# dataset load\n",
        "X = np.load('/drive/My Drive/ESM/Xv-24578.npy')\n",
        "Y = np.load('/drive/My Drive/ESM/originalLabels.npy')\n",
        "\n",
        "print(X.shape)\n",
        "print(Y.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 106,
      "metadata": {
        "id": "tN7H-3Pkme1Q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "05a4d644-5477-40c3-a9a2-dea50564046d"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(24578, 1280)"
            ]
          },
          "metadata": {},
          "execution_count": 106
        }
      ],
      "source": [
        "X.shape"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "HCmodel = AgglomerativeClustering(n_clusters=192, affinity='cosine', linkage='average')"
      ],
      "metadata": {
        "id": "gtdgnyKm2lo2"
      },
      "execution_count": 107,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "begin = time.time()\n",
        "\n",
        "HCmodel.fit(X)\n",
        "\n",
        "print(time.time() - begin)"
      ],
      "metadata": {
        "id": "mKQWxf4I2qSv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "043ca349-93d5-4f51-b2ef-0aeeba28d8f6"
      },
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "418.1067752838135\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Yp = HCmodel.labels_\n",
        "Yp"
      ],
      "metadata": {
        "id": "Iw08A1jn3FKk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e28aee7a-4270-40b7-87f8-08ec21fb06a2"
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  1,  1, ...,  1, 69, 69])"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "C=0\n",
        "#predictedLabel --> yp\n",
        "#originalLabel  --> y\n",
        "\n",
        "for y, yp in zip(Y, Yp):\n",
        "    if y==yp:\n",
        "        C += 1\n",
        "print(f'{C/len(Y)}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "utGd_UqtQky0",
        "outputId": "92c2042a-cd2c-46b9-9283-4f70a49dad3a"
      },
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.00528928309870616\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.save(arr=Yp, file='HC+ESM1v')"
      ],
      "metadata": {
        "id": "HI9v0dBhQ09-"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- *Some* URLs:\n",
        "\n",
        "    - https://github.com/DeMoriarty/fast_pytorch_kmeans/blob/master/fast_pytorch_kmeans/kmeans.py\n",
        "    - https://github.com/subhadarship/kmeans_pytorch\n",
        "    - https://stackoverflow.com/questions/44759982/are-there-any-implementations-of-kmeans-with-cosine-distance-in-apache-spark-pys"
      ],
      "metadata": {
        "id": "r5Z33loRm9Ra"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### K-Means (PyTorch Acceleration)\n",
        "\n",
        "- This tool can run on both GPU and CPU.\n",
        "    - However, I am forced to use CPU memory. Be that as it may, the CPU contains more memory compared to GPU in Google Colab Pro (i.e., The available CPU and GPU memory are 25.5 GB and 14.5 GB, respectively.).\n",
        "\n",
        "- able to train batch-wise"
      ],
      "metadata": {
        "id": "fK96TWneGaGe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# !pip install kmeans-pytorch\n",
        "!pip install git+https://github.com/subhadarship/kmeans_pytorch"
      ],
      "metadata": {
        "id": "n1B0Za6uVy1h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "00c61d0f-5b6e-4757-b6af-c850973e885d"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting git+https://github.com/subhadarship/kmeans_pytorch\n",
            "  Cloning https://github.com/subhadarship/kmeans_pytorch to /tmp/pip-req-build-4ijltfby\n",
            "  Running command git clone -q https://github.com/subhadarship/kmeans_pytorch /tmp/pip-req-build-4ijltfby\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from kmeans_pytorch import kmeans, kmeans_predict\n",
        "import time"
      ],
      "metadata": {
        "id": "D2SdvVn_LWU6"
      },
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# set random seed\n",
        "np.random.seed(101)"
      ],
      "metadata": {
        "id": "kkFbrPdWLdu1"
      },
      "execution_count": 72,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LIlTQRFgHObp",
        "outputId": "5029366a-7942-49ca-d590-abf3498dfa07"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /drive; to attempt to forcibly remount, call drive.mount(\"/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# dataset load\n",
        "X = np.load('/drive/My Drive/ESM/Xv-24578.npy')\n",
        "Y = np.load('/drive/My Drive/ESM/originalLabels.npy')\n",
        "\n",
        "print(X.shape)\n",
        "print(Y.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JwK7bm4Uzuba",
        "outputId": "69aa48b1-69db-4421-8292-6568bcc7c782"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(24578, 1280)\n",
            "(24578,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X = torch.from_numpy(X)\n",
        "print(X.shape)"
      ],
      "metadata": {
        "id": "H4lQ3BXkLrYh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "35d2ce4f-8afa-46e7-b702-7dc1f9f1efe5"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([24578, 1280])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# set device\n",
        "# if torch.cuda.is_available():\n",
        "#     device = torch.device('cuda:0')\n",
        "# else:\n",
        "#     device = torch.device('cpu')\n",
        "\n",
        "device = torch.device('cpu')\n",
        "print(f'device: {device}')"
      ],
      "metadata": {
        "id": "6fRA81yoLjq9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3caa726d-804e-482e-8912-d6c00beb2227"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "device: cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "help(kmeans)"
      ],
      "metadata": {
        "id": "uTJoDdNrMNs5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3212bf27-9fe0-441a-ff4f-49b4385eea59"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on function kmeans in module kmeans_pytorch:\n",
            "\n",
            "kmeans(X, num_clusters, distance='euclidean', cluster_centers=[], tol=0.0001, tqdm_flag=True, iter_limit=0, device=device(type='cpu'), gamma_for_soft_dtw=0.001, seed=None)\n",
            "    perform kmeans\n",
            "    :param X: (torch.tensor) matrix\n",
            "    :param num_clusters: (int) number of clusters\n",
            "    :param distance: (str) distance [options: 'euclidean', 'cosine'] [default: 'euclidean']\n",
            "    :param seed: (int) seed for kmeans\n",
            "    :param tol: (float) threshold [default: 0.0001]\n",
            "    :param device: (torch.device) device [default: cpu]\n",
            "    :param tqdm_flag: Allows to turn logs on and off\n",
            "    :param iter_limit: hard limit for max number of iterations\n",
            "    :param gamma_for_soft_dtw: approaches to (hard) DTW as gamma -> 0\n",
            "    :return: (torch.tensor, torch.tensor) cluster ids, cluster centers\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# k-means\n",
        "num_clusters = 192\n",
        "\n",
        "begin = time.time()\n",
        "\n",
        "cluster_ids_x, cluster_centers = kmeans(\n",
        "    X=X[:24578,:],\n",
        "    num_clusters=num_clusters,\n",
        "    distance='cosine',\n",
        "    device=device,\n",
        ")\n",
        "\n",
        "print()\n",
        "print(f'Time elapsed {time.time() - begin} seconds')"
      ],
      "metadata": {
        "id": "cjRDlpsMMGtj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "520a1d53-69da-4be8-fb03-7f2276537574"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "running k-means on cpu..\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[running kmeans]: 62it [04:42,  4.56s/it, center_shift=0.000000, iteration=62, tol=0.000100]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Time elapsed 282.54061365127563 seconds\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(cluster_ids_x)\n",
        "print(cluster_centers)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0PHCRyS8Dt5t",
        "outputId": "ceb8680a-5da3-49ba-b583-0bf0274719b6"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([54, 54, 54,  ..., 11, 11, 11])\n",
            "tensor([[-0.2014, -0.1432, -0.1042,  ..., -0.1642, -0.0607, -0.1622],\n",
            "        [-0.1472,  0.2373, -0.0984,  ..., -0.0676,  0.1003,  0.2316],\n",
            "        [-0.0628, -0.1229, -0.0441,  ..., -0.1878,  0.0213, -0.1657],\n",
            "        ...,\n",
            "        [-0.2269,  0.0989, -0.0133,  ..., -0.4153, -0.0005, -0.0077],\n",
            "        [-0.2202, -0.0570,  0.1944,  ..., -0.4112,  0.2120,  0.0055],\n",
            "        [-0.1452,  0.0770,  0.0670,  ..., -0.0075,  0.0632, -0.0102]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(set(cluster_ids_x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PVxqSUD6GNPz",
        "outputId": "a3fab262-c044-4161-ada8-a61bc4dc434c"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24578"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(cluster_ids_x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rs9C_MVEBPhZ",
        "outputId": "00805c30-7223-48a6-98ff-c0b984154ab5"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Tensor"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cluster_ids_x = cluster_ids_x.numpy()"
      ],
      "metadata": {
        "id": "_txv92fGAPyK"
      },
      "execution_count": 82,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z0U7Gh8qCFhU",
        "outputId": "44a804ec-74ac-4833-c154-04fe353a0c08"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([  0,   0,   0, ..., 191, 191, 191])"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cluster_ids_x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kDSQc5ziB61W",
        "outputId": "09210dbc-699f-41ff-f5a4-0e0517a70288"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([54, 54, 54, ..., 11, 11, 11])"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# C=1\n",
        "# for i in cluster_ids_x:\n",
        "#     print(i)\n",
        "#     if C==100: break\n",
        "#     C+=1\n",
        "\n",
        "# v1 = set(cluster_ids_x)\n",
        "# v2 = len(set(cluster_ids_x))\n",
        "# print(v1)\n",
        "# print(v2)"
      ],
      "metadata": {
        "id": "EASqIN9pHxzl"
      },
      "execution_count": 85,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# d = {}\n",
        "# for i in cluster_ids_x:\n",
        "#     if i not in d:\n",
        "#         d[i] = 1\n",
        "#     else:\n",
        "#         d[i] += 1"
      ],
      "metadata": {
        "id": "AKmyh5_hIIuf"
      },
      "execution_count": 86,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "C=0\n",
        "#predictedLabel --> yp\n",
        "#originalLabel  --> y\n",
        "\n",
        "for y, yp in zip(Y, cluster_ids_x):\n",
        "    if y==yp:\n",
        "        C += 1\n",
        "print(f'{C/len(Y)}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZgE4aGKsAUxA",
        "outputId": "6f9333f0-dfa3-49a4-d8c9-967a90ebd0ea"
      },
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0016274717226788184\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.save(arr=cluster_ids_x, file='PyTorchKMeans+ESM1v')"
      ],
      "metadata": {
        "id": "Yyq48SkvLf-A"
      },
      "execution_count": 88,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# device"
      ],
      "metadata": {
        "id": "jBKjSK6HJtgF"
      },
      "execution_count": 89,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# !nvidia-smi"
      ],
      "metadata": {
        "id": "mDIVvrdjJv0X"
      },
      "execution_count": 90,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### K-Means (PyTorch batch-wise Acceleration)"
      ],
      "metadata": {
        "id": "rKRVDwiSmWC0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# print(cluster_ids_x)\n",
        "# print(cluster_centers)"
      ],
      "metadata": {
        "id": "rDIhM_N01tH6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# cluster_centers"
      ],
      "metadata": {
        "id": "2ukPmQKv3R37"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# begin = time.time()\n",
        "\n",
        "# cluster_ids_x, cluster_centers = kmeans(\n",
        "#     X=b2,\n",
        "#     num_clusters=num_clusters,\n",
        "#     cluster_centers = cluster_centers,\n",
        "#     distance='cosine',\n",
        "#     device=device,\n",
        "# )\n",
        "\n",
        "# print()\n",
        "# print(time.time() - begin)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "73UiyrMI1ZOY",
        "outputId": "8d0d8b28-831d-4464-e934-69f463b3ef33"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "running k-means on cpu..\n",
            "resuming\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[running kmeans]: 38it [00:57,  1.53s/it, center_shift=0.000000, iteration=38, tol=0.000100]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "59.47051739692688\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# begin = time.time()\n",
        "\n",
        "# cluster_ids_x, cluster_centers = kmeans(\n",
        "#     X=b3,\n",
        "#     cluster_centers = cluster_centers,\n",
        "#     num_clusters=num_clusters,\n",
        "#     distance='cosine',\n",
        "#     device=device\n",
        "# )\n",
        "\n",
        "# print()\n",
        "# print(time.time() - begin)"
      ],
      "metadata": {
        "id": "PvNefq3V1ysP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1144651-905e-4698-bd04-eb0fd9591cdb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "running k-means on cpu..\n",
            "resuming\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[running kmeans]: 33it [00:49,  1.51s/it, center_shift=0.000000, iteration=33, tol=0.000100]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "51.37775921821594\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# print(cluster_ids_x)\n",
        "# print(cluster_centers)"
      ],
      "metadata": {
        "id": "f8GfYrYcMg0_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# begin = time.time()\n",
        "\n",
        "# cluster_ids_x, cluster_centers = kmeans(\n",
        "#     X=b4,\n",
        "#     num_clusters=num_clusters,\n",
        "#     distance='cosine',\n",
        "#     cluster_centers = cluster_centers,\n",
        "#     device=device\n",
        "# )\n",
        "\n",
        "# print()\n",
        "# print(time.time() - begin)"
      ],
      "metadata": {
        "id": "eV-d9Whm10GD"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# print(cluster_ids_x)\n",
        "# print(cluster_centers)"
      ],
      "metadata": {
        "id": "wUHYxW_K2CRb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# cluster_ids_X = kmeans_predict(\n",
        "#     X=X[:32000],\n",
        "#     cluster_centers = cluster_centers,\n",
        "#     distance='cosine',\n",
        "#     device=device,\n",
        "# )"
      ],
      "metadata": {
        "id": "CB6wAtg32ftg"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# cluster_ids_X"
      ],
      "metadata": {
        "id": "fjzbhKkI2lFj"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# len(set(cluster_ids_X))"
      ],
      "metadata": {
        "id": "HhX3-7gvCX7f"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# cluster_centers.shape"
      ],
      "metadata": {
        "id": "AwszXGTjMoVt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### K-Means (NLTK Acceleration)"
      ],
      "metadata": {
        "id": "MyUJgO1LlzF4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from nltk.cluster import KMeansClusterer, cosine_distance\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "3F4wbq2TXCvK"
      },
      "execution_count": 128,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# vectors = [np.array(f) for f in [[2, 1], [1, 3], [4, 7], [6, 7]]]\n",
        "# # means = [[4, 3], [5, 5]]"
      ],
      "metadata": {
        "id": "IH6HZ028X_VX"
      },
      "execution_count": 129,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# dataset load\n",
        "X = np.load('/drive/My Drive/ESM/Xb-24578.npy')\n",
        "Y = np.load('/drive/My Drive/ESM/originalLabels.npy')\n",
        "\n",
        "print(X.shape)\n",
        "print(Y.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4KgcyTUAWQAZ",
        "outputId": "f5a76f24-9e80-4ed3-fa0c-a99f917940f4"
      },
      "execution_count": 130,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(24578, 1280)\n",
            "(24578,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "K=192\n",
        "\n",
        "begin = time.time()\n",
        "\n",
        "model = KMeansClusterer(num_means=K, \n",
        "                        distance=cosine_distance,\n",
        "                        initial_means=None,\n",
        "                        repeats=1)\n",
        "clusters = model.cluster(X, True, trace=True)\n",
        "\n",
        "# print(\"Clustered:\", vectors)\n",
        "print(\"Predicted clusters:\", clusters)\n",
        "print(\"Means:\", model.means())\n",
        "print()\n",
        "\n",
        "print(f'Time elapsed: {(time.time() - begin)/60.0} minutes')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8-kMldKFXGo5",
        "outputId": "2e4e3e87-a900-46f3-f5c4-3c34b2aad4b0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "k-means trial 0\n",
            "iteration\n",
            "iteration\n",
            "iteration\n",
            "iteration\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# help(KMeansClusterer)"
      ],
      "metadata": {
        "id": "E6gxBaLXXWVe"
      },
      "execution_count": 120,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#predictedLabel --> yp\n",
        "#originalLabel  --> y\n",
        "\n",
        "C=0\n",
        "for y, yp in zip(Y, clusters):\n",
        "    if y==yp:\n",
        "        C += 1\n",
        "print(f'{C/len(Y)}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l0cU5TiVWMwg",
        "outputId": "d9539a4d-2afa-4668-d5ee-bbca6d80ef0e"
      },
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0045976076165676625\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.save(arr=clusters, file='NLTK+HC+ESM1b')"
      ],
      "metadata": {
        "id": "dtSYB_gzWbeA"
      },
      "execution_count": 122,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "len(clusters)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PDNXBnaTXrhe",
        "outputId": "dae2d106-f3cc-443f-861f-536260aa90aa"
      },
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24578"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "machine_shape": "hm",
      "name": "Clustering-kmeans-HC.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOeP0nGmshEnXiXm1XPT4P8",
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}