This chapter presents recipes to build text classifiers. This includes extracting vital features from the database, training, testing, and validating the text classifier. Initially, a text classifier is trained using commonly used words. Later, the trained text classifier is used for prediction. Building a text classifier includes preprocessing the data using tokenization, stemming text data, dividing text using chunking, and building a bag-of-words model.

Classifier units are normally considered to separate a database into various classes. The Naive Bayes classifier scheme is widely considered in literature to segregate the texts based on the trained model. This section of the chapter initially considers a text database with keywords; feature extraction extracts the key phrases from the text and trains the classifier system. Then, term frequency-inverse document frequency (tf-idf) transformation is implemented to specify the importance of the word. Finally, the output is predicted and printed using the classifier system.

1. Include the following lines in a new Python file to add datasets:

from sklearn.datasets import fetch_20newsgroups...

The pre-processing of data involves converting the existing text into acceptable information for the learning algorithm.

Tokenization is the process of dividing text into a set of meaningful pieces. These pieces are called tokens.

1. Introduce sentence tokenization:

from nltk.tokenize import sent_tokenize

2. Form a new text tokenizer:

tokenize_list_sent = sent_tokenize(text)
print "nSentence tokenizer:" 
print tokenize_list_sent 

3. Form a new word tokenizer:

from nltk.tokenize import word_tokenize 
print "nWord tokenizer:" 
print word_tokenize(text) 

4. Introduce a new WordPunct tokenizer:

from nltk.tokenize import WordPunctTokenizer 
word_punct_tokenizer...

The stemming procedure involves creating a suitable word with reduced letters for the words of the tokenizer.

1. Initialize the stemming process with a new Python file:

from nltk.stem.porter import PorterStemmer 
from nltk.stem.lancaster import LancasterStemmer 
from nltk.stem.snowball import SnowballStemmer 

2. Let's describe some words to consider, as follows:

words = ['ability', 'baby', 'college', 'playing', 'is', 'dream', 'election', 'beaches', 'image', 'group', 'happy'] 

3. Identify a group of stemmers to be used:

stemmers = ['PORTER', 'LANCASTER', &apos...

The chunking procedure can be used to divide the large text into small, meaningful words.

1. Develop and import the following packages using Python:

import numpy as np 
from nltk.corpus import brown 

2. Describe a function that divides text into chunks:

# Split a text into chunks 
def splitter(content, num_of_words): 
   words = content.split(' ') 
   result = [] 

3. Initialize the following programming lines to get the assigned variables:

   current_count = 0 
   current_words = []

4. Start the iteration using words:

   for word in words: 
     current_words.append(word) 
     current_count += 1 

5. After getting the essential amount of words, reorganize the variables:

  ...

When working with text documents that include large words, we need to switch them to several types of arithmetic depictions. We need to formulate them to be suitable for machine learning algorithms. These algorithms require arithmetical information so that they can examine the data and provide significant details. The bag-of-words procedure helps us to achieve this. Bag-of-words creates a text model that discovers vocabulary using all the words in the document. Later, it creates the models for every text by constructing a histogram of all the words in the text.

1. Initialize a new Python file by importing the following file:

import numpy as np 
from nltk.corpus import brown 
from...

Text classifiers are used to analyze customer sentiments, in product reviews, when searching queries on the internet, in social tags, to predict the novelty of research articles, and so on.