Quantum_K_Means.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "QsUYbDy9ri4b",
      "metadata": {
        "id": "QsUYbDy9ri4b"
      },
      "source": [
        "# $$⚛ \\space Quantum \\space K-Means\\space Clustering $$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "0ec6805a-a351-46ba-a293-356dcde831b2",
      "metadata": {
        "id": "0ec6805a-a351-46ba-a293-356dcde831b2"
      },
      "outputs": [],
      "source": [
        "from numpy import ndarray\n",
        "import numpy as np\n",
        "\n",
        "import matplotlib.pylab as plt\n",
        "import seaborn as sns\n",
        "import pandas as pd\n",
        "\n",
        "from sklearn.metrics import silhouette_score\n",
        "\n",
        "from typing import Union, Optional"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "e1aca70a-2bd0-4a9c-9527-04781deca86f",
      "metadata": {
        "id": "e1aca70a-2bd0-4a9c-9527-04781deca86f"
      },
      "outputs": [],
      "source": [
        "from qiskit.circuit.library import (\n",
        "                        RXGate, RYGate, ZGate , XGate, YGate\n",
        "                        )\n",
        "from qiskit.visualization import array_to_latex"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "25WsTCaxrapD",
      "metadata": {
        "id": "25WsTCaxrapD"
      },
      "source": [
        "## Classical Clustering\n",
        "\n",
        "- determine the number of clusters\n",
        "- randomly initialize the centroids\n",
        "- measure distances between data points and the centroids >> Fidelity\n",
        "- assign data points to the nearest centroid\n",
        "- update the position of the centroid according to the mean of each cluster"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "vvom75xYwFpf",
      "metadata": {
        "id": "vvom75xYwFpf"
      },
      "outputs": [],
      "source": [
        "def kMeansInitCentroids(X : ndarray[float], K: int) -> ndarray[float]:\n",
        "    \"\"\"Initialize the centroids of the clusters.\n",
        "\n",
        "    Returns an initial centroid for each cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, N)\n",
        "        Data vector.\n",
        "\n",
        "    K : int\n",
        "        Number of clusters.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(K, N)\n",
        "        Initial centroids.\n",
        "    \"\"\"\n",
        "\n",
        "    m = X.shape[0]\n",
        "    idx = np.random.choice(m, K, replace=False)\n",
        "    centroids = X[idx]\n",
        "\n",
        "    return centroids\n",
        "\n",
        "\n",
        "\n",
        "def computeCentroids(X : ndarray[float] , idx : ndarray[int] , K : int = 2) -> ndarray[float] :\n",
        "    \"\"\"Update the centroids of the clusters.\n",
        "\n",
        "    Returns a new centroid for each cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, N)\n",
        "        Encoded Data vector.\n",
        "\n",
        "    idx : numpy.ndarray, shape=(M, )\n",
        "        Represent the cluster each point is assigned to.\n",
        "\n",
        "    K : int\n",
        "        Number of clusters.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(K, N)\n",
        "        Updated centroids.\n",
        "    \"\"\" \n",
        "\n",
        "    n = X.shape[1]\n",
        "    centroids = np.zeros((K, n))\n",
        "\n",
        "    for i in range(K):\n",
        "        cluster_points = X[idx == i]\n",
        "        if len(cluster_points) > 0:\n",
        "            centroids[i] = np.mean(cluster_points, axis=0)\n",
        "\n",
        "    return centroids\n",
        "\n",
        "\n",
        "def findClosestCentroids(X : ndarray[float], centroids : ndarray[float]) -> ndarray[int]:\n",
        "    \"\"\"Find the closest centroids for each point.\n",
        "\n",
        "    Returns an array where each point is assigned to the closest cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, N)\n",
        "        Data vector.\n",
        "\n",
        "\n",
        "    centroids : numpy.ndarray, shape=(K, N)\n",
        "        Represent the encoded centroids.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(M, )\n",
        "        Array where each point is assigned to the closest cluster.\n",
        "    \"\"\" \n",
        "    m = X.shape[0]\n",
        "    closest_centroids = np.zeros(m)\n",
        "\n",
        "    for i in range(m):\n",
        "        distances = np.linalg.norm(X[i] - centroids, axis=1)\n",
        "        closest_centroids[i] = np.argmin(distances)\n",
        "\n",
        "    return closest_centroids\n",
        "\n",
        "\n",
        "def k_means(X : ndarray[float], k: int = 2, max_iter : int = 300) -> tuple[ndarray[float], ndarray[int]]:\n",
        "    \"\"\"K-Means algorithm for clustring the data into K clusters.\n",
        "\n",
        "    Returns the centroids and an array where each point is assigned to the closest cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, N)\n",
        "        Data vector.\n",
        "        \n",
        "    K : int\n",
        "        Number of clusters.\n",
        "        \n",
        "    max_iter : int\n",
        "        Number of iteration.\n",
        "        \n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(K, N)\n",
        "        The centroids.\n",
        "    \n",
        "    numpy.ndarray, shape=(M, )\n",
        "        Array where each point is assigned to the closest cluster.\n",
        "    \"\"\" \n",
        "\n",
        "    centroids = kMeansInitCentroids(X, k)\n",
        "    for _ in range(max_iter):\n",
        "        idx = findClosestCentroids(X, centroids)\n",
        "        centroids = computeCentroids(X, idx, k)\n",
        "\n",
        "    return centroids, idx"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "83acd0ab",
      "metadata": {},
      "source": [
        "#### Create The Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "CUB4q4Saz2Yi",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "CUB4q4Saz2Yi",
        "outputId": "d5330985-4616-4076-8152-7effaf37042a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#### Implement a function to create the datasets\n",
        "def CreateDataset(mean1 : float, mean2 : float, std1 : float, \n",
        "                  std2 : float, n_samples : int = 100) -> tuple[ndarray]:\n",
        "    \"\"\"\n",
        "    Create a normally distributed datasets.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    mean1 : float\n",
        "        Mean of the first dataset.\n",
        "    \n",
        "    mean2 : float\n",
        "        Mean of the second dataset.\n",
        "\n",
        "    std1 : float\n",
        "        Standard deviation of the first dataset.\n",
        "\n",
        "    std2 : float\n",
        "        Standard deviation of the second dataset.\n",
        "\n",
        "    n_samples : int\n",
        "        Number of samples required for each dataset.\n",
        "    \"\"\"\n",
        "\n",
        "    x1 = np.random.normal(mean1, std1, n_samples)\n",
        "    y1 = np.ones(len(x1))\n",
        "\n",
        "    x2 = np.random.normal(mean2, std2, n_samples)\n",
        "    y2 = np.zeros(len(x2))\n",
        "\n",
        "    return x1, x2, y1, y2\n",
        "\n",
        "#### Creating the datasets\n",
        "x1, x2, y1, y2 = CreateDataset(2, -2, .1, .1, 100)\n",
        "\n",
        "#### Visualize the dataset\n",
        "plt.scatter(x1, y1)\n",
        "plt.scatter(x2, y2);"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "Pmve7tbz0aeM",
      "metadata": {
        "id": "Pmve7tbz0aeM"
      },
      "source": [
        "### Testing Classical Clustering\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "gG5gZnrP1P5d",
      "metadata": {
        "id": "gG5gZnrP1P5d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "((200, 1), (200, 1), (200, 2))"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#### Data preprocesing (concatenation)\n",
        "X = np.concatenate((x1,x2)).reshape(-1,1)\n",
        "Y = np.concatenate((y1,y2)).reshape(-1,1)\n",
        "Data = np.concatenate((X,Y), axis = 1)\n",
        "\n",
        "#### Validate the shapes\n",
        "X.shape, Y.shape, Data.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "4bc07b2a",
      "metadata": {},
      "outputs": [],
      "source": [
        "#### Running the Classical K-Means\n",
        "centroids, idx = k_means(X, 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8d87c6ba",
      "metadata": {},
      "source": [
        "### Create Visualize Function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "pfhM4k1j3vI4",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "pfhM4k1j3vI4",
        "outputId": "e3fdbc1d-dca2-42c7-dff5-73be1000af4d"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def visualize(X : ndarray[float], idx : ndarray[int], centroids : Union[ndarray[float], list]) -> Optional[AssertionError]:\n",
        "    \"\"\"Visualize the clusters and the centroid of each cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, 1)\n",
        "        Encoded Data vector.\n",
        "\n",
        "    idx : numpy.ndarray, shape=(M, )\n",
        "        Represent the cluster each point is assigned to.\n",
        "\n",
        "    centroids : numpy.ndarray, shape=(K, 1)\n",
        "        Centroids of clusters.\n",
        "    \n",
        "    Notes\n",
        "    -----\n",
        "        This function only works with one feature.\n",
        "    \"\"\"\n",
        "\n",
        "    assert X.shape[1] == 1, \"This function only works with one feature\"\n",
        "    \n",
        "    #### Visualize the clustered data\n",
        "    df = pd.DataFrame(np.concatenate((X, idx.reshape(-1, 1)), axis=1), columns=['X', 'idx'])\n",
        "    sns.scatterplot(data=df, x='X', y='idx', hue='idx')\n",
        "\n",
        "    #### Plot the centroids\n",
        "    plt.scatter(centroids[0], 0, c='red', label='Centroid 0')\n",
        "    plt.scatter(centroids[1], 1, c='green', label='Centroid 1');\n",
        "    plt.legend()\n",
        "\n",
        "visualize(X, idx, centroids)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "i1ON8M5jrauB",
      "metadata": {
        "id": "i1ON8M5jrauB"
      },
      "source": [
        "## Quantum Clustering"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "SlOhjg2EvLPu",
      "metadata": {
        "id": "SlOhjg2EvLPu"
      },
      "source": [
        "### Quantum Pre-processing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "628db98f",
      "metadata": {},
      "outputs": [],
      "source": [
        "def init_state() -> ndarray:\n",
        "    \"\"\"\n",
        "    Set the initial state to the ground state (zero vector)\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(2, 1)\n",
        "        Zero vector.\n",
        "    \"\"\"\n",
        "\n",
        "    zero_vec = np.array([[1], [0]])\n",
        "\n",
        "    return zero_vec"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "084510bc",
      "metadata": {},
      "outputs": [],
      "source": [
        "def encode_data(init_state : ndarray[complex] , x : ndarray[float]) -> ndarray[complex]:\n",
        "    \"\"\"\n",
        "    Encode data on a qbit using rotatinal gate => RYGate()\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    init_state : numpy.ndarray, shape=(2, 1)\n",
        "        The ground state.\n",
        "\n",
        "    x : numpy.ndarray, shape=(M, 1) | (K, 1)\n",
        "        Data vector or Centroids.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(M, 2, 1)\n",
        "        The encoded data vector.\n",
        "        \n",
        "    Notes\n",
        "    -------\n",
        "    Here we start in an initial state ( zero vector) and apply a rotetinal gate\n",
        "    on this state using the value of each data point.\n",
        "    \"\"\"\n",
        "\n",
        "    evolved_state = []\n",
        "    for point in x:\n",
        "      ry = RYGate(float(point)).to_matrix()\n",
        "      encoded = ry @ init_state\n",
        "      evolved_state.append(encoded)\n",
        "\n",
        "    evolved_state = np.array(evolved_state)\n",
        "    \n",
        "    return evolved_state"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "76cb1168",
      "metadata": {},
      "outputs": [],
      "source": [
        "def calc_fidelity(state1: ndarray[complex]  , state2 : ndarray[complex]) -> float :\n",
        "    \"\"\"\n",
        "    Calculate the fidelity (inner product) between any two quantum states.\n",
        "\n",
        "    Returns the fidelity between the encoded data point and the encoced centroid.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    state1 : numpy.ndarray, shape=(2, 1)\n",
        "        The first state.\n",
        "\n",
        "    state2 : numpy.ndarray, shape=(2, 1)\n",
        "        The second state.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    float\n",
        "        Inner product of the states.\n",
        "\n",
        "    Notes\n",
        "    -----\n",
        "    the output should be a real scalar between 0 and 1.\n",
        "\n",
        "    \"\"\"\n",
        "    \n",
        "    return np.vdot(state1, state2).real"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "88Kiawl6vORj",
      "metadata": {
        "id": "88Kiawl6vORj"
      },
      "outputs": [],
      "source": [
        "def measure(state : ndarray[complex], observable : ndarray[complex]) -> float:\n",
        "    \"\"\"\n",
        "    Measure the state of the Qubit on the observable.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    state : numpy.ndarray, shape=(2, 1)\n",
        "        The state (Centroid).\n",
        "\n",
        "    observable : numpy.ndarray, shape=(2, 2)\n",
        "        The observable (ZGate).\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    float\n",
        "        Classical output of the system.\n",
        "\n",
        "    \"\"\"\n",
        "    \n",
        "    return (state.conj().T @ observable @ state).real"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0a1f4d9b",
      "metadata": {},
      "source": [
        "#### Here we defined three essential functions to implement Quantum K-Means <br>\n",
        "- The first function is *`init_state`*,  Assuming our initial state is always zero vector with shape `(2, 1)`.  why?\n",
        "\n",
        "    - Because we have **one feuture** and a **singel Qubit** for encoding data in our system.<br>\n",
        "- The second function is *`encode_data`* this function is used to encode both Data and centroids <br>\n",
        "- The third function is *`calc_fidelity`* it only calculates the similarity between the data point and each cluster.<br>\n",
        "- The fourth function is *`measure`* it converts the state of the quantum system to a **real classical value**.(`irreversible process`)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f206a00c",
      "metadata": {},
      "source": [
        "### Quantum K-Means\n",
        "- determine the number of clusters\n",
        "- randomly initialize the centroids\n",
        "- measure distances between data points and the centroids >> Fidelity\n",
        "  - Initialize three separable states in the ground state. One is for the data point and the other two represent the centroid.\n",
        "  - choose your encoding scheme\n",
        "  - using a for loop you will pick a classical point to measure the distance between the centroids and this sample.\n",
        "  - encode the data using the encoding scheme (rotational gates)\n",
        "  - apply the selected rotational gates on the states\n",
        "  - then calculate the fidelity between the two states (one state would represent the data point and the other would represent the centroid)\n",
        "- assign data points to the nearest centroid\n",
        "- update the position of the centroid according to the mean of each cluster"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "id": "968372a1",
      "metadata": {},
      "outputs": [],
      "source": [
        "def kMeansInitCentroidsQ(X : ndarray[float], K: int) -> ndarray[complex]:\n",
        "    \"\"\"\n",
        "    Initialize the centroids of the clusters.\n",
        "\n",
        "    Returns an initial centroid for each cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, 1)\n",
        "        Data vector.\n",
        "\n",
        "    K : int\n",
        "        Number of clusters.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(K, 2, 1)\n",
        "        Encoded initial centroids.\n",
        "    \"\"\"\n",
        "\n",
        "    M = X.shape[0]\n",
        "    choices = np.random.choice(M, K, replace=False)\n",
        "    centroids = X[choices]\n",
        "    init_state_arr = init_state()\n",
        "    encoded_centroids = encode_data(init_state_arr, centroids )\n",
        "    \n",
        "    return encoded_centroids"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "id": "6e11da88",
      "metadata": {},
      "outputs": [],
      "source": [
        "def findClosestCentroidsQ(X : ndarray[complex], centroids : ndarray[complex]) -> ndarray[int]:\n",
        "    \"\"\"Find the closest centroids for each point.\n",
        "\n",
        "    Returns an array where each point is assigned to the closest cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, 2, 1)\n",
        "        Encoded data vector.\n",
        "\n",
        "\n",
        "    centroids : numpy.ndarray, shape=(K, 2, 1)\n",
        "        Represent the encoded centroids.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(M, )\n",
        "        Array where each point is assigned to the closest cluster.\n",
        "    \"\"\" \n",
        "    M = X.shape[0]\n",
        "    idx = np.zeros(M)\n",
        "\n",
        "    \n",
        "    for i in range(M):\n",
        "        fids = []\n",
        "        for cent in centroids:\n",
        "            fidelity = calc_fidelity(X[i], cent)\n",
        "            fids.append(fidelity)\n",
        "        idx[i] = np.argmax(fids)\n",
        "\n",
        "    return idx"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "626cba6d",
      "metadata": {},
      "outputs": [],
      "source": [
        "def computeCentroidsQ(X : ndarray[complex], idx : ndarray[int], K : int = 2) -> ndarray[complex] :\n",
        "    \"\"\"Update the centroids of the clusters.\n",
        "\n",
        "    Returns a new centroid for each cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, 1)\n",
        "        Encoded Data vector.\n",
        "\n",
        "    idx : numpy.ndarray, shape=(M, )\n",
        "        Represent the cluster each point is assigned to.\n",
        "\n",
        "    K : int\n",
        "        Number of clusters.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(K, 2, 1)\n",
        "        Updated centroids.\n",
        "    \"\"\" \n",
        "\n",
        "    centroids = np.zeros((K, 2, 1), dtype=complex)\n",
        "\n",
        "    for i in range(K):\n",
        "      cluster_points = X[idx == i]\n",
        "      if len(cluster_points) > 0:\n",
        "          centroids[i] = np.mean(cluster_points, axis=0)\n",
        "          \n",
        "    return centroids"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "d67fd646",
      "metadata": {},
      "outputs": [],
      "source": [
        "def k_meansQ(X : ndarray[float], k: int = 2, max_iter : int = 300) -> tuple[ndarray[complex], ndarray[int]]:\n",
        "    \"\"\"K-Means algorithm for clustring the data into K clusters.\n",
        "\n",
        "    Returns the centroids and an array where each point is assigned to the closest cluster.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    X : numpy.ndarray, shape=(M, 1)\n",
        "        Data vector.\n",
        "        \n",
        "    K : int\n",
        "        Number of clusters.\n",
        "        \n",
        "    max_iter : int\n",
        "        Number of iteration.\n",
        "        \n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    numpy.ndarray, shape=(K, 2, 1)\n",
        "        Represent the encoded centroids.\n",
        "\n",
        "    numpy.ndarray, shape=(M, 1)\n",
        "        Array where each point is assigned to the closest cluster.\n",
        "    \"\"\" \n",
        "    \n",
        "    centroids = kMeansInitCentroidsQ(X, k)\n",
        "\n",
        "    points_init_state = init_state()\n",
        "    encoded_X = encode_data(points_init_state, X)\n",
        "\n",
        "    for _ in range(max_iter):\n",
        "        idx = findClosestCentroidsQ(encoded_X, centroids)\n",
        "        centroids = computeCentroidsQ(encoded_X, idx, k)\n",
        "        \n",
        "    return centroids, idx"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0832c1ab",
      "metadata": {},
      "source": [
        "### Running Quantum K-Mean"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "d4975d16",
      "metadata": {},
      "outputs": [],
      "source": [
        "centroids_encoded, idx = k_meansQ(X, 2, 200)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8bbbdcd0",
      "metadata": {},
      "source": [
        "### Measuring Centroids"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "id": "4a6626ea",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(2, 2)"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# hamiltonian or Observable\n",
        "z_gate = ZGate().to_matrix()\n",
        "y_gate = YGate().to_matrix()\n",
        "x_gate = XGate().to_matrix()\n",
        "\n",
        "z_gate.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "id": "ca002788",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[array(0.90784291), array(-0.9074525)]"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "centroids = []\n",
        "# centroids.append(measure(centroids_encoded[0], z_gate).squeeze())\n",
        "# centroids.append(measure(centroids_encoded[1], z_gate).squeeze())\n",
        "centroids.append(measure(centroids_encoded[0], x_gate).squeeze())\n",
        "centroids.append(measure(centroids_encoded[1], x_gate).squeeze())\n",
        "# centroids.append(measure(centroids_encoded[0], y_gate).squeeze())\n",
        "# centroids.append(measure(centroids_encoded[1], y_gate).squeeze())\n",
        "centroids"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1c73783d",
      "metadata": {},
      "source": [
        "### Cluster Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "id": "4e2cfcf8",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.9708670507986779"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "silhouette_score(X, idx)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "851bea2b",
      "metadata": {},
      "source": [
        "### Visualize The Clusters and the centroids"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "id": "a167d61c",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "visualize(X, idx, centroids)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Observations\n",
        "- Enconding the date with RYGate -> results in a better clustring specially with measuring on the x-axis.\n",
        "- The output of the quantum system when measured is constrained between `-1 and 1` because the eigenvalues of observables are `-1 and 1`, there for it will be better to scale the data in this range.\n",
        "- Measuring on the same axis of encoding yeilds unuseful results."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d8d87167",
      "metadata": {},
      "source": [
        "---\n",
        "$$ Good \\space Luck ✨$$ "
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.10.3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}