# Unveiling Hidden Themes: A Guide to LDA Topic Modelling in Python

## Understanding LDA Algorithm: A Deep Dive into Topic Modelling with NLP

Have you ever wondered how large amounts of text data can be analyzed to uncover underlying themes and patterns? Look no further than LDA, a powerful algorithm used in natural language processing (NLP) for topic modelling.

This article provides a comprehensive introduction to LDA, including its purpose, workings, and a practical example of its output.

## Definition and Purpose of LDA

LDA, or Latent Dirichlet Allocation, is a statistical approach that allows us to identify the underlying topics present in a collection of text documents. Essentially, LDA takes a corpus, a large set of documents, and attempts to extract a set of topics that might explain the contents of the corpus.

This process allows us to gain insights into the content of the corpus that might not have been apparent at a surface level. The purpose of LDA is to be able to classify new documents based on the topics present within the corpus.

LDA looks at every document in the corpus and identifies the set of topics that each document represents. It then identifies how every word in the document is related to the identified topics.

The result of this process is a two-step classification: first by topic and then by word.

## How LDA Works

LDA works by assigning every word in every document to a particular topic. Initially, the algorithm randomly assigns each word to a topic.

As the algorithm executes, it iteratively refines this assignment to ensure that each word is more accurately assigned to a topic, given the other words in that document and the topics identified so far. This process happens iteratively until the algorithm detects stability in the overall pattern produced by topic assignment.

In other words, the algorithm stops when the patterns being produced no longer shift significantly from one iteration to the next. Thus, the output of LDA is a set of topics, with probabilities assigned to each document in the corpus for every topic.

## Illustrative Example of LDA

To illustrate the workings of LDA, let’s consider a simple corpus consisting of three documents: a sports article, a political news article, and a business article. Let’s use LDA to ascertain the topics present in this corpus.

### Corpus and Topic Modelling

To begin with, we first tokenize the three documents, as shown below:

• Document 1: The Knicks won their game last night
• Document 2: The Prime Minister addressed the nation today
• Document 3: The stocks fell sharply after the earnings report

The first step is to determine the number of topics that we would like to identify. For this example, we will assume that there are two topics present in the corpus.

Once we have set the number of topics, LDA randomly assigns each word in the corpus to one of the two topics.

### The output for this corpus and iteration looks like this:

• Topic 1: 60% Knicks, 5% game, 20% Prime Minister, 15% addressed, 5% stocks, 95% earnings
• Topic 2: 40% Knicks, 95% game, 80% Prime Minister, 85% addressed, 95% stocks, 5% earnings

The first iteration might assign Knicks and game to Topic 1, Prime Minister and addressed to Topic 2, and stocks and earnings to both topics. Iterating over these assignments, LDA refines the probabilities of these word-to-topic assignments until the final probabilities converge on a stable solution.

In the above example, the output suggests that Topic 1 is focused on business with words related to stocks and earnings. Conversely, Topic 2 seems to focus on political news with keywords like Prime Minister and addressed.

The assignment of Knicks to both topics hints at some overlap between the topics. Document classification based on which topics are dominant in them can yield interesting insights.

## Conclusion

LDA is a powerful algorithm that can be applied to a variety of text data to extract interesting insights about the underlying patterns. Its ability to classify topics in text documents can be extremely helpful in various fields, such as content analysis, social media monitoring, and market research.

With the rise of big data and ever-increasing amounts of textual data, this algorithm has become even more critical in making sense of structured and unstructured data sources. By understanding LDAs mechanism and seeing its output in action, you will be well-equipped to tackle many of the challenges of conducting NLP-based topic modelling.

## Implementing LDA in Python: A Step-by-Step Guide

In the previous section, we provided a general overview of LDA and its workings. In this section, we will dive deeper into the implementation of LDA in Python, covering some of the most important steps involved in using LDA for text analysis.

### Importing Required Libraries

The first step in implementing LDA in Python is to import the required libraries. The primary libraries needed for LDA implementation include NumPy, Pandas, Gensim, and NLTK.

Additionally, we need to import the Stopwords package from NLTK to remove common words that may not be useful in the analysis.

import numpy as np
import pandas as pd
from gensim.models import LdaModel
from gensim import corpora
from gensim.parsing.preprocessing import preprocess_string
from nltk.corpus import stopwords

### Cleaning Data

Once we import the necessary libraries, we need to clean the data before feeding it to the LDA model. Data cleaning refers to the process of removing any irrelevant or redundant information from the data.

In text analysis, this includes normalizing whitespace, removing stopwords, stemming, and tokenization. Normalization of whitespace refers to removing any extra spaces from the text, and removing stopwords generally refers to removing commonly used words like the, a, and so on.

Stemming involves reducing words to their root form, and tokenization refers to splitting the text into individual words, or tokens.

stop_words = stopwords.words('english')
def clean_text(text):
text = preprocess_string(text,
[
lambda x: x.lower(),
lambda x: x.replace('[^a-zA-Z0-9 ]', ' '),
lambda x: x.strip(),
]
)
text = ' '.join([word for word in text.split() if word not in stop_words])
return text

### Term Frequency (TF-IDF)

LDA works by analyzing the frequency of words in the data. The frequency of occurrence of a word in a document is called the term frequency (TF).

However, some words may be common across all documents, making them less informative for classifying the text into meaningful topics. Therefore, we use a numerical statistic called TF-IDF, which stands for Term Frequency-Inverse Document Frequency.

TF-IDF is a weighting factor that assigns higher weightage to words that are rare in the corpus and lower weightage to words that are common in all documents. It helps to prioritize words that are specific to particular documents and assigns lower importance to common words.

The output of this process is a document-term matrix that represents the frequency of each term in their respective documents.

def create_dictionary_and_corpus(texts):
dictionary = corpora.Dictionary(texts)
corpus = [dictionary.doc2bow(text) for text in texts]
return dictionary, corpus

### Running LDA using Bag of Words

Once we have constructed the document-term matrix, the next step is to create the LDA model. We can do this using the Gensim LdaMulticore method.

We start by converting the document-term matrix into a corpus_doc2bow_vectors format. Then we create the LDA model by specifying the number of topics we want to extract and the number of times that the model should pass over the data to complete its training.

The passes parameter specifies how many passes we want the model to make over the data, and the workers parameter specifies how many CPU cores we would like to utilize in training the model.

def train_lda_model_bow(corpus, dictionary, num_topics, passes):
lda_model = LdaModel(corpus=corpus, id2word=dictionary, num_topics=num_topics, passes=passes, workers=4)
return lda_model

### Running LDA using TF-IDF

Alternatively, we can further refine the LDA model by using the corpus_tfidf_vectors format instead of the document-term matrix. The corpus_tfidf_vectors format weighs the term-frequency values by their IDF values, which makes it a more refined way to represent the data than the simple frequency counts used in the Bag of Words approach.

By using the corpus_tfidf_vectors format, we can create a more accurate model that is better suited for identifying important and unique words within the documents. To do this, we need to modify our code to account for the corpus_tfidf_vectors format.

from gensim.models import TfidfModel
def train_lda_model_tfidf(corpus, dictionary, num_topics, passes):
tfidf = TfidfModel(corpus)
corpus_tfidf = tfidf[corpus]
lda_model = LdaModel(corpus=corpus_tfidf, id2word=dictionary, num_topics=num_topics, passes=passes, workers=4)
return lda_model

### Classification of Topics

Once we have trained the LDA model, we can use it to classify new documents based on their similarity to the topics within the existing corpus. We can do this by assigning new documents to one of the extracted topics based on their similarity to the topic terms.

We can evaluate the performance of our model by comparing the derived topics for a random selection of sample documents with the manually assigned topics. The accuracy of these classifications is a good indicator of the performance of the LDA model overall.

def classify_new_document(lda_model, dictionary, new_document):
bow_vector = dictionary.doc2bow(new_document.split())
topic_distribution = lda_model.get_document_topics(bow_vector)
dominant_topic = max(topic_distribution, key=lambda x: x[1])
return dominant_topic

## Conclusion

LDA is a statistical modeling technique used in data mining and natural language processing to identify topic models within a corpus. We can use LDA for a variety of applications, including content analysis, social media monitoring, and market research.

Implementing LDA in Python involves several key steps, including importing the necessary libraries, preparing the data by cleaning it, calculating TF-IDF values, and creating and training the LDA models. Overall, LDA is a powerful tool that can help us identify interesting themes and insights within large datasets, making it a valuable tool for data scientists working with text data in any context.

In this article, we explored the implementation of LDA, a powerful algorithm for identifying topic models within a corpus of text data, using Python. We covered various key steps involved in using LDA, including importing necessary libraries, cleaning data, calculating TF-IDF values, and creating and training LDA models.

LDA is a valuable tool for data scientists working with text data, as it can help uncover insights and themes within large datasets. By following the steps outlined in this article, data scientists can leverage LDA to analyze text data and extract valuable insights.