Adventures in Machine Learning

Demystifying Text Normalization: Stemming vs Lemmatization

Text normalization techniques have become increasingly relevant in Natural Language Processing (NLP) applications. NLP aims to enable computers to interpret human language by extracting meaning from text.

However, this can be difficult, especially when considering the fact that human language is inherently complex, influenced by a range of factors, such as context, spelling, grammar, and formality. One of the main challenges faced when analyzing text is dealing with words that have different forms but the same meaning.

This is where text normalization techniques come into the picture. In this article, we will explore the two primary text normalization techniques: stemming and lemmatization.

Understanding Stemming and Lemmatization

Stemming and lemmatization are techniques used in text normalization that involve reducing words to their base form. The primary objective of these techniques is to facilitate the analysis of text by grouping together words that have the same meaning.

By reducing words to their root form, it becomes easier to apply machine-learning algorithms such as clustering, classification, and sentiment analysis. Stemming essentially involves the process of removing the suffix from a word to obtain its root form.

For example, the word ‘running’ can be stemmed to ‘run’, ‘jolly’ can be stemmed to ‘jolli’, and ‘happy’ can be stemmed to ‘happi’. This technique is particularly useful when working with large datasets, where every second saved counts.

Lemmatization, on the other hand, is a more complex technique that involves reducing words to their base form known as the lemma. This means that if a word has multiple inflected forms, lemmatization will return the base form.

This technique can handle irregular words that may not be covered by stemming. For instance, the word ‘went’, which is the past tense of ‘go’, can be lemmatized to its base form ‘go’.

Similarly, the word ‘are’ can be lemmatized to ‘be’.

Importance of Reducing Words to Their Base Form

Reducing words to their base form is not just important for simplifying language. It has other practical implications when it comes to data analysis and improving user experience.

Here are some key reasons why text normalization is crucial in NLP:

  1. Improved Search Results

    When analyzing text, it is crucial to identify the relationships between different words in a sentence.

    Lemma and Stemming simplify the task of identifying relationships between different parts of the sentence. To show how this works, consider the search phrase “best place to visit in summer”.

    The search engine will return more accurate results if it can recognize variations of the word ‘visit’, such as ‘visiting,’ ‘visited,’ ‘visitor,’ etc.

  2. Increased Accuracy in Sentiment Analysis

    Sentiment analysis uses machine learning algorithms to extract emotions, attitudes, and opinions from written or spoken language. By reducing words to their base form, sentiment analysis systems can better capture the emotional content of a text, enabling developers to identify the sentiment of the content more accurately.

    For instance, consider the sentence “I love the new iPhone. Its features are amazing.” By extracting the base form of words like ‘loved’ and ‘amazing,’ sentiment analysis algorithms can quickly determine that the sentiment expressed in this sentence is positive.

  3. Efficient Machine Translation

    For machine translation systems that rely on algorithms to automatically translate text from one language to another, stemming and lemmatization can make the process more accurate.

    These techniques increase the chances of discovering related words with similar meanings regardless of their grammatical context. By doing this, it becomes possible to find word senses suitable for the context.

Stemming Using NLTK and SpaCy Libraries

Now that we have an understanding of why it’s important to reduce words to their base form, let’s take a closer look at how this can be achieved using the Python Natural Language Toolkit (NLTK) and SpaCy libraries. The NLTK library is a popular choice for text normalization tasks in NLP applications.

One of the most commonly used stemmers in the library is the Porter Stemmer, which is based on the Porter stemming algorithm. Another well-known stemmer is the Snowball Stemmer.

Both stemmers work by removing the suffix of a word until the root form is obtained.

Here’s how to use the Porter Stemmer with the NLTK library in Python:

from nltk.stem import PorterStemmer
from nltk.tokenize import word_tokenize
porter = PorterStemmer()
text = "The quick brown fox jumps over the lazy dog."
words = word_tokenize(text)
for word in words:

The above code will output the stems of each word in the text:


SpaCy is another open-source library that is widely used in NLP applications.

It provides a comprehensive pipeline of functions, including tokenization, part-of-speech tagging, entity recognition, and lemmatization. Since the library is written in C and Cython, it’s relatively fast and efficient in its operations.

Here’s how to use the lemmatizer in SpaCy:

import spacy
nlp = spacy.load('en_core_web_sm')
text = "The quick brown fox jumps over the lazy dog."
doc = nlp(text)
for token in doc:
    print(token, token.lemma_)

This code will output the original token alongside its lemma:

The the
quick quick
brown brown
fox fox
jumps jump
over over
the the
lazy lazy
dog dog
. .


Understanding text normalization techniques is critical to anyone involved in NLP applications. While stemming and lemmatization are widely used techniques, they have their strengths and weaknesses.

Thus, it’s important to determine which technique to use based on the task at hand. By reducing words to their base form, developers can significantly improve the accuracy of machine translation, improve search results, and increase the accuracy of sentiment analysis.

3) Stemming with PorterStemmer and Snowball Stemmer

Stemming is a text normalization technique that involves removing the suffix from words to obtain their root form. The idea behind stemming is to standardize words so that related words can be grouped together in a dataset.

One of the most widely used stemming algorithms is the Porter Stemmer. The Porter Stemmer is a rule-based stemming algorithm developed by Martin Porter in 1979.

It uses a set of rules to remove suffixes from English words and returns the stem. The algorithm is designed to be relatively simple and efficient, making it a popular choice for many NLP applications.

Here’s a simple example of how the Porter Stemmer works. Consider the word “running”.

The Porter Stemmer applies a series of rules to the word until it reduces it to its stem “run”. The following steps demonstrate how this works:

  1. Remove the “ing” suffix to obtain “runn”.
  2. Apply Rule 1: Replace the suffix “nn” with “n”, obtaining “run”.
  3. Replace the “r” suffix with the letter “e” for verbs to obtain the final stem “run”.

While the Porter Stemmer is widely used, it may not be suitable for all NLP tasks since it can produce incorrect stems for words with irregular forms.

This is where the Snowball Stemmer comes into the picture. The Snowball Stemmer (Porter2 Stemmer) is an improved version of the Porter Stemmer algorithm.

It extends the set of rules used by the Porter Stemmer to include more complex suffixes and language-specific rules. This means that the Snowball Stemmer is more powerful than the Porter Stemmer and can produce more accurate stems.

The Snowball Stemmer is available in many NLP libraries, including NLTK and SpaCy. Here’s how to use the Snowball Stemmer with NLTK:

from nltk.stem import SnowballStemmer
stemmer = SnowballStemmer("english")
words = ["running", "jumps", "jumping", "jumped", "jumper"]
for word in words:

This code will output the stems of each word using the Snowball Stemmer:


4) Understanding Lemmatization

Lemmatization, like stemming, is a text normalization technique used to reduce words to their base form. However, unlike stemming, Lemmatization takes into account the context and part of speech of a word to obtain its lemma.

The lemma is the base form of a word, which may or may not be a proper word. For example, the lemma of “am”, “are”, and “is” is “be”, which itself is a proper word.

The primary difference between stemming and lemmatization is that stemming involves the removal of suffixes to obtain a base form, while lemmatization involves the application of an algorithmic process to obtain the base form. One of the most popular algorithms used in lemmatization is WordNet.

WordNet is a large lexical database of English words that includes words and definitions. The database is organized into sets of synonyms called synsets, where each synset is linked to one or more lemmas.

Here’s how to use the lemmatizer in Python NLTK:

from nltk.stem import WordNetLemmatizer'wordnet')
lemmatizer = WordNetLemmatizer()
words = ["running", "jumps", "jumping", "jumped", "jumper"]
for word in words:

This code will output the lemmas of each word using WordNet:


In the code above, we imported the WordNetLemmatizer from the NLTK library and downloaded the WordNet database using the method. We then initialized the lemmatizer and provided a list of words to lemmatize.

Finally, we used a for loop to iterate through each word in the list and used the lemmatize() method on the lemmatizer object to obtain the lemma. We can also use the Python SpaCy library for lemmatization.

Here’s an example of how to use the lemmatizer in SpaCy:

import spacy
nlp = spacy.load('en_core_web_sm')
text = "The quick brown fox jumps over the lazy dog."
doc = nlp(text)
for token in doc:
    print(token.text, token.lemma_, token.pos_)

This code will output the lemma and part of speech of each word in the text using SpaCy:

The the DET
quick quick ADJ
brown brown ADJ
fox fox NOUN
jumps jump VERB
over over ADP
the the DET
lazy lazy ADJ
dog dog NOUN

In conclusion, stemming and lemmatization are text normalization techniques used in NLP applications. While stemming involves removing word suffixes to obtain their root forms, lemmatization uses an algorithmic process to obtain the base form of a word.

The choice of which technique to use depends on the specific NLP task at hand. 5) Lemmatization vs.


Lemmatization and stemming are two text normalization techniques used in Natural Language Processing (NLP). While the primary purpose of both techniques is to reduce words to their base form to aid in language analysis, each technique has its unique benefits and tradeoffs.

Tradeoff Between Speed and Accuracy

Stemming is a more straightforward and faster process compared to lemmatization – it involves cutting off word suffixes without considering grammar or context to obtain the stem/root of the word. This approach is ideal for applications that require fast processing speeds, such as sentiment analysis, search engines, and other information retrieval systems that require immediate responses.

Lemmatization, on the other hand, is highly accurate but a slower process, particularly when dealing with large volumes of text data. Lemmatization takes the grammatical context into account, which means it requires a more in-depth analysis of the text, and this naturally slows down the process.

It takes more time to determine the right base form for each word in the text than with stemming. Accuracy of Lemmatization vs.


One of the primary differences between stemming and lemmatization is the accuracy of the results obtained. Stemming is susceptible to over-stemming and under-stemming, which often causes errors in language analysis.

Over-stemming occurs when a stemmer cut off too many character sequences from a word, resulting in the stem being incorrectly represented. For example, the word ‘boys’ is stemmed to ‘boi’ instead of ‘boy’.

Under-stemming, on the other hand, occurs when a stemmer fails to cut off enough suffixes to obtain the stem. For example, the word ‘happier’ is stemmed to ‘happi’ instead of ‘happy.

Lemmatization, on the other hand, avoids this error by using a more complex algorithm to obtain the base form of the word. It also takes into account the part of speech of the word and context in which the word is used, which enhances its accuracy.

Lemmatization provides valuable information from the context that can help better disambiguate the meaning of a word. Thus, this makes it especially useful in natural language applications that require a high level of accuracy, such as information retrieval, machine translation and chatbot development.

One notable example is a chatbot service that needs to comprehend complex user queries. Without proper normalization, the chatbot may fail to interpret the nuances of the query and deliver unsuitable responses that can lead to a frustrating experience for the user.

In this case, using lemmatization can help to facilitate more accurate comprehension of the users needs. In addition, when dealing with language-specific requirements, it may be necessary to select a specific lemmatizer that is tailored towards that language.

During this process, pos tagging comes into play, providing the necessary grammatical details to help with disambiguation. For instance, a sentence in French, “rechercher la voiture” as a search query to be translated into English, “search for the car” may end up being translated as “searching” if stemmed, but the performance would be much improved if lemmatized and understood in the specific context.


One of the primary differences between stemming and lemmatization is the context in which they are best used. Stemming may be ideal in situations where speed and efficiency are top priorities, and accuracy levels are acceptable, while lemmatization is better suited for applications that require a high degree of accuracy with precision for context.

In general terms, both lemmatization and stemming have their unique advantages and disadvantages, though lemmatization appears to be better for improving information retrieval, machine translation, and chatbot development tasks. Even at its slow pace, lemmatization remains the go-to technique for analytically demanding NLP applications that require a greater level of personalization and precision.

In conclusion, text normalization techniques such as stemming and lemmatization are essential in enabling machines to understand human language by reducing words to their base form. While stemming may be faster, lemmatization provides a higher degree of accuracy by taking into account grammar and context, making it more suitable for tasks that require a greater level of personalization.

The choice between the two techniques ultimately depends on the task requirements in any given NLP application. Understanding how to use these techniques and which one to use in each situation is vital for successful language analysis and processing.

Ultimately, the effectiveness of natural language processing depends on a consideration of the utility of these techniques in each particular process.

Popular Posts