Topic Modeling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "9a84916f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import torch\n",
    "import scipy.io\n",
    "from sklearn.datasets import fetch_20newsgroups\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "import numpy as np\n",
    "from scipy import sparse\n",
    "from typing import Tuple, List\n",
    "import re\n",
    "import string\n",
    "from gensim.models import Word2Vec, KeyedVectors\n",
    "import torch.nn.functional as F\n",
    "from torch import nn\n",
    "from torch import optim\n",
    "import math\n",
    "from typing import List\n",
    "from torch import optim\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "f52abdc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = fetch_20newsgroups(subset='train')\n",
    "test_data = fetch_20newsgroups(subset='test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "8bd98623",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Removing special characters\n",
    "train_docs = [re.findall(r'''[\\w']+|[.,!?;-~{}`´_<=>:/@*()&'$%#\"]''', train_data.data[doc]) for doc in range(len(train_data.data))]\n",
    "test_docs = [re.findall(r'''[\\w']+|[.,!?;-~{}`´_<=>:/@*()&'$%#\"]''', test_data.data[doc]) for doc in range(len(test_data.data))]\n",
    "\n",
    "def contains_punctuation(w):\n",
    "    return any(char in string.punctuation for char in w)\n",
    "\n",
    "def contains_numeric(w):\n",
    "    return any(char.isdigit() for char in w)\n",
    "\n",
    "total_docs = train_docs + test_docs\n",
    "\n",
    "#Converting words to lowercase and eliminating the words with numbers\n",
    "total_docs = [[word.lower() for word in total_docs[doc] if not contains_punctuation(word)] for doc in range(len(total_docs))]\n",
    "total_docs = [[word for word in total_docs[doc] if not contains_numeric(word)] for doc in range(len(total_docs))]\n",
    "\n",
    "#Removing words with single character\n",
    "total_docs = [[word for word in total_docs[doc] if len(word)>1] for doc in range(len(total_docs))]\n",
    "total_docs = [\" \".join(total_docs[doc]) for doc in range(len(total_docs))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "ab88357a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def token_counts_split(bow_data, size):\n",
    "    tokens = [[w for w in bow_data[doc, :].indices] for doc in range(size)]\n",
    "    counts = [[c for c in bow_data[doc, :].data] for doc in range(size)]\n",
    "    return tokens, counts\n",
    "\n",
    "def create_bow_representation(doc_indices, words, dataset_size, vocab_length):\n",
    "    return sparse.coo_matrix(([1] * len(doc_indices), (doc_indices, words)), \n",
    "        shape=(dataset_size, vocab_length)).tocsr()\n",
    "\n",
    "def document_indices(documents):\n",
    "    aux = [[j for i in range(len(doc))] for j, doc in enumerate(documents)]\n",
    "    return [int(x) for y in aux for x in y]\n",
    "\n",
    "def data_preprocessing(total_docs, min_df, max_df, train_factor=1.0):\n",
    "    \n",
    "    #Vectorized count reperestion of words in the documents\n",
    "    vectorizer = CountVectorizer(min_df=min_df, max_df=max_df)\n",
    "    v_docs = vectorizer.fit_transform(total_docs)\n",
    "    docs = [[word for word in document.split() if word not in vectorizer.stop_words_] for document in total_docs]\n",
    "    v_docs = v_docs.sign()\n",
    "\n",
    "    #Creating the vocaubalary for the dataset\n",
    "    sum_cts = v_docs.sum(axis=0)\n",
    "    vocab_length = sum_cts.shape[1]\n",
    "    sum_array = np.zeros(vocab_length, dtype=int)\n",
    "    for w in range(vocab_length):\n",
    "        sum_array[w] = sum_cts[0, w]\n",
    "    word2id = dict([(w, vectorizer.vocabulary_.get(w)) for w in vectorizer.vocabulary_])\n",
    "    id2word = dict([(vectorizer.vocabulary_.get(w), w) for w in vectorizer.vocabulary_])\n",
    "    index_sort = np.argsort(sum_array)\n",
    "    vocab = [id2word[index_sort[c]] for c in range(vocab_length)]\n",
    "    \n",
    "    #Calculating tarin and test size \n",
    "    train_size = int(np.floor(train_factor * v_docs.shape[0]))\n",
    "    test_size = int(v_docs.shape[0] - train_size)\n",
    "    #Computing permutation for random reordering of the documents\n",
    "    index_rand = np.random.permutation(v_docs.shape[0]).astype(int)\n",
    "\n",
    "    #Considering only the words present in training data\n",
    "    vocab = list(set([w for i in range(train_size) \n",
    "                      for w in docs[index_rand[i]] if w in word2id]))\n",
    "    word2id = dict([(w, i_d) for i_d, w in enumerate(vocab)])\n",
    "    id2word = dict([(i_d, w) for i_d, w in enumerate(vocab)])\n",
    "\n",
    "    #Spliting into train and test data\n",
    "    train_data = [[word2id[w] for w in docs[index_rand[i]] if w in word2id] for i in range(train_size)]\n",
    "    test_data = [[word2id[w] for w in docs[index_rand[i + train_size]] if w in word2id] for i in range(test_size)]\n",
    "    train_data = [doc for doc in train_data if doc != []]\n",
    "    test_data = [doc for doc in test_data if doc != []]\n",
    "    test_data = [doc for doc in test_data if len(doc) > 1]\n",
    "    test_data1 = [[w for i, w in enumerate(doc) if i <= len(doc) / 2.0 - 1] for doc in test_data]\n",
    "    test_data2 = [[w for i, w in enumerate(doc) if i > len(doc) / 2.0 - 1] for doc in test_data]\n",
    "\n",
    "    #Words present in tarin and test data\n",
    "    train_words = [w for doc in train_data for w in doc]\n",
    "    test_words1 = [w for doc in test_data1 for w in doc]\n",
    "    test_words2 = [w for doc in test_data2 for w in doc]\n",
    "\n",
    "    train_indices = document_indices(train_data)\n",
    "    test_indices1 = document_indices(test_data1)\n",
    "    test_indices2 = document_indices(test_data2)\n",
    "\n",
    "    #Creating a bag of word reperestation for train and test data\n",
    "    train_bow = create_bow_representation(train_indices, train_words, len(train_data), len(vocab))\n",
    "    test_bow1 = create_bow_representation(test_indices1, test_words1, len(test_data1), len(vocab))\n",
    "    test_bow2 = create_bow_representation(test_indices2, test_words2, len(test_data1), len(vocab))\n",
    "\n",
    "    #Spliting data into token and count reperestation of the data and storing it in a dictionary\n",
    "    train_tokens, train_counts = token_counts_split(train_bow, len(train_data))\n",
    "    test_tokens1, test_counts1 = token_counts_split(test_bow1, len(test_data1))\n",
    "    test_tokens2, test_counts2 = token_counts_split(test_bow2, len(test_data2))\n",
    "    train_dataset = {\n",
    "        'tokens': np.array([[np.array(d) for d in train_tokens]], dtype=object).squeeze(),\n",
    "        'counts': np.array([[np.array(d) for d in train_counts]], dtype=object).squeeze(),\n",
    "    }\n",
    "\n",
    "    test_dataset = {\n",
    "        'test1': {\n",
    "            'tokens': np.array([[np.array(d) for d in test_tokens1]], dtype=object).squeeze(),\n",
    "            'counts': np.array([[np.array(d) for d in test_counts1]], dtype=object).squeeze(),\n",
    "        },\n",
    "        'test2': {\n",
    "            'tokens':np.array([[np.array(d) for d in test_tokens1]], dtype=object).squeeze(),\n",
    "            'counts': np.array([[np.array(d) for d in test_counts1]], dtype=object).squeeze(),\n",
    "        }\n",
    "    }\n",
    "\n",
    "    return vocab, train_dataset, test_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "ae5bf247",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data Preprocessing, train and test data split, creating vocabulary\n",
    "vocab, train_data, test_data = data_preprocessing(total_docs, min_df=10, max_df=0.70, train_factor=0.85)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "f365df4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#creating the dense representation of bow for the given batch size\n",
    "def get_batch(doc_tokens, doc_counts, ind, vocab_size):\n",
    "    \n",
    "    docs_batch = np.zeros((len(ind), vocab_size))\n",
    "\n",
    "    for k, doc_id in enumerate(ind):\n",
    "        doc = doc_tokens[doc_id]\n",
    "        count = doc_counts[doc_id]\n",
    "        \n",
    "        if len(doc) == 1:\n",
    "            doc = [doc.squeeze()]\n",
    "            count = [count.squeeze()]\n",
    "        else:\n",
    "            doc = doc.squeeze()\n",
    "            count = count.squeeze()\n",
    "            \n",
    "        if doc_id != -1:\n",
    "            for l, word in enumerate(doc):\n",
    "                docs_batch[k, word] = count[l]\n",
    "                \n",
    "    docs_batch = torch.from_numpy(docs_batch).float()\n",
    "    return docs_batch\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "5dde3422",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model(nn.Module):\n",
    "    def __init__(self, vocab_length, hidden_layer_size, total_topics, rho_length, dout=0.5, embeddings=None, train_embeddings=True):\n",
    "        super(Model, self).__init__()\n",
    "\n",
    "        \n",
    "        self.vocab_length = vocab_length\n",
    "        self.hidden_layer_size = hidden_layer_size\n",
    "        self.total_topics = total_topics\n",
    "        self.rho_length = rho_length\n",
    "        self.dropout = nn.Dropout(dout)\n",
    "        self.train_embeddings = train_embeddings\n",
    "        \n",
    "        #Linear layer for computing the topic embeddings\n",
    "        self.alphas = nn.Linear(rho_length, total_topics, bias=False)\n",
    "        \n",
    "        #Assigning word embeddings or creating the linear layer in case of training the word embeddings\n",
    "        if self.train_embeddings:\n",
    "            self.rho = nn.Linear(rho_length, vocab_length, bias=False)\n",
    "        else:\n",
    "            self.rho = embeddings.clone().float()\n",
    "\n",
    "        #Creating the layers for encoder\n",
    "        self.q_theta = nn.Sequential(\n",
    "            nn.Linear(vocab_length, hidden_layer_size),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_layer_size, hidden_layer_size),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        #Layer for latent space represtation of the theta\n",
    "        self.mu_theta = nn.Linear(hidden_layer_size, total_topics, bias=True)\n",
    "        self.logsigma_theta = nn.Linear(hidden_layer_size, total_topics, bias=True)\n",
    "\n",
    "    #Calculation the beta that topic_word distribution by taking product of topic embeddings and word embeddings\n",
    "    def compute_beta(self):\n",
    "        if self.train_embeddings:\n",
    "            embeddings_product = self.alphas(self.rho.weight)\n",
    "        else:\n",
    "            embeddings_product = self.alphas(self.rho)\n",
    "        beta = F.softmax(embeddings_product, dim=0).transpose(1, 0)\n",
    "        return beta\n",
    "    \n",
    "    #Reparameterization and smapling from the distribuation\n",
    "    def reparameterization(self, mu, logvar):\n",
    "        if self.training:\n",
    "            sd = torch.exp(0.5 * logvar)\n",
    "            s = torch.randn_like(sd)\n",
    "            return s.mul_(sd).add_(mu)\n",
    "        else:\n",
    "            return mu\n",
    "    \n",
    "    #Encoder part of the variational Auto encoder, for calculating mu and log sigma of theta distribuation\n",
    "    def encoder(self, X_norm):\n",
    "        q_theta = self.q_theta(X_norm)\n",
    "        q_theta = self.dropout(q_theta)\n",
    "        mu = self.mu_theta(q_theta)\n",
    "        logsigma = self.logsigma_theta(q_theta)\n",
    "        kl_term =  -0.5 * torch.sum(1 + logsigma - mu.pow(2) - logsigma.exp(), dim=-1).mean()\n",
    "        sample = self.reparameterization(mu, logsigma)\n",
    "        theta = F.softmax(sample, dim=-1)\n",
    "        return theta, kl_term\n",
    "    \n",
    "    #Decoder for reconstruction of the input by taking product of topic and word distributions\n",
    "    def decoder(self, theta, beta):\n",
    "        X_reconstructed = torch.log(torch.mm(theta, beta) + 1e-6)\n",
    "        return X_reconstructed\n",
    "\n",
    "    def forward(self, X, X_norm, theta=None):\n",
    "        \n",
    "        if theta is None:\n",
    "            theta, kl_term = self.encoder(X_norm)\n",
    "        else:\n",
    "            kl_term = None\n",
    "        beta_matrix = self.compute_beta()\n",
    "        \n",
    "        X_reconstructed = self.decoder(theta, beta_matrix)\n",
    "        reconstruction_loss = -(X_reconstructed * X).sum(1).mean()\n",
    "        #Calculating the negative ELBO\n",
    "        loss_function = reconstruction_loss + kl_term\n",
    "        return loss_function, reconstruction_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "bbbe389e",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class ETM(object):\n",
    "\n",
    "    def __init__(self, vocab, total_topics = 10, iterations = 20, rho_length = 300, embeddings = None, train_embeddings = False, \n",
    "                 hidden_layer_size = 800, learning_rate = 0.005, batch_size = 1000, weight_decay = 1.2e-6, top_words = 10, log_interval = 2, dout = 0.0):\n",
    "        \n",
    "        self.vocab = vocab\n",
    "        self.total_topics = total_topics\n",
    "        self.iterations = iterations\n",
    "        self.rho_length = rho_length\n",
    "        self.train_embeddings = train_embeddings\n",
    "        self.hidden_layer_size = hidden_layer_size\n",
    "        self.learning_rate = learning_rate\n",
    "        self.batch_size = batch_size\n",
    "        self.weight_decay = weight_decay\n",
    "        self.top_words = top_words\n",
    "        self.log_interval = log_interval\n",
    "        self.vocab_length = len(self.vocab)\n",
    "        self.dropout = dout\n",
    "        self.negative_ELBO = []\n",
    "        self.Recons_loss = []\n",
    "        if self.train_embeddings:\n",
    "            self.embeddings = None  \n",
    "        else:\n",
    "            self.embeddings = self.process_pretrained_embeddings(embeddings)\n",
    "        \n",
    "        \n",
    "        np.random.seed(0)\n",
    "        torch.manual_seed(0)\n",
    "        if torch.cuda.is_available():\n",
    "            torch.cuda.manual_seed(0)\n",
    "        \n",
    "        self.model = Model(\n",
    "            self.vocab_length,\n",
    "            self.hidden_layer_size,\n",
    "            self.total_topics,\n",
    "            self.rho_length,\n",
    "            self.dropout,\n",
    "            self.embeddings,\n",
    "            self.train_embeddings)\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate, weight_decay=self.weight_decay)\n",
    "\n",
    "\n",
    "    def train_model(self, itr, train_data_tokens, train_data_counts):\n",
    "        self.model.train()\n",
    "        count = 0\n",
    "        total_rec_loss = 0\n",
    "        total_loss = 0\n",
    "        \n",
    "        #Spliting the data into batches\n",
    "        doc_indices = torch.randperm(len(train_data_tokens))\n",
    "        doc_indices = torch.split(doc_indices, self.batch_size)\n",
    "        \n",
    "        for doc_id in doc_indices:\n",
    "            self.optimizer.zero_grad()\n",
    "            self.model.zero_grad()\n",
    "            batch = get_batch(train_data_tokens, train_data_counts, doc_id, self.vocab_length)\n",
    "            #Normalizing the bow representation\n",
    "            batch_data_norm = batch / batch.sum(1).unsqueeze(1)\n",
    "            loss_function, reconstruction_loss = self.model(batch, batch_data_norm)\n",
    "            loss_function.backward()\n",
    "            self.optimizer.step()\n",
    "            total_rec_loss += torch.sum(reconstruction_loss).item()\n",
    "            total_loss += torch.sum(loss_function).item()\n",
    "            count += 1\n",
    "        #Calculating cummulative reconstruction loss and negative ELBO \n",
    "        total_rec_loss = round(total_rec_loss / count, 3)\n",
    "        total_loss = round(total_loss / count, 3)\n",
    "        self.negative_ELBO.append(total_loss)\n",
    "        self.Recons_loss.append(total_rec_loss)\n",
    "        if itr % 10 == 0:\n",
    "             print('Iteration {} - Rec loss: {} - NELBO: {}'.format(itr, total_rec_loss, total_loss))\n",
    "\n",
    "        \n",
    "    def fit(self, train_data, test_data=None):\n",
    "       \n",
    "        train_data_tokens = train_data['tokens']\n",
    "        train_data_counts = train_data['counts']\n",
    "        \n",
    "        #Displaying topic before training\n",
    "        with torch.no_grad():\n",
    "            topics = []\n",
    "            beta_matrix = self.model.compute_beta()\n",
    "            for t in range(self.total_topics):\n",
    "                words_token = list(beta_matrix[t].numpy().argsort()[-10:][::-1])\n",
    "                words = [self.vocab[i] for i in words_token]\n",
    "                topics.append(words)\n",
    "            print(f'Topics before training: {topics}')\n",
    "        \n",
    "        #Training the model\n",
    "        for itr in range(1, self.iterations):\n",
    "            self.train_model(itr, train_data_tokens, train_data_counts)\n",
    "         \n",
    "        #Displaying topic after training\n",
    "        with torch.no_grad():\n",
    "            topics = []\n",
    "            beta_matrix = self.model.compute_beta()\n",
    "            for t in range(self.total_topics):\n",
    "                words_token = list(beta_matrix[t].numpy().argsort()[-10:][::-1])\n",
    "                words = [self.vocab[i] for i in words_token]\n",
    "                topics.append(words)\n",
    "            print(f'Topics after training: {topics}')\n",
    "\n",
    "        return self\n",
    "    \n",
    "    \n",
    "    def process_pretrained_embeddings(self, embeddings):\n",
    "        embeddings_array = np.zeros((self.vocab_length, self.rho_length))\n",
    "        \n",
    "        #Intializing the embeddings and assigning the random vector incase abscence of given word\n",
    "        for k, word in enumerate(self.vocab):\n",
    "            try:\n",
    "                embeddings_array[k] = embeddings[word]\n",
    "            except KeyError:\n",
    "                embeddings_array[k] = np.random.normal(scale=0.6, size=(self.emb_size, ))\n",
    "        return torch.from_numpy(embeddings_array)\n",
    "    \n",
    "    def calculate_perplexity(self, test_data):\n",
    "        test_tokens1 = test_data['test1']['tokens']\n",
    "        test_tokens2 = test_data['test2']['tokens']\n",
    "\n",
    "        test_counts1 = test_data['test1']['counts']\n",
    "        test_counts2 = test_data['test2']['counts']\n",
    "        self.model.eval()\n",
    "        with torch.no_grad():\n",
    "            count = 0\n",
    "            total_loss = 0\n",
    "            beta = self.model.compute_beta()\n",
    "            doc_indices = torch.split(torch.tensor(range(len(test_tokens1))), self.batch_size)\n",
    "            for doc_id in doc_indices:\n",
    "                #Calculating the distribuation on first half of the test data: Considered as observed data\n",
    "                batch1 = get_batch(test_tokens1, test_counts1, doc_id, self.vocab_length)\n",
    "                batch_data_norm1 = batch1 / batch1.sum(1).unsqueeze(1)\n",
    "                theta, _ = self.model.encoder(batch_data_norm1)\n",
    "                \n",
    "                #Calculating the liklihood of document completion for the second half of the test data\n",
    "                batch2 = get_batch(test_tokens2, test_counts2, doc_id, self.vocab_length)\n",
    "                batch2_reconstructed = self.model.decoder(theta, beta)\n",
    "                reconstruction_loss = -(batch2_reconstructed * batch2).sum(1)\n",
    "                loss = (reconstruction_loss / batch2.sum(1)).mean().item()\n",
    "                total_loss += loss\n",
    "                count += 1\n",
    "            perplexity = round(math.exp(total_loss/count), 2)\n",
    "            return perplexity\n",
    "    \n",
    "    def calculate_topic_diversity(self):\n",
    "        self.model.eval()\n",
    "        top_words = 20\n",
    "        with torch.no_grad():\n",
    "            beta = self.model.compute_beta().numpy()\n",
    "            matrix = np.zeros((self.total_topics, top_words))\n",
    "            for t in range(self.total_topics):\n",
    "                sorted_vector = beta[t, :].argsort()\n",
    "                index = sorted_vector[-top_words: ][: : -1]\n",
    "                matrix[t, :] = index\n",
    "            unique_count = len(np.unique(matrix))\n",
    "            #Calculating the percentage of unique words over all the topics\n",
    "            topic_diversity = unique_count / (top_words * self.total_topics)\n",
    "            return topic_diversity\n",
    "\n",
    "\n",
    "    #Function calculates the topic word distribution after training, if required\n",
    "    def calculate_word_distribution(self):\n",
    "        self.model.eval()\n",
    "        with torch.no_grad():\n",
    "            return self.model.compute_beta()\n",
    "\n",
    "\n",
    "    #Function calculates the document topic distribution after training, if required\n",
    "    def calculate_topic_distribution(self, train_data):\n",
    "    \n",
    "        self.model.eval()\n",
    "        \n",
    "        train_tokens = train_data['tokens']\n",
    "        train_counts = train_data['counts']\n",
    "        distribution = []\n",
    "        with torch.no_grad():\n",
    "            count = 0\n",
    "            total_loss = 0\n",
    "            doc_indices = torch.split(torch.tensor(range(len(train_tokens))), self.batch_size)\n",
    "            for doc_id in doc_indices:\n",
    "                batch = get_batch(train_tokens, train_counts, doc_id, self.vocab_length)\n",
    "                batch_data_norm = batch / batch.sum(1).unsqueeze(1)\n",
    "                theta, _ = self.model.encoder(batch_data_norm)\n",
    "                distribution.append(theta)\n",
    "            distribution = torch.cat(tuple(distribution), 0)\n",
    "            return distribution\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "a7387f9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pretrained_word_embeddings(data, rho_d=300, min_ct=1, sg=1, workers=25, neg_samples=10, w_size=4, epochs=50):\n",
    "    \n",
    "    sentences = [doc.split() for doc in data]\n",
    "    #Pre-training the word embeddings\n",
    "    model = Word2Vec(\n",
    "        sentences,\n",
    "        min_count=min_ct,\n",
    "        sg=sg,\n",
    "        vector_size=rho_d,\n",
    "        epochs=epochs,\n",
    "        workers=workers,\n",
    "        negative=neg_samples,\n",
    "        window=w_size)\n",
    "    embeddings = model.wv\n",
    "\n",
    "    return embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "3e2a9fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "embeddings = pretrained_word_embeddings(total_docs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "5a4e852f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Topics before training: [['af', 'det', 'beaverton', 'uc', 'tor', 'pict', 'hardest', 'robot', 'jp', 'strawberry'], ['bu', 'avoiding', 'comets', 'mathematics', 'harper', 'incomplete', 'winmarks', 'dammit', 'unbiased', 'ml'], ['iq', 'sj', 'wang', 'acsu', 'rebound', 'masks', 'dakota', 'maryland', 'bargaining', 'eecs'], ['rat', 'pillion', 'diana', 'usd', 'bg', 'philosopher', 'advise', 'louisiana', 'quantum', 'confined'], ['ref', 'diving', 'cellar', 'bullets', 'arsenal', 'noel', 'nervous', 'disasters', 'reputation', 'grip'], ['hulk', 'samuelsson', 'destroying', 'thereby', 'majors', 'corpses', 'ballot', 'thereafter', 'arrest', 'preparing'], ['expecting', 'zoology', 'oulu', 'asuacad', 'springfield', 'callison', 'golden', 'synthetic', 'hits', 'monthly'], ['dg', 'doh', 'pit', 'ace', 'batman', 'quest', 'uic', 'kelvin', 'inland', 'wolverine']]\n",
      "Iteration 10 - Rec loss: 1602.448 - NELBO: 1609.894\n",
      "Iteration 20 - Rec loss: 1572.559 - NELBO: 1581.838\n",
      "Iteration 30 - Rec loss: 1642.889 - NELBO: 1652.317\n",
      "Iteration 40 - Rec loss: 1562.462 - NELBO: 1572.052\n",
      "Topics after training: [['max', 'pl', 'ah', 'bh', 'bhj', 'wm', 'tu', 'si', 'ax', 'cx'], ['com', 'uk', 'distribution', 'nasa', 'usa', 'org', 'access', 'gov', 'world', 'netcom'], ['edu', 're', 'article', 'writes', 'university', 'host', 'posting', 'nntp', 'cs', 'ca'], ['israel', 'were', 'government', 'law', 'are', 'by', 'was', 'he', 'war', 'jews'], ['or', 'on', 'windows', 'can', 'file', 'with', 'this', 'an', 'software', 'graphics'], ['that', 'it', 'you', 'be', 'this', 'not', 'on', 'are', 'have', 'as'], ['game', 'win', 'team', 'games', 'play', 'year', 'player', 'season', 'hockey', 'last'], ['car', 'space', 'low', 'bike', 'probe', 'dc', 'engine', 'high', 'miles', 'or']]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.ETM at 0x281d98550>"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Training and evaluating the model for min_df = 10 for 50 iterations\n",
    "ETM_Model1 = ETM(vocab, total_topics=8, iterations=50, embeddings=embeddings, train_embeddings=False)\n",
    "ETM_Model1.fit(train_data) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "296088d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(close=None, block=None)>"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "iterations = []\n",
    "for itr in range(1, 50):\n",
    "    iterations.append(itr)\n",
    "plt.plot(iterations, ETM_Model1.negative_ELBO)\n",
    "plt.title('Plot of Negative ELBO per Iterations during training') \n",
    "plt.ylabel('Negative ELBO')\n",
    "plt.xlabel('Iterations')\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "36e940f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(close=None, block=None)>"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "iterations = []\n",
    "for itr in range(1, 50):\n",
    "    iterations.append(itr)\n",
    "plt.plot(iterations, ETM_Model1.Recons_loss)\n",
    "plt.title('Plot of Reconstruction loss over Iterations during training') \n",
    "plt.ylabel('Reconstruction loss')\n",
    "plt.xlabel('Iterations')\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "37d2c14d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For minimum document frequency: 100\n",
      "\n",
      "Topics before training: [['uc', 'terrorists', 'log', 'cal', 'irvine', 'msu', 'cmu', 'lawrence', 'leads', 'purdue'], ['bu', 'mathematics', 'cleveland', 'panix', 'std', 'coast', 'object', 'displays', 'percentage', 'falls'], ['maryland', 'rpi', 'stanford', 'fm', 'du', 'portal', 'iv', 'amateur', 'delaware', 'greg'], ['quantum', 'ucsd', 'genesis', 'carter', 'ex', 'dare', 'nz', 'baby', 'gods', 'showed'], ['soldiers', 'arms', 'balls', 'plane', 'blue', 'cis', 'loop', 'diet', 'funds', 'entitled'], ['providing', 'spring', 'signs', 'granted', 'hits', 'holds', 'shuttle', 'judge', 'interests', 'civil'], ['golden', 'hits', 'split', 'tuesday', 'bryan', 'lake', 'healthy', 'optilink', 'dale', 'psuvm'], ['hq', 'expo', 'industrial', 'uunet', 'gmt', 'chemistry', 'howard', 'pitt', 'useragent', 'oz']]\n",
      "Iteration 10 - Rec loss: 1204.236 - NELBO: 1209.179\n",
      "Iteration 20 - Rec loss: 1149.01 - NELBO: 1155.203\n",
      "Iteration 30 - Rec loss: 1139.199 - NELBO: 1145.648\n",
      "Iteration 40 - Rec loss: 1128.228 - NELBO: 1134.763\n",
      "Topics after training: [['with', 'it', 'this', 'you', 'or', 'have', 'can', 'be', 'windows', 'if'], ['on', 'or', 'are', 'new', 'by', 'space', 'information', 'may', 'an', 'gov'], ['edu', 'university', 'posting', 're', 'host', 'article', 'nntp', 'writes', 'cs', 'ca'], ['by', 'were', 'their', 'government', 'was', 'been', 'they', 'had', 'are', 'he'], ['it', 'that', 'you', 'on', 'have', 'this', 'with', 'they', 'be', 'my'], ['that', 'not', 'you', 'it', 'are', 'as', 'this', 'be', 'have', 'we'], ['was', 'he', 'at', 'on', 'but', 'his', 'game', 'ca', 'be', 'year'], ['com', 're', 'article', 'writes', 'host', 'org', 'nntp', 'posting', 'netcom', 'distribution']]\n",
      "\n",
      "\n",
      "For minimum document frequency: 50\n",
      "\n",
      "Topics before training: [['af', 'det', 'beaverton', 'uc', 'tor', 'jp', 'assistant', 'bos', 'prof', 'dir'], ['bu', 'mathematics', 'dammit', 'wasted', 'cleveland', 'flawed', 'thompson', 'panix', 'jaeger', 'conner'], ['sj', 'wang', 'acsu', 'dakota', 'maryland', 'eecs', 'rpi', 'ccwf', 'clarkson', 'dk'], ['rat', 'louisiana', 'quantum', 'reveal', 'hangs', 'gen', 'ucsd', 'calpoly', 'insane', 'genesis'], ['ref', 'cellar', 'bullets', 'reputation', 'mountains', 'odin', 'properties', 'county', 'stores', 'britain'], ['destroying', 'thereby', 'majors', 'arrest', 'presents', 'periods', 'spots', 'injuries', 'mere', 'utter'], ['expecting', 'zoology', 'oulu', 'golden', 'hits', 'monthly', 'las', 'das', 'split', 'geoff'], ['dg', 'pit', 'ace', 'batman', 'quest', 'uic', 'kelvin', 'hq', 'expo', 'bearing']]\n",
      "Iteration 10 - Rec loss: 1327.483 - NELBO: 1333.112\n",
      "Iteration 20 - Rec loss: 1311.638 - NELBO: 1318.986\n",
      "Iteration 30 - Rec loss: 1324.505 - NELBO: 1332.121\n",
      "Iteration 40 - Rec loss: 1302.074 - NELBO: 1309.825\n",
      "Topics after training: [['or', 'with', 'this', 'windows', 'on', 'can', 'file', 'it', 'have', 'an'], ['by', 'space', 'are', 'or', 'nasa', 'on', 'be', 'gov', 'new', 'key'], ['edu', 'article', 'university', 'posting', 'writes', 'host', 're', 'nntp', 'cs', 'distribution'], ['by', 'were', 'was', 'he', 'his', 'their', 'they', 'are', 'who', 'had'], ['com', 're', 'max', 'uk', 'de', 'netcom', 'ac', 'jim', 'wrote', 'writes'], ['that', 'it', 'you', 'not', 'this', 'have', 'be', 'are', 'as', 'on'], ['he', 'was', 'ca', 'game', 'his', 'year', 'at', 'team', 'games', 'last'], ['com', 'my', 'on', 'with', 'car', 're', 'or', 'writes', 'at', 'off']]\n",
      "\n",
      "\n",
      "For minimum document frequency: 20\n",
      "\n",
      "Topics before training: [['af', 'det', 'beaverton', 'uc', 'tor', 'hardest', 'robot', 'jp', 'strawberry', 'assistant'], ['bu', 'avoiding', 'comets', 'mathematics', 'harper', 'incomplete', 'winmarks', 'dammit', 'unbiased', 'ml'], ['iq', 'sj', 'wang', 'acsu', 'rebound', 'masks', 'dakota', 'maryland', 'eecs', 'stsci'], ['rat', 'pillion', 'usd', 'bg', 'philosopher', 'advise', 'louisiana', 'quantum', 'confined', 'cga'], ['ref', 'cellar', 'bullets', 'arsenal', 'noel', 'nervous', 'reputation', 'grip', 'sod', 'mountains'], ['hulk', 'destroying', 'thereby', 'majors', 'corpses', 'arrest', 'preparing', 'presents', 'likelihood', 'additions'], ['expecting', 'zoology', 'oulu', 'asuacad', 'springfield', 'callison', 'golden', 'hits', 'monthly', 'las'], ['dg', 'doh', 'pit', 'ace', 'batman', 'quest', 'uic', 'kelvin', 'hq', 'expo']]\n",
      "Iteration 10 - Rec loss: 1536.065 - NELBO: 1542.621\n",
      "Iteration 20 - Rec loss: 1493.327 - NELBO: 1501.402\n",
      "Iteration 30 - Rec loss: 1486.519 - NELBO: 1495.342\n",
      "Iteration 40 - Rec loss: 1459.286 - NELBO: 1467.901\n",
      "Topics after training: [['max', 'windows', 'or', 'file', 'graphics', 'mac', 'edu', 'com', 'version', 'software'], ['edu', 'com', 're', 'article', 'writes', 'posting', 'host', 'university', 'nntp', 'cs'], ['ca', 'game', 'team', 'games', 'edu', 'year', 'he', 'his', 'player', 'win'], ['were', 'by', 'was', 'their', 'they', 'had', 'government', 'he', 'israel', 'are'], ['god', 'he', 'not', 'that', 'we', 'his', 'are', 'jesus', 'you', 'who'], ['that', 'it', 'you', 'this', 'be', 'have', 'on', 'not', 'are', 'with'], ['com', 'space', 'car', 'nasa', 'on', 're', 'engine', 'low', 'bike', 'writes'], ['encryption', 'key', 'information', 'public', 'health', 'clipper', 'access', 'security', 'drug', 'use']]\n",
      "\n",
      "\n",
      "For minimum document frequency: 10\n",
      "\n",
      "Topics before training: [['af', 'det', 'beaverton', 'uc', 'tor', 'pict', 'hardest', 'robot', 'jp', 'strawberry'], ['bu', 'avoiding', 'comets', 'mathematics', 'harper', 'incomplete', 'winmarks', 'dammit', 'unbiased', 'ml'], ['iq', 'sj', 'wang', 'acsu', 'rebound', 'masks', 'dakota', 'maryland', 'bargaining', 'eecs'], ['rat', 'pillion', 'diana', 'usd', 'bg', 'philosopher', 'advise', 'louisiana', 'quantum', 'confined'], ['ref', 'diving', 'cellar', 'bullets', 'arsenal', 'noel', 'nervous', 'disasters', 'reputation', 'grip'], ['hulk', 'samuelsson', 'destroying', 'thereby', 'majors', 'corpses', 'ballot', 'thereafter', 'arrest', 'preparing'], ['expecting', 'zoology', 'oulu', 'asuacad', 'springfield', 'callison', 'golden', 'synthetic', 'hits', 'monthly'], ['dg', 'doh', 'pit', 'ace', 'batman', 'quest', 'uic', 'kelvin', 'inland', 'wolverine']]\n",
      "Iteration 10 - Rec loss: 1605.683 - NELBO: 1612.209\n",
      "Iteration 20 - Rec loss: 1577.438 - NELBO: 1586.529\n",
      "Iteration 30 - Rec loss: 1551.211 - NELBO: 1560.547\n",
      "Iteration 40 - Rec loss: 1564.851 - NELBO: 1574.136\n",
      "Topics after training: [['drive', 'file', 'windows', 'or', 'disk', 'software', 'can', 'graphics', 'card', 'data'], ['edu', 'university', 'nntp', 'posting', 'host', 'ca', 're', 'cs', 'article', 'reply'], ['max', 'game', 'games', 'team', 'win', 'player', 'ny', 'nl', 'detroit', 'wins'], ['were', 'he', 'was', 'god', 'us', 'israel', 'by', 'are', 'who', 'his'], ['space', 'encryption', 'nasa', 'information', 'clipper', 'health', 'key', 'by', 'data', 'research'], ['that', 'it', 'you', 'this', 'be', 'on', 'have', 'not', 'are', 'with'], ['car', 'my', 'new', 'each', 'bike', 'on', 'off', 'vs', 'with', 'power'], ['com', 're', 'article', 'writes', 'posting', 'host', 'org', 'nntp', 'netcom', 'uucp']]\n",
      "\n",
      "\n",
      "For minimum document frequency: 5\n",
      "\n",
      "Topics before training: [['af', 'det', 'beaverton', 'uc', 'tor', 'pict', 'hardest', 'robot', 'jp', 'strawberry'], ['bu', 'avoiding', 'comets', 'mathematics', 'harper', 'incomplete', 'winmarks', 'dammit', 'unbiased', 'ml'], ['iq', 'dee', 'sj', 'wang', 'acsu', 'rebound', 'masks', 'dakota', 'maryland', 'bargaining'], ['rat', 'pillion', 'diana', 'usd', 'bg', 'philosopher', 'advise', 'louisiana', 'quantum', 'confined'], ['ref', 'diving', 'cellar', 'bullets', 'arsenal', 'noel', 'nervous', 'disasters', 'reputation', 'grip'], ['hulk', 'samuelsson', 'destroying', 'thereby', 'majors', 'corpses', 'ballot', 'thereafter', 'arrest', 'preparing'], ['expecting', 'zoology', 'oulu', 'asuacad', 'springfield', 'callison', 'golden', 'synthetic', 'hits', 'monthly'], ['dg', 'doh', 'pit', 'ace', 'batman', 'quest', 'uic', 'kelvin', 'inland', 'wolverine']]\n",
      "Iteration 10 - Rec loss: 1677.287 - NELBO: 1686.085\n",
      "Iteration 20 - Rec loss: 1649.606 - NELBO: 1659.445\n",
      "Iteration 30 - Rec loss: 1638.539 - NELBO: 1648.623\n",
      "Iteration 40 - Rec loss: 1659.348 - NELBO: 1669.045\n",
      "Topics after training: [['max', 'la', 'pt', 'pts', 'au', 'ma', 'nl', 'cx', 'pl', 'ah'], ['space', 'energy', 'nasa', 'satellite', 'medical', 'earth', 'research', 'low', 'surface', 'health'], ['sandvik', 'prism', 'navy', 'boulder', 'columbia', 'de', 'udel', 'caltech', 'mitre', 'arbor'], ['israel', 'law', 'government', 'god', 'christians', 'jewish', 'jews', 'jesus', 'christian', 'war'], ['image', 'data', 'graphics', 'software', 'windows', 'or', 'file', 'can', 'version', 'system'], ['that', 'it', 'you', 'be', 'this', 'on', 'have', 'not', 'are', 'with'], ['game', 'games', 'year', 'car', 'baseball', 'win', 'team', 'bike', 'play', 'last'], ['edu', 'com', 're', 'article', 'writes', 'posting', 'host', 'university', 'nntp', 'ca']]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "For minimum document frequency: 2\n",
      "\n",
      "Topics before training: [['af', 'det', 'beaverton', 'uc', 'tor', 'pict', 'hardest', 'robot', 'jp', 'strawberry'], ['bu', 'avoiding', 'comets', 'mathematics', 'harper', 'incomplete', 'winmarks', 'dammit', 'unbiased', 'ml'], ['iq', 'dee', 'sj', 'wang', 'acsu', 'rebound', 'masks', 'dakota', 'maryland', 'bargaining'], ['rat', 'pillion', 'diana', 'usd', 'bg', 'philosopher', 'advise', 'louisiana', 'quantum', 'confined'], ['ref', 'diving', 'cellar', 'bullets', 'arsenal', 'noel', 'nervous', 'disasters', 'reputation', 'grip'], ['hulk', 'samuelsson', 'destroying', 'thereby', 'majors', 'corpses', 'ballot', 'thereafter', 'arrest', 'preparing'], ['expecting', 'zoology', 'oulu', 'asuacad', 'springfield', 'callison', 'golden', 'synthetic', 'hits', 'monthly'], ['dg', 'doh', 'pit', 'ace', 'batman', 'quest', 'uic', 'kelvin', 'inland', 'wolverine']]\n",
      "Iteration 10 - Rec loss: 1799.874 - NELBO: 1808.461\n",
      "Iteration 20 - Rec loss: 1774.016 - NELBO: 1783.777\n",
      "Iteration 30 - Rec loss: 1762.083 - NELBO: 1772.127\n",
      "Iteration 40 - Rec loss: 1823.409 - NELBO: 1833.662\n",
      "Topics after training: [['max', 'windows', 'file', 'mac', 'dos', 'pc', 'scsi', 'mb', 'controller', 'hd'], ['rz', 'tu', 'arbor', 'hamburg', 'kaldis', 'newton', 'isc', 'colostate', 'jp', 'manes'], ['software', 'computer', 'data', 'information', 'mail', 'key', 'message', 'access', 'graphics', 'systems'], ['space', 'car', 'low', 'bike', 'probe', 'speed', 'bikes', 'oil', 'high', 'fat'], ['israel', 'government', 'god', 'law', 'christians', 'states', 'muslim', 'turkish', 'jewish', 'war'], ['that', 'it', 'you', 'this', 'on', 'be', 'have', 'not', 'are', 'with'], ['game', 'win', 'toronto', 'games', 'vs', 'team', 'play', 'division', 'baseball', 'player'], ['edu', 'com', 're', 'article', 'writes', 'posting', 'university', 'host', 'nntp', 'cs']]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Training and evaluating the model for different vocabulary size for 50 iterations\n",
    "iterations = 50\n",
    "min_df = [100, 50, 20, 10, 5, 2]\n",
    "perplexities = []\n",
    "topic_diversities = []\n",
    "vocab_sizes = []\n",
    "for i in range(len(min_df)):\n",
    "    print(f'For minimum document frequency: {min_df[i]}\\n')\n",
    "    vocab, train_data, test_data = data_preprocessing(total_docs, min_df=min_df[i], max_df=0.70, train_factor=0.85)\n",
    "    ETM_Model2 = ETM(vocab, total_topics=8, iterations=iterations, embeddings=embeddings, train_embeddings=False)\n",
    "    ETM_Model2.fit(train_data)\n",
    "    pp = ETM_Model2.calculate_perplexity(test_data)\n",
    "    td = ETM_Model2.calculate_topic_diversity()\n",
    "    perplexities.append(pp)\n",
    "    topic_diversities.append(td)\n",
    "    vocab_sizes.append(len(vocab))\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "90ddb114",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(close=None, block=None)>"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(vocab_sizes, perplexities)\n",
    "plt.title('Plot of Perplexity of the model as function of vocabulary size') \n",
    "plt.ylabel('Perplexity')\n",
    "plt.xlabel('Vocabulary Size')\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "338d1019",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(close=None, block=None)>"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(vocab_sizes, topic_diversities)\n",
    "plt.title('Plot of Topic Diversity of the model as function of vocabulary size') \n",
    "plt.ylabel('Topic Diversity')\n",
    "plt.xlabel('Vocabulary Size')\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c4529ea",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}