Gibbs-Sampling-Implementation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "gJ0xc5gtyVGb"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf \n",
        "from sklearn.decomposition import PCA\n",
        "import seaborn as sns\n",
        "from tensorflow import keras\n",
        "from keras.utils import np_utils\n",
        "from sklearn import preprocessing\n",
        "from sklearn.preprocessing import OneHotEncoder"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()\n",
        "assert x_train.shape == (50000, 32, 32, 3)\n",
        "assert x_test.shape == (10000, 32, 32, 3)\n",
        "assert y_train.shape == (50000, 1)\n",
        "assert y_test.shape == (10000, 1)"
      ],
      "metadata": {
        "id": "_86JxKi5zi38",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8895e513-b82d-477b-c3ca-788c2723e6dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
            "170498071/170498071 [==============================] - 4s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "classes = np.unique(y_train)\n",
        "nClasses = len(classes)\n",
        "print('Number of Outputs: ', nClasses)\n",
        "print('Number of Output Classes: ', classes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pVfsHKmVz0ly",
        "outputId": "1e9048af-f24d-4779-9266-17467f85e754"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of Outputs:  10\n",
            "Number of Output Classes:  [0 1 2 3 4 5 6 7 8 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#plot images from dataset\n",
        "%matplotlib inline\n",
        "\n",
        "label_list = {\n",
        "    0: 'Airplane',\n",
        "    1: 'Automobile',\n",
        "    2: 'Bird',\n",
        "    3: 'Cat',\n",
        "    4: 'Deer',\n",
        "    5: 'Dog',\n",
        "    6: 'Frog',\n",
        "    7: 'Horse',\n",
        "    8: 'Ship',\n",
        "    9: 'Truck',\n",
        "}\n",
        "\n",
        "plt.figure(figsize = [10,10])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "xSSrE1zl0mOk",
        "outputId": "49027d31-def8-482b-a22d-7d7e11605466"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 0 Axes>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#display 1st image in training data\n",
        "plt.subplot(121)\n",
        "curr_img = np.reshape(x_train[0], (32,32,3))\n",
        "plt.imshow(curr_img)\n",
        "print(plt.title(\"(Label: \" + str(label_list[y_train[0][0]]) + \")\"))\n",
        "\n",
        "#display 1st image in testing data\n",
        "plt.subplot(122)\n",
        "curr_img = np.reshape(x_test[0], (32,32,3))\n",
        "plt.imshow(curr_img)\n",
        "print(plt.title(\"(Label: \" + str(label_list[y_test[0][0]]) + \")\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 251
        },
        "id": "NaSW_Nla0qTO",
        "outputId": "1de3c3dd-a5bd-478b-a28d-42b2bb7d4cfe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Text(0.5, 1.0, '(Label: Frog)')\n",
            "Text(0.5, 1.0, '(Label: Cat)')\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#check max and min values of dataset\n",
        "np.min(x_train), np.max(x_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OdfOFVWg0tPN",
        "outputId": "93a93e48-92d3-4c31-8e3e-5d6d1e5a1021"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0, 255)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#normalize pixels between 0 and 1\n",
        "x_train = x_train/255.0\n",
        "np.min(x_train), np.max(x_train)\n",
        "x_train.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9xIffyz204Wc",
        "outputId": "bc0cf356-6825-4af3-bb62-c430b00f31de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(50000, 32, 32, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#flatten images\n",
        "x_train_flat = x_train.reshape(-1,3072)\n",
        "feat_cols = ['pixel' + str(i) for i in range(x_train_flat.shape[1])]\n",
        "df_cifar = pd.DataFrame(x_train_flat, columns = feat_cols)\n",
        "df_cifar['Label'] = y_train\n",
        "print('Size of Data Frame: {}'.format(df_cifar.shape))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bSoZ6Sqz0605",
        "outputId": "7d92511b-614b-431c-f3c3-c6a641d27acf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Size of Data Frame: (50000, 3073)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#reshape dataset and determine number of variance\n",
        "x_test = x_test/255.0\n",
        "x_test = x_test.reshape(-1, 32, 32, 3)\n",
        "x_test_flat = x_test.reshape(-1, 3072)"
      ],
      "metadata": {
        "id": "ZAtU1jzj1HyQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pca = PCA(n_components=5)\n",
        "pca.fit(x_train_flat)\n",
        "PCA(copy = True, iterated_power = 'auto', n_components = 0.99, random_state = None, svd_solver = 'auto', tol = 0.0, whiten = False)\n",
        "pca.n_components_"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ciEOLDgL2z6o",
        "outputId": "193b80f6-bca7-4ea1-ae78-b6821ded62b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_img_pca = pca.transform(x_train_flat)\n",
        "test_img_pca = pca.transform(x_test_flat)\n",
        "\n",
        "#y_train = np_utils.to_categorical(y_train)\n",
        "#y_test = np_utils.to_categorical(y_test)"
      ],
      "metadata": {
        "id": "tc4_J3ci22cI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#variance of principal components\n",
        "print('Explained Variation per Principal Component: {}'.format(pca.explained_variance_ratio_))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UEOUf4lH6nND",
        "outputId": "5eb3672b-3a52-472b-d677-c61f644fc930"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Explained Variation per Principal Component: [0.2907663  0.11253144 0.06694414 0.03676459 0.03608843]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_img_pca[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JQJ3qA3N9Xci",
        "outputId": "3dab2120-c354-4738-86a2-a25243bbeb16"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-6.40101763,  2.72903876,  1.50171051, -2.95333278, -4.45258051])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "scaler = preprocessing.StandardScaler().fit(train_img_pca)"
      ],
      "metadata": {
        "id": "0Ah5OsSIUJzM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x_train_scaled = scaler.transform(train_img_pca)\n",
        "x_test_scaled  = scaler.transform(test_img_pca)"
      ],
      "metadata": {
        "id": "M364TKMGVtB9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We are done with the data preprocessing. Now, we can create the priors and model initializations"
      ],
      "metadata": {
        "id": "Dwp2C_WyWUsT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "prob_theta = np.asarray([0.1]*10) #Since the Gibbs Sampling method converges much harder than Variational Inference method, we set the probs as 1/10 for each cluster and will not update it "
      ],
      "metadata": {
        "id": "gwOnBtFVW8OM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "beta_std = 1\n",
        "beta_prior = np.random.normal(0, beta_std, (10,5)) #dimension is 10x5, a length-5 beta_k vector for each one of 10 clusters "
      ],
      "metadata": {
        "id": "I4MU3c6bXmyB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y_train_flat = np.ndarray.flatten(y_train)\n",
        "y_train_onehot = np.zeros((y_train_flat.size, y_train_flat.max() + 1))\n",
        "y_train_onehot[np.arange(y_train_flat.size), y_train_flat] = 1"
      ],
      "metadata": {
        "id": "P2UUNincZlcY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "z_train_prior = np.random.randint(10, size=50000, dtype=int)"
      ],
      "metadata": {
        "id": "0Oi9g3XffG_6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we can start the parameter update process"
      ],
      "metadata": {
        "id": "b-bmWdkoiOye"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "epochs = 50\n",
        "beta = beta_prior\n",
        "z_train = z_train_prior\n",
        "cluster_num = 10\n",
        "feature_num = pca.n_components_\n",
        "data_num = len(x_train)\n",
        "sig = 1\n",
        "lamb = 1"
      ],
      "metadata": {
        "id": "4DpIW6JVfr1W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def normalize_one(arr):\n",
        "  arr = np.asarray(arr)\n",
        "  total = np.sum(arr)\n",
        "  return arr/total"
      ],
      "metadata": {
        "id": "dencAP-0umSQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def calc_log_posterior(z_train, beta, x_train_scaled):\n",
        "  data_num = len(z_train)\n",
        "  cluster_num = beta.shape[0]\n",
        "  feature_num = beta.shape[1]\n",
        "  log_post = 0\n",
        "  for i in range(data_num):\n",
        "    log_post += -(np.sum((x_train_scaled[i]-beta[z_train[i]])**2))/(2*sig**2)\n",
        "  print(log_post)\n",
        "  return log_post"
      ],
      "metadata": {
        "id": "IqRhNnrGSBFO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def z_sampler(z_index, beta, x_train_scaled):\n",
        "  cluster_num = beta.shape[0]\n",
        "  feature_num = beta.shape[1] \n",
        "  x_sample = x_train_scaled[z_index]\n",
        "  x_cond_probs = np.asarray([None]*cluster_num)\n",
        "  for cluster in range(cluster_num):\n",
        "    cluster_prob = 0\n",
        "    for feature in range(feature_num):\n",
        "      cluster_prob += np.exp(np.sum((x_train_scaled[z_index]-beta[cluster])**2)/(-2*sig**2))\n",
        "    x_cond_probs[cluster] = cluster_prob\n",
        "  x_cond_probs = normalize_one(x_cond_probs)\n",
        "  z_sampled = np.random.choice(cluster_num, p=np.asarray(x_cond_probs, dtype='float64'))\n",
        "  return z_sampled, x_cond_probs"
      ],
      "metadata": {
        "id": "GHlRXx8fkxZZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def b_sampler(b_index, z_train, x_train_scaled): #b_index is equivalent to k from the lecture notes\n",
        "  data_num = len(z_train)\n",
        "  feature_num = len(x_train_scaled[0])\n",
        "  indeces = [i for i in range(data_num) if z_train[i] == b_index]\n",
        "  x_indexed = x_train_scaled[indeces]\n",
        "  x_indexed_mean = np.mean(x_indexed, axis=0)\n",
        "  nk = len(indeces) #number of x's assigned as y = k (according to z, not the true label y)\n",
        "  mu_k = (nk/(sig**2))/((nk/(sig**2))+(1/(lamb**2)))*x_indexed_mean\n",
        "  lamb_k_val = np.sqrt(1/((nk/(sig**2))+(1/(lamb**2))))\n",
        "  lamb_k = np.asarray([lamb_k_val]*feature_num)\n",
        "  return np.random.normal(loc=mu_k, scale=lamb_k) #returns updated b_k for a specific cluster k (b_index)"
      ],
      "metadata": {
        "id": "yFGzDmUICIiJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "beta_std_vals = [0.5, 2, 10]\n",
        "sig_values = [0.5, 2, 10]\n",
        "lamb_values = [0.5, 2, 10]\n",
        "\n",
        "epochs = 10\n",
        "cluster_num = 10\n",
        "feature_num = pca.n_components_\n",
        "data_num = len(x_train)\n",
        "z_train = z_train_prior"
      ],
      "metadata": {
        "id": "E6cL6pFXT87b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for beta_std in beta_std_vals:\n",
        "  for sig in sig_values:\n",
        "    for lamb in lamb_values:\n",
        "      beta = np.random.normal(0, beta_std, (10,5)) #dimension is 10x5, a length-5 beta_k vector for each one of 10 clusters\n",
        "      print(\"beta_std: \" + str(beta_std) + \", sig: \" + str(sig) +\", lamb: \" + str(lamb)) \n",
        "      for epoch in range(epochs):\n",
        "        for z_index in range(data_num):\n",
        "          z_train[z_index] = z_sampler(z_index, beta, x_train_scaled)[0] \n",
        "        for cluster in range(cluster_num):\n",
        "            beta[cluster] = b_sampler(cluster, z_train, x_train_scaled)\n",
        "        calc_log_posterior(z_train, beta, x_train_scaled)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HNDHZ2wiVnuu",
        "outputId": "b670c005-b802-43c2-bcf4-b1daba4b1ae8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "beta_std: 0.5, sig: 0.5, lamb: 0.5\n",
            "-317967.01123101794\n",
            "-287077.3779391262\n",
            "-275295.11315929354\n",
            "-268277.7999647387\n",
            "-262580.20270423556\n",
            "-257515.49447112196\n",
            "-252256.54177199097\n",
            "-247088.51145617687\n",
            "-243230.11276432098\n",
            "-241848.71836123956\n",
            "beta_std: 0.5, sig: 0.5, lamb: 2\n",
            "-328550.91749527975\n",
            "-287606.4152735736\n",
            "-275748.72207892395\n",
            "-268201.8199284189\n",
            "-260681.4555724063\n",
            "-255018.21102845433\n",
            "-251567.6072685146\n",
            "-249155.0678023474\n",
            "-247694.03046869137\n",
            "-246300.9490368463\n",
            "beta_std: 0.5, sig: 0.5, lamb: 10\n",
            "-315309.74946321105\n",
            "-270011.3156392561\n",
            "-258872.79027182126\n",
            "-256087.86579495214\n",
            "-254619.41806888086\n",
            "-253695.19605161902\n",
            "-252837.66258913555\n",
            "-251817.61377655942\n",
            "-251265.8052998182\n",
            "-250256.2026007393\n",
            "beta_std: 0.5, sig: 2, lamb: 0.5\n",
            "-30762.13531201074\n",
            "-31227.334411007578\n",
            "-31272.484817233777\n",
            "-31274.09321776634\n",
            "-31281.145781928568\n",
            "-31270.187618664422\n",
            "-31273.900170296427\n",
            "-31259.415950427912\n",
            "-31270.541771876502\n",
            "-31265.42077350731\n",
            "beta_std: 0.5, sig: 2, lamb: 2\n",
            "-31079.67412113971\n",
            "-31252.00361783467\n",
            "-31255.51668951924\n",
            "-31265.20334476822\n",
            "-31267.644130550587\n",
            "-31264.365178447566\n",
            "-31267.91442707692\n",
            "-31264.985435282484\n",
            "-31266.80630157419\n",
            "-31273.15685365578\n",
            "beta_std: 0.5, sig: 2, lamb: 10\n",
            "-30690.255274365463\n",
            "-31212.007881801605\n",
            "-31265.92126209549\n",
            "-31269.521930379356\n",
            "-31266.616920294276\n",
            "-31261.801319655897\n",
            "-31264.866932183726\n",
            "-31265.436176609066\n",
            "-31262.816953388865\n",
            "-31273.033469365553\n",
            "beta_std: 0.5, sig: 10, lamb: 0.5\n",
            "-1271.824210315216\n",
            "-1271.3983444388132\n",
            "-1271.3127728733275\n",
            "-1272.7206247782894\n",
            "-1271.6580620371153\n",
            "-1270.896310481914\n",
            "-1270.193868704294\n",
            "-1270.549070589148\n",
            "-1273.2541314626085\n",
            "-1278.8390216634489\n",
            "beta_std: 0.5, sig: 10, lamb: 2\n",
            "-1272.0656335143574\n",
            "-1271.902657641206\n",
            "-1274.3833077388324\n",
            "-1274.9196125102847\n",
            "-1271.4844867644374\n",
            "-1267.2270626503127\n",
            "-1277.592329412846\n",
            "-1270.7992887304783\n",
            "-1277.1794003974655\n",
            "-1280.8529730291434\n",
            "beta_std: 0.5, sig: 10, lamb: 10\n",
            "-1264.768295391476\n",
            "-1270.4874753076201\n",
            "-1276.4205537668615\n",
            "-1273.954618930219\n",
            "-1271.7742887424524\n",
            "-1280.206672714516\n",
            "-1276.0871948298752\n",
            "-1273.5742604796826\n",
            "-1283.8364371188081\n",
            "-1263.633173910528\n",
            "beta_std: 2, sig: 0.5, lamb: 0.5\n",
            "-366440.03062718385\n",
            "-306859.8920581809\n",
            "-281461.7068124981\n",
            "-271291.65868097445\n",
            "-265314.534195385\n",
            "-260062.48898744685\n",
            "-256263.14284538862\n",
            "-253435.3475468646\n",
            "-250687.12975310307\n",
            "-248847.41056900736\n",
            "beta_std: 2, sig: 0.5, lamb: 2\n",
            "-322502.0282051296\n",
            "-291084.43833352835\n",
            "-273758.8143092686\n",
            "-263458.79417794215\n",
            "-258561.8214680899\n",
            "-255542.61142126276\n",
            "-252365.78009603816\n",
            "-248917.28299235067\n",
            "-246356.588456134\n",
            "-245423.74311172796\n",
            "beta_std: 2, sig: 0.5, lamb: 10\n",
            "-369729.670635046\n",
            "-309116.23021856655\n",
            "-281759.1297814549\n",
            "-271403.29799303156\n",
            "-267164.72679646796\n",
            "-264438.61189086083\n",
            "-262273.6646239067\n",
            "-260877.85527605104\n",
            "-258841.70972875267\n",
            "-256608.4510807915\n",
            "beta_std: 2, sig: 2, lamb: 0.5\n",
            "-27419.953494639718\n",
            "-30885.482514629857\n",
            "-31236.66292846305\n",
            "-31267.316738315676\n",
            "-31264.704881339938\n",
            "-31267.116660442938\n",
            "-31267.801127834788\n",
            "-31260.65890359308\n",
            "-31268.843714021976\n",
            "-31266.55334252025\n",
            "beta_std: 2, sig: 2, lamb: 2\n",
            "-28047.81524025026\n",
            "-30899.96791634252\n",
            "-31236.871990653257\n",
            "-31265.355989351687\n",
            "-31261.307094795415\n",
            "-31263.245010569706\n",
            "-31271.57311424959\n",
            "-31272.621363805443\n",
            "-31264.84633644972\n",
            "-31270.03017215811\n",
            "beta_std: 2, sig: 2, lamb: 10\n",
            "-28086.17959216273\n",
            "-30971.951615098136\n",
            "-31238.9272244117\n",
            "-31266.90214229531\n",
            "-31267.035569278713\n",
            "-31259.769827134318\n",
            "-31267.447016645412\n",
            "-31282.131624406957\n",
            "-31270.39756932246\n",
            "-31269.131509672658\n",
            "beta_std: 2, sig: 10, lamb: 0.5\n",
            "-1269.5336808443258\n",
            "-1277.1990822596674\n",
            "-1290.2662069407372\n",
            "-1277.2719772229755\n",
            "-1268.158459399045\n",
            "-1267.1991112227552\n",
            "-1274.0481029773493\n",
            "-1271.0473858177359\n",
            "-1274.9155946765823\n",
            "-1270.6208879474866\n",
            "beta_std: 2, sig: 10, lamb: 2\n",
            "-1272.4914462953739\n",
            "-1273.5363608193838\n",
            "-1286.0397793649113\n",
            "-1274.6186555468346\n",
            "-1282.112701239512\n",
            "-1281.5199629607012\n",
            "-1274.3177171585621\n",
            "-1285.8392351892314\n",
            "-1276.4474415839431\n",
            "-1280.2809119139158\n",
            "beta_std: 2, sig: 10, lamb: 10\n",
            "-1277.4129961288118\n",
            "-1277.3115022369973\n",
            "-1273.5378048397954\n",
            "-1278.5605905194261\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "My Gibbs sampling algorithm did not really converge on Cifar-10 Dataset even though I could not find any error in the implementation. That is why, I decided to use Scikit Learn Library to implement LDA on a news headline data set:"
      ],
      "metadata": {
        "id": "jAJLvoH4LaU8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "from nltk.tokenize import RegexpTokenizer\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "from sklearn.decomposition import LatentDirichletAllocation\n",
        "\n",
        "# Load Dataset\n",
        "data = pd.read_csv('abcnews-date-text.csv', error_bad_lines=False);\n",
        "documents_list= data['headline_text'].tolist()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uqip_LwtLt4r",
        "outputId": "fd5e2647-70bd-4b38-c478-918a0dd239ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py:3326: FutureWarning: The error_bad_lines argument has been deprecated and will be removed in a future version.\n",
            "\n",
            "\n",
            "  exec(code_obj, self.user_global_ns, self.user_ns)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "documents_list_in = documents_list[:1000000]\n",
        "documents_list_out = documents_list[1000000:]"
      ],
      "metadata": {
        "id": "nwd1LEZodT6D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize regex tokenizer\n",
        "tokenizer = RegexpTokenizer(r'\\w+')\n",
        "\n",
        "# Vectorize document using TF-IDF\n",
        "tfidf = TfidfVectorizer(lowercase=True,\n",
        "                        stop_words='english',\n",
        "                        ngram_range = (1,1),\n",
        "                        tokenizer = tokenizer.tokenize)\n",
        "\n",
        "# Fit and Transform the documents\n",
        "train_data_in = tfidf.fit_transform(documents_list_in) \n",
        "train_data_out = tfidf.transform(documents_list_out) "
      ],
      "metadata": {
        "id": "Q471mg4eL1uV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the number of topics or components\n",
        "num_components=4\n",
        "\n",
        "# Create LDA object\n",
        "model2=LatentDirichletAllocation(n_components=num_components, max_iter = 2)\n",
        "model4=LatentDirichletAllocation(n_components=num_components, max_iter = 4)\n",
        "model6=LatentDirichletAllocation(n_components=num_components, max_iter = 6)\n",
        "model8=LatentDirichletAllocation(n_components=num_components, max_iter = 8)\n",
        "model10=LatentDirichletAllocation(n_components=num_components, max_iter = 10)"
      ],
      "metadata": {
        "id": "6WQN_gvxMTZC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit SVD model on data\n",
        "model2.fit(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HStB3zuZenH8",
        "outputId": "9a47d17a-caae-4454-98c3-9ed3fdf9f0f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LatentDirichletAllocation(max_iter=2, n_components=4)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lda_matrix2 = model2.transform(train_data_in)\n",
        "\n"
      ],
      "metadata": {
        "id": "4zLBLnceMVW3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get Components \n",
        "lda_components2=model2.components_\n",
        "# Print the topics with their terms\n",
        "terms = tfidf.get_feature_names()\n",
        "\n",
        "for index, component in enumerate(lda_components2):\n",
        "    zipped = zip(terms, component)\n",
        "    top_terms_key=sorted(zipped, key = lambda t: t[1], reverse=True)[:10]\n",
        "    top_terms_list=list(dict(top_terms_key).keys())\n",
        "    print(\"Topic \"+str(index)+\": \",top_terms_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f6SS8WJbWq-O",
        "outputId": "772f6dd2-abd3-4be4-d807-ad4e33906055"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function get_feature_names is deprecated; get_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead.\n",
            "  warnings.warn(msg, category=FutureWarning)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Topic 0:  ['interview', 'man', 'police', 'court', 'says', 'jailed', 'new', 'charged', 'drug', 'death']\n",
            "Topic 1:  ['crash', 'council', 'police', 'says', 'qld', 'new', 'man', 'court', 'govt', 'country']\n",
            "Topic 2:  ['police', 'man', 'court', 'new', 'business', 'market', 'govt', 'news', 'attack', 'fight']\n",
            "Topic 3:  ['new', 'police', 'plan', 'govt', 'abc', 'charged', 'farmers', 'weather', 'man', 'help']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model2.perplexity(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JPAMn7pdXJ4T",
        "outputId": "3167ea5d-1cd1-4241-b349-dad4d8ca34d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "19806.8986356928"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model2.perplexity(train_data_out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8gcnIzhEaxES",
        "outputId": "ee147d41-ce1c-4c3a-f3a2-ac250d5925a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42154.698557842385"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit SVD model on data\n",
        "model4.fit(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k_J0ttpkkgxw",
        "outputId": "3a5ca1a8-f90a-4656-d001-3e6e19b92634"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LatentDirichletAllocation(max_iter=4, n_components=4)"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lda_matrix4 = model4.transform(train_data_in)"
      ],
      "metadata": {
        "id": "evssI8s-kzst"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get Components \n",
        "lda_components4=model4.components_\n",
        "# Print the topics with their terms\n",
        "terms = tfidf.get_feature_names()\n",
        "\n",
        "for index, component in enumerate(lda_components4):\n",
        "    zipped = zip(terms, component)\n",
        "    top_terms_key=sorted(zipped, key = lambda t: t[1], reverse=True)[:10]\n",
        "    top_terms_list=list(dict(top_terms_key).keys())\n",
        "    print(\"Topic \"+str(index)+\": \",top_terms_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iEVTXUN0n4Lr",
        "outputId": "23302299-aa1b-4eba-82ed-847c5fba98df"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function get_feature_names is deprecated; get_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead.\n",
            "  warnings.warn(msg, category=FutureWarning)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Topic 0:  ['man', 'police', 'abc', 'crash', 'court', 'killed', 'car', 'govt', 'child', 'accused']\n",
            "Topic 1:  ['water', 'police', 'new', 'council', 'interview', 'farmers', 'plan', 'govt', 'search', 'wa']\n",
            "Topic 2:  ['new', 'rural', 'council', 'country', 'health', 'nsw', 'national', 'govt', 'qld', 'says']\n",
            "Topic 3:  ['man', 'police', 'charged', 'day', 'death', 'new', 'market', 'interview', 'woman', 'court']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model4.perplexity(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0a5fi7e9oa93",
        "outputId": "21b2fe19-1b46-4dc2-f4fd-0cda0dc171e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "18047.317748728412"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model4.perplexity(train_data_out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G_2mLY_gogJj",
        "outputId": "02ecb63c-3bfa-4b41-de2e-f7a897c73824"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "39061.15305092236"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit SVD model on data\n",
        "model6.fit(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xwvBijx7pkbc",
        "outputId": "6c8852fa-9c45-444c-8be4-1edf9086acc0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LatentDirichletAllocation(max_iter=6, n_components=4)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lda_matrix6 = model6.transform(train_data_in)"
      ],
      "metadata": {
        "id": "uTLc6NbIqENS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get Components \n",
        "lda_components6=model6.components_\n",
        "# Print the topics with their terms\n",
        "terms = tfidf.get_feature_names()\n",
        "\n",
        "for index, component in enumerate(lda_components6):\n",
        "    zipped = zip(terms, component)\n",
        "    top_terms_key=sorted(zipped, key = lambda t: t[1], reverse=True)[:10]\n",
        "    top_terms_list=list(dict(top_terms_key).keys())\n",
        "    print(\"Topic \"+str(index)+\": \",top_terms_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "57bscbcIuFzD",
        "outputId": "cac36e55-5fe3-4449-dc0d-87817e232902"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function get_feature_names is deprecated; get_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead.\n",
            "  warnings.warn(msg, category=FutureWarning)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Topic 0:  ['interview', 'day', 'australia', 'cup', 'win', 'new', 'world', 'says', 'final', 'drug']\n",
            "Topic 1:  ['man', 'police', 'crash', 'killed', 'court', 'charged', 'death', 'woman', 'missing', 'car']\n",
            "Topic 2:  ['govt', 'abc', 'water', 'new', 'rural', 'farmers', 'council', 'plan', 'police', 'urged']\n",
            "Topic 3:  ['new', 'council', 'police', 'plan', 'centre', 'blaze', 'fears', 'water', 'interview', 'home']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model6.perplexity(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P2a2A6L9uuI9",
        "outputId": "47ae7093-0ef0-43d4-d828-eb9a62004086"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "17246.841850688787"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model6.perplexity(train_data_out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lCL7nVNwu3gn",
        "outputId": "6b6ec0ea-3c64-4036-e85d-aee7c7053edb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "37662.68106757268"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit SVD model on data\n",
        "model8.fit(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_WknBD6SvjVn",
        "outputId": "c20c5bdc-30f7-44f6-888a-795b71f99af7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LatentDirichletAllocation(max_iter=8, n_components=4)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lda_matrix8 = model8.transform(train_data_in)"
      ],
      "metadata": {
        "id": "sGlLZZf0wx69"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get Components \n",
        "lda_components8=model8.components_\n",
        "# Print the topics with their terms\n",
        "terms = tfidf.get_feature_names()\n",
        "\n",
        "for index, component in enumerate(lda_components8):\n",
        "    zipped = zip(terms, component)\n",
        "    top_terms_key=sorted(zipped, key = lambda t: t[1], reverse=True)[:10]\n",
        "    top_terms_list=list(dict(top_terms_key).keys())\n",
        "    print(\"Topic \"+str(index)+\": \",top_terms_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E-lVAQ431yvr",
        "outputId": "aceed445-b03b-498c-e0b9-fb890156c0be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function get_feature_names is deprecated; get_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead.\n",
            "  warnings.warn(msg, category=FutureWarning)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Topic 0:  ['new', 'power', 'water', 'day', 'closer', 'council', 'final', 'win', 'rain', 'wins']\n",
            "Topic 1:  ['interview', 'north', 'south', 'new', 'police', 'west', 'australia', 'council', 'aid', 'cup']\n",
            "Topic 2:  ['man', 'police', 'crash', 'charged', 'car', 'killed', 'missing', 'court', 'murder', 'woman']\n",
            "Topic 3:  ['govt', 'abc', 'market', 'new', 'rural', 'plan', 'council', 'report', 'rise', 'business']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model8.perplexity(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L2lsP7f-2PsJ",
        "outputId": "d5bd0423-4d29-43b6-dcf8-d0e8d901ed00"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16682.95821428011"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model8.perplexity(train_data_out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7tetCEze2YPz",
        "outputId": "e45d948c-beff-4e4e-99c1-5f2c208512ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "36767.57359086032"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit SVD model on data\n",
        "model10.fit(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_6zDxfO_3VHV",
        "outputId": "44ccfe87-9fdc-4eb5-9b3c-e28cd99bb689"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LatentDirichletAllocation(n_components=4)"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lda_matrix10 = model10.transform(train_data_in)"
      ],
      "metadata": {
        "id": "5SPbUw_z6a0t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get Components \n",
        "lda_components10=model10.components_\n",
        "# Print the topics with their terms\n",
        "terms = tfidf.get_feature_names()\n",
        "\n",
        "for index, component in enumerate(lda_components10):\n",
        "    zipped = zip(terms, component)\n",
        "    top_terms_key=sorted(zipped, key = lambda t: t[1], reverse=True)[:10]\n",
        "    top_terms_list=list(dict(top_terms_key).keys())\n",
        "    print(\"Topic \"+str(index)+\": \",top_terms_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZzbO8jxS_f_F",
        "outputId": "91f57547-f9b7-42eb-b8ae-6e7586ba61a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function get_feature_names is deprecated; get_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead.\n",
            "  warnings.warn(msg, category=FutureWarning)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Topic 0:  ['police', 'man', 'crash', 'charged', 'car', 'killed', 'missing', 'death', 'woman', 'dies']\n",
            "Topic 1:  ['health', 'govt', 'new', 'rural', 'child', 'budget', 'says', 'council', 'news', 'funding']\n",
            "Topic 2:  ['water', 'council', 'new', 'govt', 'plan', 'abc', 'weather', 'says', 'pm', 'report']\n",
            "Topic 3:  ['interview', 'win', 'cup', 'world', 'court', 'test', 'final', 'guilty', 'murder', 'trial']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model10.perplexity(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nX-SsPq-_6eb",
        "outputId": "497213cf-91c5-4f50-b784-a5ab0132aaa7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16155.872705848691"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model10.perplexity(train_data_out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cn_ChIe6AFdC",
        "outputId": "a943e7f9-1833-4a5f-dcda-7f4bc5f95b63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "35816.71935787367"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model10_8=LatentDirichletAllocation(n_components=8, max_iter = 10)"
      ],
      "metadata": {
        "id": "erXC2OlGAp4G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit SVD model on data\n",
        "model10_8.fit(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W1-l9dqSBFeW",
        "outputId": "579b11ca-7e04-450b-f295-b5b6e1a477bf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LatentDirichletAllocation(n_components=8)"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lda_matrix10_8 = model10_8.transform(train_data_in)"
      ],
      "metadata": {
        "id": "2RcZ7AKBBKVA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get Components \n",
        "lda_components10_8=model10_8.components_\n",
        "# Print the topics with their terms\n",
        "terms = tfidf.get_feature_names()\n",
        "\n",
        "for index, component in enumerate(lda_components10_8):\n",
        "    zipped = zip(terms, component)\n",
        "    top_terms_key=sorted(zipped, key = lambda t: t[1], reverse=True)[:10]\n",
        "    top_terms_list=list(dict(top_terms_key).keys())\n",
        "    print(\"Topic \"+str(index)+\": \",top_terms_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2rwHKgx8FJxv",
        "outputId": "78412dba-e724-4e8c-bda7-394e13f50e48"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function get_feature_names is deprecated; get_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead.\n",
            "  warnings.warn(msg, category=FutureWarning)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Topic 0:  ['interview', 'win', 'cup', 'final', 'clash', 'tigers', 'open', 'england', 'play', 'title']\n",
            "Topic 1:  ['man', 'police', 'court', 'charged', 'murder', 'death', 'missing', 'accused', 'charges', 'woman']\n",
            "Topic 2:  ['iraq', 'killed', 'news', 'day', 'pakistan', 'kills', 'dead', 'troops', 'blast', 'abc']\n",
            "Topic 3:  ['council', 'govt', 'new', 'plan', 'abc', 'weather', 'union', 'labor', 'says', 'workers']\n",
            "Topic 4:  ['market', 'prices', 'live', 'rain', 'east', 'share', 'markets', 'price', 'australian', 'firefighters']\n",
            "Topic 5:  ['interview', 'world', 'asylum', 'new', 'cup', 'wins', 'australia', 'smith', 'seekers', 'league']\n",
            "Topic 6:  ['water', 'health', 'govt', 'new', 'plan', 'funding', 'boost', 'urged', 'council', 'qld']\n",
            "Topic 7:  ['crash', 'car', 'dies', 'man', 'fatal', 'accident', 'police', 'driver', 'plane', 'killed']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model10_8.perplexity(train_data_in)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CvrM1XOnGSHr",
        "outputId": "478b7930-114e-463a-edb5-ece773956e5d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "21103.808072908552"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model10_8.perplexity(train_data_out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dv4LovbaGhbu",
        "outputId": "183699ea-5107-4b56-daa1-08becc42b85e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "57882.67742064533"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "83-wqEl6HwZA"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "perp_in = np.asarray([19806, 18047, 17246, 16682, 16155])\n",
        "perp_out = np.asarray([42154, 39061, 37662, 36767, 35816])\n",
        "X = np.asarray([2,4,6,8,10])"
      ],
      "metadata": {
        "id": "FdekrMa90f2H"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting both the curves simultaneously\n",
        "plt.plot(X, perp_in, color='r', label='Perplexity (in-sample', marker ='.')\n",
        "plt.plot(X, perp_out, color='g', label='Perplexity (out-of-sample', marker ='.')\n",
        "  \n",
        "# Naming the x-axis, y-axis and the whole graph\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Perplexity\")\n",
        "plt.title(\"Perplexity over iterations\")\n",
        "  \n",
        "# Adding legend, which helps us recognize the curve according to it's color\n",
        "plt.legend()\n",
        "  \n",
        "# To load the display window\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "FnuFinRt6oY2",
        "outputId": "4f92ea1c-2380-48b7-c34a-24987da95923"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "0aQ8l3Ol7EAz"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}