Doing Sentiment Analysis using Natural Language Process

Introduction:

 In the field of Artificial Intelligence, the amount of using Natural Language Processing is increasing heavily. Some common applications where NLP is used mostly as follows:

 Text Classification (Spam Detector etc)

 Sentiment Analysis

 Author Recognition

 Machine Translate

 Chatbots

What is Sentiment Analysis?

One of the most common applications in Natural Language Processing is Sentiment Analysis through which we can decide the emotion of a text is written.

As the use of Social Media platforms are growing day by day, as the use of these platforms are getting popular and the more people are getting attached to it,  the need to analyze the content that people shares/posts over here are increasing rapidly. If we consider the volume of data coming through social media, it is really difficult to do this with human power. Therefore, the need for applications that can quickly detect and respond to the positive or negative comments that people write are increasing. In this blog, a baseline model for simple analysis of sentiment will be developed.

First of all, go through the information about the dataset .

Data Set Name: Sentiment Labelled Sentences Data Set

Data Set Source: UCI Machine Learning Libarary

Data Set Info: This dataset was created with user reviews collected via three different websites ( like Amazon, Yelp, IMDb). These comments contain the restaurants, films and product reviews. Each record in the data set is labeled with two different emoticons. These are 1: Positive, 0: Negative.We will create a sentiment analysis model using the data set we have given above.

Let's build a Machine Learning model with the Python using the sklearn and nltk library.

First, let's import the libraries we will use.

1

import pandas as pd

2

import numpy as np

3

import pickle

4

import sys

5

import os

6

import io

7

import re

8

from sys import path

9

import numpy as np

10

import pickle

11

from sklearn.feature_extraction.text import CountVectorizer

12

from sklearn.naive_bayes import MultinomialNB

13

from sklearn.model_selection import train_test_split

14

from sklearn.preprocessing import LabelBinarizer

15

import matplotlib.pyplot as plt

16

from string import punctuation, digits

17

from IPython.core.display import display, HTML

18

from nltk.corpus import stopwords

19

from nltk.corpus import stopwords

20

from nltk.tokenize import word_tokenize

21

from nltk.tokenize import RegexpTokenizer

Now we'll upload and view our data set.

1

#Amazon Data

2

input_file = "../data/amazon_cells_labelled.txt"

3

amazon = pd.read_csv(input_file,delimiter='\t',header=None)

4

amazon.columns = ['Sentence','Class']

5

​

6

#Yelp Data

7

input_file = "../data/yelp_labelled.txt"

8

yelp = pd.read_csv(input_file,delimiter='\t',header=None)

9

yelp.columns = ['Sentence','Class']

10

​

11

#Imdb Data

12

input_file = "../data/imdb_labelled.txt"

13

imdb = pd.read_csv(input_file,delimiter='\t',header=None)

14

imdb.columns = ['Sentence','Class']

15

​

16

​

17

#combine all data sets

18

data = pd.DataFrame()

19

data = pd.concat([amazon, yelp, imdb])

20

data['index'] = data.index

21

​

22

data

Successfully imported the data and viewed it. Now, let's look at the statistics about the data.

1

#Total Count of Each Category

2

pd.set_option('display.width', 4000)

3

pd.set_option('display.max_rows', 1000)

4

distOfDetails = data.groupby(by='Class', as_index=False).agg({'index': pd.Series.nunique}).sort_values(by='index', ascending=False)

5

distOfDetails.columns =['Class', 'COUNT']

6

print(distOfDetails)

7

​

8

#Distribution of All Categories

9

plt.pie(distOfDetails['COUNT'],autopct='%1.0f%%',shadow=True, startangle=360)

10

plt.show()

See carefully, the data set is very balanced i.e. almost equal numbers of positive and negative classes.

Now, before using the data set in the model, let's do a few things to clear the text.

1

#Text Preprocessing

2

columns = ['index','Class', 'Sentence']

3

df_ = pd.DataFrame(columns=columns)

4

​

5

#lower string

6

data['Sentence'] = data['Sentence'].str.lower()

7

​

8

#remove email adress

9

data['Sentence'] = data['Sentence'].replace('[a-zA-Z0-9-_.]+@[a-zA-Z0-9-_.]+', '', regex=True)

10

​

11

#remove IP address

12

data['Sentence'] = data['Sentence'].replace('((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.|$)){4}', '', regex=True)

13

​

14

#remove punctaitions and special chracters

15

data['Sentence'] = data['Sentence'].str.replace('[^\w\s]','')

16

​

17

#remove numbers

18

data['Sentence'] = data['Sentence'].replace('\d', '', regex=True)

19

​

20

#remove stop words

21

for index, row in data.iterrows():

22

    word_tokens = word_tokenize(row['Sentence'])

23

    filtered_sentence = [w for w in word_tokens if not w in stopwords.words('english')]

24

    df_ = df_.append({"index": row['index'], "Class":  row['Class'],"Sentence": " ".join(filtered_sentence[0:])}, ignore_index=True)

25

​

26

data = df_

We made the pre-cleaning of the data ready for use within the model. Before we build our model, let's split our dataset to test (10%) and training(90%).

1

X_train, X_test, y_train, y_test = train_test_split(data['Sentence'].values.astype('U'),data['Class'].values.astype('int32'), test_size=0.10, random_state=0)

2

classes  = data['Class'].unique()

Now we have to create our model using our training data. While creating the model, I will use the TF-IDF as the vectorizer and the Stochastic Gradient Descend algorithm as the classifier.

We found these methods and the parameters in the method using grid search (I will not mention grid search in this article).

1

from sklearn.metrics import confusion_matrix

2

from sklearn.model_selection import cross_val_score

3

from sklearn.metrics import accuracy_score

4

from sklearn.neural_network import MLPClassifier

5

from sklearn.feature_extraction.text import TfidfVectorizer

6

from sklearn.linear_model import SGDClassifier

7

​

8

​

9

#grid search result

10

vectorizer = TfidfVectorizer(analyzer='word',ngram_range=(1,2), max_features=50000,max_df=0.5,use_idf=True, norm='l2') 

11

counts = vectorizer.fit_transform(X_train)

12

vocab = vectorizer.vocabulary_

13

classifier = SGDClassifier(alpha=1e-05,max_iter=50,penalty='elasticnet')

14

targets = y_train

15

classifier = classifier.fit(counts, targets)

16

example_counts = vectorizer.transform(X_test)

17

predictions = classifier.predict(example_counts)

Our model has occurred. Now let's test our model with test data. Let's examine the accuracy, precision, recall and f1 results.

1

from sklearn.metrics import precision_score

2

from sklearn.metrics import recall_score

3

from sklearn.metrics import classification_report

4

​

5

#Model Evaluation

6

acc = accuracy_score(y_test, predictions, normalize=True)

7

hit = precision_score(y_test, predictions, average=None,labels=classes)

8

capture = recall_score(y_test, predictions, average=None,labels=classes)

9

​

10

print('Model Accuracy:%.2f'%acc)

11

print(classification_report(y_test, predictions))

1

Model Accuracy:0.83

2

             precision    recall  f1-score   support

3

​

4

          0       0.83      0.84      0.84       139

5

          1       0.84      0.82      0.83       136

6

​

7

avg / total       0.83      0.83      0.83       275

See the success of our model was 83%. Let's look at the confusion matrix, where we can see more clearly how accurate our estimates are.

1

#source: https://www.kaggle.com/grfiv4/plot-a-confusion-matrix

2

import itertools

3

def plot_confusion_matrix(cm, classes,

4

                          normalize=False,

5

                          title='Confusion matrix',

6

                          cmap=plt.cm.Blues):

7

    """

8

    This function prints and plots the confusion matrix.

9

    Normalization can be applied by setting `normalize=True`.

10

    """

11

    if normalize:

12

        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]

13

        #print("Normalized confusion matrix")

14

    else:

15

        print()

16

​

17

    plt.imshow(cm, interpolation='nearest', cmap=cmap, aspect='auto')

18

    plt.title(title)

19

    plt.colorbar()

20

    tick_marks = np.arange(len(classes))

21

    plt.xticks(tick_marks, classes, rotation=45)

22

    plt.yticks(tick_marks, classes)

23

​

24

    fmt = '.2f' if normalize else 'd'

25

    thresh = cm.max() / 2.

26

    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):

27

        plt.text(j, i, format(cm[i, j], fmt),

28

                 horizontalalignment="center",

29

                 color="white" if cm[i, j] > thresh else "black")

30

​

31

    plt.tight_layout()

32

    plt.ylabel('True label')

33

    plt.xlabel('Predicted label')

34

    plt.figure(figsize=(150,100))

1

# Compute confusion matrix

2

cnf_matrix = confusion_matrix(y_test, predictions,classes)

3

np.set_printoptions(precision=2)

4

​

5

class_names = range(1,classes.size+1)

6

​

7

# Plot non-normalized confusion matrix

8

plt.figure()

9

plot_confusion_matrix(cnf_matrix, classes=class_names,title='Confusion matrix, without normalization')

10

​

11

classInfo = pd.DataFrame(data=[])

12

for i in range(0,classes.size):

13

    classInfo = classInfo.append([[classes[i],i+1]],ignore_index=True)

14

​

15

classInfo.columns=['Category','Index']

16

classInfo

So now, we have successfully developed a Natural Language Processing project. This is a baseline model. 

-An Article by Rajdeep Das

Visit My linkedIn Porifle 

References: GitHub, DZone