{"id":584,"date":"2017-01-27T00:30:40","date_gmt":"2017-01-26T16:30:40","guid":{"rendered":"https:\/\/www.techcoil.com\/blog\/?p=584"},"modified":"2018-09-05T00:22:10","modified_gmt":"2018-09-04T16:22:10","slug":"how-to-generate-n-grams-in-python-without-using-any-external-libraries","status":"publish","type":"post","link":"https:\/\/www.techcoil.com\/blog\/how-to-generate-n-grams-in-python-without-using-any-external-libraries\/","title":{"rendered":"How to generate n-grams in Python without using any external libraries"},"content":{"rendered":"

There are many text analysis applications that utilize n-grams as a basis for building prediction models. The term \"n-grams\" refers to individual or group of words that appear consecutively in text documents. <\/p>\n

In this post, I document the Python codes that I typically use to generate n-grams without depending on external python libraries. <\/p>\n

Steps to generate n-grams from a large string of text<\/h2>\n

I usually break up the task of generating n-grams from a large string of text into the following subtasks:<\/p>\n

    \n
  1. Preprocess a large string of text and break them into a list of words.<\/li>\n
  2. Generate n-grams from a list of words.<\/li>\n<\/ol>\n

    Codes to preprocess a large string of text and break them into a list of words<\/h3>\n

    I typically use the following function to preprocess the text before the generation of n-grams:<\/p>\n

    \r\ndef process_text(text):\r\n\r\n    text = text.lower()\r\n    text = text.replace(',', ' ')\r\n    text = text.replace('\/', ' ')\r\n    text = text.replace('(', ' ')\r\n    text = text.replace(')', ' ')\r\n    text = text.replace('.', ' ')\r\n\r\n    # Convert text string to a list of words\r\n    return text.split()\r\n    \r\n<\/pre>\n
    The process_text<\/code> function accepts an input parameter as the text which we want to preprocess.<\/p>\n
    It first converts all the characters in the text to lowercases. After that, it replaces commas, forward slashes, brackets and full stops with single whitespaces. Finally, it uses the split<\/code> function on the text to split words by spaces and returns the result.<\/p>\n
    I will add more character replacement codes depending on where I anticipate the text input comes from. For example, if I am anticipating that the text is coming from a web crawler, I will perform HTML decoding<\/a> on the text input as well.<\/p>\n
    Codes to generate n-grams from a list of words<\/h3>\n
    I typically use the following function to generate n-grams out of a list of individual words:<\/p>\n
    \r\ndef generate_ngrams(words_list, n):\r\n    ngrams_list = []\r\n\r\n    for num in range(0, len(words_list)):\r\n        ngram = ' '.join(words_list[num:num + n])\r\n        ngrams_list.append(ngram)\r\n\r\n    return ngrams_list\r\n\r\n<\/pre>\n
    The generate_ngrams<\/code> function accepts two input parameters:<\/p>\n
      \n
    1. A list of individual words which can come from the output of the process_text<\/code> function.<\/li>\n
    2. A number which indicates the number of words in a text sequence.<\/li>\n<\/ol>\n
      Upon receiving the input parameters, the generate_ngrams<\/code> function declares a list to keep track of the generated n-grams. It then loops through all the words in words_list<\/code> to construct n-grams and appends them to ngram_list<\/code>.<\/p>\n
      When the loop completes, the generate_ngrams<\/code> function returns ngram_list<\/code> back to the caller.<\/p>\n
      Putting together process_text and generate_ngrams functions to generate n-grams<\/h2>\n
      The following is an example of how I would use the process_text<\/code> and generate_ngrams<\/code> functions in tandem to generate n-grams:<\/p>\n
      \r\nif __name__ == '__main__':\r\n\r\n    text = 'A quick brown fox jumps over the lazy dog.'\r\n\r\n    words_list = process_text(text)\r\n    unigrams = generate_ngrams(words_list, 1)\r\n    bigrams = generate_ngrams(words_list, 2)\r\n    trigrams = generate_ngrams(words_list, 3)\r\n    fourgrams = generate_ngrams(words_list, 4)\r\n    fivegrams = generate_ngrams(words_list, 5)\r\n\r\n    print (unigrams + bigrams + trigrams + fourgrams + fivegrams)\r\n<\/pre>\n
      The function first declares the text with the string 'A quick brown fox jumps over the lazy dog.'. It then convert the text to a list of individual words with the process_text<\/code> function. Once process_text<\/code> completes, it uses the generate_ngrams<\/code> function to create 1-gram, 2-gram, 3-gram, 4-gram and 5-gram sequences. Lastly, it prints the generated n-gram sequences to standard output.<\/p>\n
      Putting the the codes together in a Python script and running them will give me the following output:<\/p>\n
      \r\n['a', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog', 'a quick', 'quick brown', 'brown fox', 'fox jumps', 'jumps over', 'over the', 'the lazy', 'lazy dog', 'dog', 'a quick brown', 'quick brown fox', 'brown fox jumps', 'fox jumps over', 'jumps over the', 'over the lazy', 'the lazy dog', 'lazy dog', 'dog', 'a quick brown fox', 'quick brown fox jumps', 'brown fox jumps over', 'fox jumps over the', 'jumps over the lazy', 'over the lazy dog', 'the lazy dog', 'lazy dog', 'dog', 'a quick brown fox jumps', 'quick brown fox jumps over', 'brown fox jumps over the', 'fox jumps over the lazy', 'jumps over the lazy dog', 'over the lazy dog', 'the lazy dog', 'lazy dog', 'dog']\r\n<\/pre>\n\n