Kickstart ML with Python snippets

Simple explanation of the tokenization process

Tokenization is a fundamental step in preparing text data for machine learning models, especially in natural language processing (NLP).

What is Tokenization?

Tokenization is the process of breaking down text into smaller units called tokens. These tokens can be words, subwords, or characters, depending on the level of granularity you need for your specific task.

Why is Tokenization Important?

  1. Simplifies Text Processing: By breaking text into tokens, we can more easily analyze and manipulate the text. It allows us to convert the raw text into a format that can be used as input to machine learning models.

  2. Enables Feature Extraction: Tokens serve as the basic units for feature extraction. For example, in a sentiment analysis task, each word token can be a feature that helps determine the sentiment of the text.

  3. Facilitates Understanding and Comparison: Tokenized text allows for easier comparison and understanding of different texts. For instance, finding the frequency of each word in a document becomes straightforward when the document is tokenized.

How is Tokenization Done?

Word Tokenization

This involves splitting the text into individual words. For example:

  • Input Text: "Machine learning is fascinating."
  • Tokens: ["Machine", "learning", "is", "fascinating", "."]

Subword Tokenization

This method is often used in handling rare words and for languages with complex morphology. It involves breaking words into subword units, like prefixes, suffixes, or even smaller units.

  • Input Text: "unhappiness"
  • Tokens: ["un", "happiness"]

Subword tokenization techniques include Byte Pair Encoding (BPE) and WordPiece.

Character Tokenization

This involves splitting the text into individual characters. This method is useful for certain tasks where the character level features are important.

  • Input Text: "Hello"
  • Tokens: ["H", "e", "l", "l", "o"]

Tools and Libraries for Tokenization

Several libraries in Python can be used for tokenization:

  • NLTK (Natural Language Toolkit): Provides simple methods for word and sentence tokenization.
  • spaCy: Offers efficient and accurate tokenization.
  • Hugging Face Transformers: Uses advanced tokenization methods suited for modern NLP models like BERT, GPT, etc.

Challenges and pitfalls in Tokenization

  1. Handling Punctuation: Deciding whether to treat punctuation as separate tokens or part of a word.
  2. Dealing with Compound Words: Recognizing when words should be split or kept together (e.g., "New York" vs. "New" and "York").
  3. Language Specificity: Tokenization rules can vary greatly between languages due to differences in grammar and syntax.

Understanding tokenization is crucial for effectively preprocessing text data and building robust NLP models. It lays the foundation for further steps such as stop word removal, stemming, lemmatization, and feature extraction.

Stemming and lemmatization are crucial concepts related to tokenization in natural language processing (NLP). They are used to preprocess text data by reducing words to their base or root form, which helps in normalizing the text and improving the performance of machine learning models.


Stemming is the process of reducing a word to its base or root form. The base form, called the "stem," might not be a valid word by itself. The primary goal is to remove affixes (such as -ing, -ed, -s) to simplify the text.


  • Input Words: "running", "runs", "runner"
  • Stems: "run", "run", "runner"

Stemming is usually done using heuristic-based algorithms, which apply a set of rules to strip suffixes from words. The most common stemming algorithm is the Porter Stemmer, but others like the Snowball Stemmer and Lancaster Stemmer are also used.

Python Example

Here's how stemming can be done using the nltk library:


Lemmatization is the process of reducing a word to its canonical or dictionary form, called the "lemma." Unlike stemming, lemmatization takes into account the morphological analysis of the words and returns valid words.

Lemmatization requires more sophisticated understanding of the context and the part of speech of the word. This often makes lemmatization more accurate than stemming.


  • Input Words: "running", "runs", "runner", "better"
  • Lemmas: "run", "run", "runner", "good"

Lemmatization typically uses a vocabulary and morphological analysis. The most common lemmatization tool in Python is the WordNet Lemmatizer.

Stemming vs. Lemmatization

  1. Output Form:

    • Stemming: Produces the root form, which may not be a valid word.
    • Lemmatization: Produces the base form or lemma, which is always a valid word.
  2. Approach:

    • Stemming: Uses heuristic rules.
    • Lemmatization: Uses a vocabulary and morphological analysis.
  3. Accuracy:

    • Stemming: Faster but less accurate.
    • Lemmatization: Slower but more accurate.

Why Use Stemming and Lemmatization?

Both stemming and lemmatization are used to reduce the dimensionality of the text data. By reducing words to their base forms, we can:

  • Improve Consistency: Treat different forms of a word as a single feature.
  • Reduce Vocabulary Size: Minimize the number of unique tokens in the text.
  • Enhance Model Performance: Provide more consistent and clean input to machine learning models, improving their ability to generalize.

In summary, stemming and lemmatization are crucial steps in text preprocessing that help in normalizing and simplifying the text, making it more suitable for machine learning models.

Practical Example of Tokenization

Let's go through a practical example using Python and the nltk (Natural Language Toolkit) library. We'll tokenize a simple sentence into words.

Step-by-Step Example

  1. Install NLTK:

    • Ensure you have the nltk library installed. You can install it using pip if you haven’t already.
    pip install nltk
  2. Import Libraries:

    • Import the necessary libraries for tokenization.
    import nltk
    from nltk.tokenize import word_tokenize
  3. Download NLTK Data:

    • Download the required NLTK data, such as the tokenizer models.'punkt')
  4. Tokenize a Sentence:

    • Tokenize a simple sentence into words using the word_tokenize function.
    # Sample sentence
    sentence ="Tokenization is the first step in natural language processing."
    # Tokenize the sentence
    tokens = word_tokenize(sentence)
    # Print the token




  1. Sentence Definition:

    • We defined a sample sentence to tokenize: "Tokenization is the first step in natural language processing."
  2. Tokenization Process:

    • We used the word_tokenize function from the nltk.tokenize module to split the sentence into individual words and punctuation marks.
  3. Resulting Tokens:

    • The output is a list of tokens: ['Tokenization', 'is', 'the', 'first', 'step', 'in', 'natural', 'language', 'processing', '.']
    • Each word and punctuation mark is treated as a separate token.

Back to Kickstart ML with Python cookbook page