GMM_Implementation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "GMM_Implementation.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tFr3s1eh9_Mi"
      },
      "source": [
        "# Gaussian Mixture Models Implementation\n",
        "Oscar Contreras Carrasco\n",
        "\n",
        "Hi everyone! This is a full implementation of Gaussian Mixture Models in Python. I really hope you will find it useful to further understand how the algorithm works.\n",
        "\n",
        "Let's first import the libraries we are going to be using throughout the exercise:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "irGOL_Dcw8ja"
      },
      "source": [
        "import imageio\n",
        "import matplotlib.animation as ani\n",
        "import matplotlib.cm as cmx\n",
        "import matplotlib.colors as colors\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "from matplotlib.patches import Ellipse\n",
        "from PIL import Image\n",
        "from sklearn import datasets\n",
        "from sklearn.cluster import KMeans"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hN_TKq1kVRJT"
      },
      "source": [
        "For the purposes of this exercise, we will be using the Iris dataset, which is probably already familiar to you. We can easily obtain it by using the __load_iris__ function provided by sklearn:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mcCzJFnT_fRQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6132d687-b3bd-4620-996a-d729893231b3"
      },
      "source": [
        "iris = datasets.load_iris()\n",
        "X = iris.data\n",
        "X[:20]"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5.1, 3.5, 1.4, 0.2],\n",
              "       [4.9, 3. , 1.4, 0.2],\n",
              "       [4.7, 3.2, 1.3, 0.2],\n",
              "       [4.6, 3.1, 1.5, 0.2],\n",
              "       [5. , 3.6, 1.4, 0.2],\n",
              "       [5.4, 3.9, 1.7, 0.4],\n",
              "       [4.6, 3.4, 1.4, 0.3],\n",
              "       [5. , 3.4, 1.5, 0.2],\n",
              "       [4.4, 2.9, 1.4, 0.2],\n",
              "       [4.9, 3.1, 1.5, 0.1],\n",
              "       [5.4, 3.7, 1.5, 0.2],\n",
              "       [4.8, 3.4, 1.6, 0.2],\n",
              "       [4.8, 3. , 1.4, 0.1],\n",
              "       [4.3, 3. , 1.1, 0.1],\n",
              "       [5.8, 4. , 1.2, 0.2],\n",
              "       [5.7, 4.4, 1.5, 0.4],\n",
              "       [5.4, 3.9, 1.3, 0.4],\n",
              "       [5.1, 3.5, 1.4, 0.3],\n",
              "       [5.7, 3.8, 1.7, 0.3],\n",
              "       [5.1, 3.8, 1.5, 0.3]])"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vgz6E8z9VaVJ"
      },
      "source": [
        "Let us now implement the Gaussian density function. Ahem... I know you can use numpy functions for that, but I believe it is actually interesting to see how things work internally. Our aim is to create a function that implements this:\n",
        "\n",
        "\\begin{equation}\n",
        "\\large\n",
        "p(\\mathbf x | \\mathbf\\mu, \\mathbf\\Sigma) = \\frac 1 {({2\\pi})^{n/2}|\\Sigma|^{1/2}}\\exp\\left(-\\frac 1 2 (\\mathbf x -\\mathbf\\mu)^T\\mathbf\\Sigma^{-1}(\\mathbf x -\\mathbf\\mu)\\right)\n",
        "\\end{equation}\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wk9WlrFVHtcN"
      },
      "source": [
        "def gaussian(X, mu, cov):\n",
        "    n = X.shape[1]\n",
        "    diff = (X - mu).T\n",
        "    return np.diagonal(1 / ((2 * np.pi) ** (n / 2) * np.linalg.det(cov) ** 0.5) * np.exp(-0.5 * np.dot(np.dot(diff.T, np.linalg.inv(cov)), diff))).reshape(-1, 1)"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OiJ_cem5W_Cp"
      },
      "source": [
        "You can try this function by using the code in next cell. You should obtain something like:\n",
        "\n",
        "array([[0.00159853],\n",
        "       [0.00481869],\n",
        "       [0.00276259],\n",
        "       [0.0014309 ],\n",
        "       [0.00143998]])"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7PHi0Tu4xQAS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4b461c95-5623-448f-cb44-140a541fdc82"
      },
      "source": [
        "x0 = np.array([[0.05, 1.413, 0.212], [0.85, -0.3, 1.11], [11.1, 0.4, 1.5], [0.27, 0.12, 1.44], [88, 12.33, 1.44]])\n",
        "mu = np.mean(x0, axis=0)\n",
        "cov = np.dot((x0 - mu).T, x0 - mu) / (x0.shape[0] - 1)\n",
        "\n",
        "y = gaussian(x0, mu=mu, cov=cov)\n",
        "y"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.00159853],\n",
              "       [0.00481869],\n",
              "       [0.00276259],\n",
              "       [0.0014309 ],\n",
              "       [0.00143998]])"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NsxI7u2NXpWY"
      },
      "source": [
        "__Step 1__\n",
        "\n",
        "This is the initialization step of the GMM. At this point, we must initialise our parameters $\\pi_k$, $\\mu_k$, and $\\Sigma_k$. In this case, we are going to use the results of KMeans as an initial value for $\\mu_k$, set $\\pi_k$ to one over the number of clusters and $\\Sigma_k$ to the identity matrix. We could also use random numbers for everything, but using a sensible initialisation procedure will help the algorithm achieve better results."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XEZjEtUqRfgG"
      },
      "source": [
        "def initialize_clusters(X, n_clusters):\n",
        "    clusters = []\n",
        "    idx = np.arange(X.shape[0])\n",
        "    \n",
        "    # We use the KMeans centroids to initialise the GMM\n",
        "    \n",
        "    kmeans = KMeans(n_clusters).fit(X)\n",
        "    mu_k = kmeans.cluster_centers_\n",
        "    \n",
        "    for i in range(n_clusters):\n",
        "        clusters.append({\n",
        "            'pi_k': 1.0 / n_clusters,\n",
        "            'mu_k': mu_k[i],\n",
        "            'cov_k': np.identity(X.shape[1], dtype=np.float64)\n",
        "        })\n",
        "        \n",
        "    return clusters"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b4HIKt0OYCex"
      },
      "source": [
        "**Step 2 (Expectation step)**\n",
        "\n",
        "We should now calculate $\\gamma(z_{nk})$. We can achieve this by means of the following expression:\n",
        "\n",
        "\\begin{equation}\n",
        "\\large\n",
        "\\gamma{(z_{nk})}=\\frac {\\pi_k\\mathcal N(\\mathbf x_n| \\mathbf\\mu_k, \\mathbf\\Sigma_k)}{\\sum_{j=1}^K\\pi_j\\mathcal N(\\mathbf x_n| \\mathbf\\mu_j, \\mathbf\\Sigma_j)}\n",
        "\\end{equation}\n",
        "\n",
        "For convenience, we just calculate the denominator as a sum over all terms in the numerator, and then assign it to a variable named __totals__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "78Xqp2nSGugd"
      },
      "source": [
        "def expectation_step(X, clusters):\n",
        "    global gamma_nk, totals\n",
        "    N = X.shape[0]\n",
        "    K = len(clusters)\n",
        "    totals = np.zeros((N, 1), dtype=np.float64)\n",
        "    gamma_nk = np.zeros((N, K), dtype=np.float64)\n",
        "    \n",
        "    for k, cluster in enumerate(clusters):\n",
        "        pi_k = cluster['pi_k']\n",
        "        mu_k = cluster['mu_k']\n",
        "        cov_k = cluster['cov_k']\n",
        "    \n",
        "        gamma_nk[:, k] = (pi_k * gaussian(X, mu_k, cov_k)).ravel()\n",
        "    \n",
        "    totals = np.sum(gamma_nk, 1)\n",
        "    gamma_nk /= np.expand_dims(totals, 1)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_VHT5Ph1ZAFu"
      },
      "source": [
        "**Step 3 (Maximization step):**\n",
        "\n",
        "Let us now implement the maximization step. Since $\\gamma(z_{nk})$ is common to the expressions for $\\pi_k$, $\\mu_k$ and $\\Sigma_k$, we can simply define:\n",
        "\n",
        "\\begin{equation}\n",
        "\\large\n",
        "N_k=\\sum_{n=1}^N\\gamma({z_{nk}})\n",
        "\\end{equation}\n",
        "\n",
        "And then we can calculate the revised parameters by using:\n",
        "\n",
        "\\begin{equation}\n",
        "\\large\n",
        "\\pi_k^*=\\frac {N_k} N\n",
        "\\end{equation}\n",
        "\n",
        "\n",
        "\\begin{equation}\n",
        "\\large\n",
        "\\mu_k^*=\\frac 1 {N_k} \\sum_{n=1}^N\\gamma({z_{nk}})\\mathbf x_n\n",
        "\\end{equation}\n",
        "\n",
        "\n",
        "\\begin{equation}\n",
        "\\large\n",
        "\\Sigma_k^*=\\frac 1 {N_k} \\sum_{n=1}^N\\gamma({z_{nk}})(\\mathbf x_n-\\mathbf\\mu_k)(\\mathbf x_n-\\mathbf\\mu_k)^T\n",
        "\\end{equation}\n",
        "\n",
        "Note: To calculate the covariance, we define an auxiliary variable __diff__ that contains $(x_n-\\mu_k)^T$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Z7K5jrEJHHu"
      },
      "source": [
        "def maximization_step(X, clusters):\n",
        "    global gamma_nk\n",
        "    N = float(X.shape[0])\n",
        "  \n",
        "    for k, cluster in enumerate(clusters):\n",
        "        gamma_k = np.expand_dims(gamma_nk[:, k], 1)\n",
        "        N_k = np.sum(gamma_k, axis=0)\n",
        "        \n",
        "        pi_k = N_k / N\n",
        "        mu_k = np.sum(gamma_k * X, axis=0) / N_k\n",
        "        cov_k = (gamma_k * (X - mu_k)).T @ (X - mu_k) / N_k\n",
        "        \n",
        "        cluster['pi_k'] = pi_k\n",
        "        cluster['mu_k'] = mu_k\n",
        "        cluster['cov_k'] = cov_k"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qzbylmjoa_61"
      },
      "source": [
        "Let us now determine the log-likelihood of the model. It is given by:\n",
        "\n",
        "\\begin{equation}\n",
        "\\large\n",
        "\\ln p(\\mathbf X)=\\sum_{n=1}^N\\ln\\sum_{k=1}^K\\pi_k\\mathcal N(\\mathbf x_n|\\mu_k,\\Sigma_k)\n",
        "\\end{equation}\n",
        "\n",
        "However, the second summation has already been calculated in the __expectation_step__ function and is available in the __totals__ variable. So we just make use of it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vzVrZY6PTMR8"
      },
      "source": [
        "def get_likelihood(X, clusters):\n",
        "    global gamma_nk, totals\n",
        "    sample_likelihoods = np.log(totals)\n",
        "    return np.sum(sample_likelihoods), sample_likelihoods"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oGSkyh33bNu8"
      },
      "source": [
        "Finally, let's put everything together! First, we are going to initialise the parameters by using the __initialise_clusters__ function, and then perform several expectation-maximization steps. In this case, we set the number of iterations of the training procedure to a fixed __n_epochs__ number. I have done this on purpose to generate graphs of the log-likelihood later."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9qWFzpI3Uq-9"
      },
      "source": [
        "def train_gmm(X, n_clusters, n_epochs):\n",
        "    clusters = initialize_clusters(X, n_clusters)\n",
        "    likelihoods = np.zeros((n_epochs, ))\n",
        "    scores = np.zeros((X.shape[0], n_clusters))\n",
        "    history = []\n",
        "\n",
        "    for i in range(n_epochs):\n",
        "        clusters_snapshot = []\n",
        "        \n",
        "        # This is just for our later use in the graphs\n",
        "        for cluster in clusters:\n",
        "            clusters_snapshot.append({\n",
        "                'mu_k': cluster['mu_k'].copy(),\n",
        "                'cov_k': cluster['cov_k'].copy()\n",
        "            })\n",
        "            \n",
        "        history.append(clusters_snapshot)\n",
        "      \n",
        "        expectation_step(X, clusters)\n",
        "        maximization_step(X, clusters)\n",
        "\n",
        "        likelihood, sample_likelihoods = get_likelihood(X, clusters)\n",
        "        likelihoods[i] = likelihood\n",
        "\n",
        "        print('Epoch: ', i + 1, 'Likelihood: ', likelihood)\n",
        "\n",
        "    scores = np.log(gamma_nk)\n",
        "    \n",
        "    return clusters, likelihoods, scores, sample_likelihoods, history"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QqhgdUKrbUrf"
      },
      "source": [
        "Let's train our model!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5h10mICZGwrh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0422a47d-2db7-43d3-b77c-2ea211435735"
      },
      "source": [
        "n_clusters = 3\n",
        "n_epochs = 50\n",
        "\n",
        "clusters, likelihoods, scores, sample_likelihoods, history = train_gmm(X, n_clusters, n_epochs)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  1 Likelihood:  -727.7880991223876\n",
            "Epoch:  2 Likelihood:  -229.33102066299756\n",
            "Epoch:  3 Likelihood:  -199.7481287796375\n",
            "Epoch:  4 Likelihood:  -195.73888520322583\n",
            "Epoch:  5 Likelihood:  -192.39610102342957\n",
            "Epoch:  6 Likelihood:  -189.9948025598058\n",
            "Epoch:  7 Likelihood:  -188.36696982597584\n",
            "Epoch:  8 Likelihood:  -187.12218440393474\n",
            "Epoch:  9 Likelihood:  -185.9688827396132\n",
            "Epoch:  10 Likelihood:  -184.90274085547037\n",
            "Epoch:  11 Likelihood:  -183.96159641602355\n",
            "Epoch:  12 Likelihood:  -183.12299960946618\n",
            "Epoch:  13 Likelihood:  -182.42175149358584\n",
            "Epoch:  14 Likelihood:  -181.8531428976812\n",
            "Epoch:  15 Likelihood:  -181.27453302608765\n",
            "Epoch:  16 Likelihood:  -180.67059402382154\n",
            "Epoch:  17 Likelihood:  -180.34032123839046\n",
            "Epoch:  18 Likelihood:  -180.23332341934022\n",
            "Epoch:  19 Likelihood:  -180.2004120937125\n",
            "Epoch:  20 Likelihood:  -180.19017245247892\n",
            "Epoch:  21 Likelihood:  -180.18696259547232\n",
            "Epoch:  22 Likelihood:  -180.18594920021096\n",
            "Epoch:  23 Likelihood:  -180.18562756299497\n",
            "Epoch:  24 Likelihood:  -180.18552514337966\n",
            "Epoch:  25 Likelihood:  -180.18549246812688\n",
            "Epoch:  26 Likelihood:  -180.18548203275674\n",
            "Epoch:  27 Likelihood:  -180.18547869814944\n",
            "Epoch:  28 Likelihood:  -180.18547763224765\n",
            "Epoch:  29 Likelihood:  -180.18547729147537\n",
            "Epoch:  30 Likelihood:  -180.185477182519\n",
            "Epoch:  31 Likelihood:  -180.18547714768022\n",
            "Epoch:  32 Likelihood:  -180.18547713654021\n",
            "Epoch:  33 Likelihood:  -180.1854771329779\n",
            "Epoch:  34 Likelihood:  -180.18547713183892\n",
            "Epoch:  35 Likelihood:  -180.18547713147473\n",
            "Epoch:  36 Likelihood:  -180.18547713135814\n",
            "Epoch:  37 Likelihood:  -180.18547713132088\n",
            "Epoch:  38 Likelihood:  -180.18547713130909\n",
            "Epoch:  39 Likelihood:  -180.18547713130522\n",
            "Epoch:  40 Likelihood:  -180.18547713130403\n",
            "Epoch:  41 Likelihood:  -180.18547713130357\n",
            "Epoch:  42 Likelihood:  -180.18547713130354\n",
            "Epoch:  43 Likelihood:  -180.18547713130351\n",
            "Epoch:  44 Likelihood:  -180.18547713130343\n",
            "Epoch:  45 Likelihood:  -180.18547713130346\n",
            "Epoch:  46 Likelihood:  -180.18547713130346\n",
            "Epoch:  47 Likelihood:  -180.1854771313035\n",
            "Epoch:  48 Likelihood:  -180.1854771313034\n",
            "Epoch:  49 Likelihood:  -180.18547713130337\n",
            "Epoch:  50 Likelihood:  -180.18547713130346\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ho3efim_bYxk"
      },
      "source": [
        "It is always a good idea to see how the log-likelihood is making progress. So let's create a graph reflecting that value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YV_9LG2WLGeZ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 607
        },
        "outputId": "729f02ff-fd74-4705-e26e-20492d4d3657"
      },
      "source": [
        "plt.figure(figsize=(10, 10))\n",
        "plt.title('Log-Likelihood')\n",
        "plt.plot(np.arange(1, n_epochs + 1), likelihoods)\n",
        "plt.show()"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V1RMlu7ybb6r"
      },
      "source": [
        "Let us now create a graph to visualise our clusters as well as the parameters for the Gaussian mixture. Essentially, what we do here is to create ellipses of different scales in order to map to the coordinates of each Gaussian."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eR5RLqt9HEzp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 592
        },
        "outputId": "1ce14324-1c80-4deb-b1ae-c1afd86e39a5"
      },
      "source": [
        "def create_cluster_animation(X, history, scores):\n",
        "    fig, ax = plt.subplots(1, 1, figsize=(10, 10))\n",
        "    colorset = ['blue', 'red', 'black']\n",
        "    images = []\n",
        "    \n",
        "    for j, clusters in enumerate(history):\n",
        "      \n",
        "        idx = 0\n",
        "      \n",
        "        if j % 3 != 0:\n",
        "            continue\n",
        "        \n",
        "        plt.cla()\n",
        "        \n",
        "        for cluster in clusters:\n",
        "            mu = cluster['mu_k']\n",
        "            cov = cluster['cov_k']\n",
        "\n",
        "            eigenvalues, eigenvectors = np.linalg.eigh(cov)\n",
        "            order = eigenvalues.argsort()[::-1]\n",
        "            eigenvalues, eigenvectors = eigenvalues[order], eigenvectors[:, order]\n",
        "            vx, vy = eigenvectors[:,0][0], eigenvectors[:,0][1]\n",
        "            theta = np.arctan2(vy, vx)\n",
        "\n",
        "            color = colors.to_rgba(colorset[idx])\n",
        "\n",
        "            for cov_factor in range(1, 4):\n",
        "                ell = Ellipse(xy=mu, width=np.sqrt(eigenvalues[0]) * cov_factor * 2, height=np.sqrt(eigenvalues[1]) * cov_factor * 2, angle=np.degrees(theta), linewidth=2)\n",
        "                ell.set_facecolor((color[0], color[1], color[2], 1.0 / (cov_factor * 4.5)))\n",
        "                ax.add_artist(ell)\n",
        "\n",
        "            ax.scatter(cluster['mu_k'][0], cluster['mu_k'][1], c=colorset[idx], s=1000, marker='+')\n",
        "            idx += 1\n",
        "\n",
        "        for i in range(X.shape[0]):\n",
        "            ax.scatter(X[i, 0], X[i, 1], c=colorset[np.argmax(scores[i])], marker='o')\n",
        "        \n",
        "        fig.canvas.draw()\n",
        "        \n",
        "        image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\n",
        "        image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n",
        "\n",
        "        images.append(image)\n",
        "    \n",
        "    kwargs_write = {'fps':1.0, 'quantizer':'nq'}\n",
        "    imageio.mimsave('./gmm.gif', images, fps=1)\n",
        "    plt.show(Image.open('gmm.gif').convert('RGB'))\n",
        "    \n",
        "    \n",
        "create_cluster_animation(X, history, scores)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7YlS_QKKbvmJ"
      },
      "source": [
        "By the way, you can also watch an animation of how the cluster estimations improve. You can just open the __gmm.gif__ file generated. Let's now test if our calculations are correct. In this case, we are using sklearn's GMM implementation to check for the parameters and probabilities."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W5TLvNKQ8LX6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ffc36d50-32e0-47b5-9f99-37fe455a960f"
      },
      "source": [
        "from sklearn.mixture import GaussianMixture\n",
        "\n",
        "gmm = GaussianMixture(n_components=n_clusters, max_iter=50).fit(X)\n",
        "gmm_scores = gmm.score_samples(X)\n",
        "\n",
        "print('Means by sklearn:\\n', gmm.means_)\n",
        "print('Means by our implementation:\\n', np.array([cluster['mu_k'].tolist() for cluster in clusters]))\n",
        "print('Scores by sklearn:\\n', gmm_scores[0:20])\n",
        "print('Scores by our implementation:\\n', sample_likelihoods.reshape(-1)[0:20])"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Means by sklearn:\n",
            " [[5.006      3.428      1.462      0.246     ]\n",
            " [6.54639415 2.94946365 5.48364578 1.98726565]\n",
            " [5.9170732  2.77804839 4.20540364 1.29848217]]\n",
            "Means by our implementation:\n",
            " [[5.006      3.428      1.462      0.246     ]\n",
            " [5.91496959 2.77784365 4.20155323 1.29696685]\n",
            " [6.54454865 2.94866115 5.47955343 1.98460495]]\n",
            "Scores by sklearn:\n",
            " [ 1.57050082  0.73787138  1.14436656  0.92913238  1.411028   -0.09451903\n",
            "  0.05266884  1.62442195  0.27082378  0.16706624  0.83489877  0.77168582\n",
            "  0.29597841 -1.79224582 -3.41557928 -2.10529279 -1.12995447  1.47503579\n",
            " -0.84612536  0.97699215]\n",
            "Scores by our implementation:\n",
            " [ 1.57057947  0.73793642  1.14444614  0.92920539  1.41110417 -0.09448868\n",
            "  0.05268031  1.62449505  0.27090462  0.16702226  0.83494742  0.77171947\n",
            "  0.29597776 -1.79222469 -3.41562626 -2.1052825  -1.1300608   1.47509939\n",
            " -0.84608424  0.9770596 ]\n"
          ]
        }
      ]
    }
  ]
}