Words from the word representation

import pandas as pd

import numpy as np

import warnings

warnings.filterwarnings(‘ignore’)

# Reading the data

TicketData=pd.read_csv(‘supportTicketData.csv’)

# Printing number of rows and columns

print(TicketData.shape)

# Printing sample rows

TicketData.head(10)

# Number of unique values for urgency column

# You can see there are 3 ticket types

print(TicketData.groupby(‘urgency’).size())

# Plotting the bar chart

%matplotlib inline

TicketData.groupby(‘urgency’).size().plot(kind=‘bar’);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

# Count vectorization of text

from sklearn.feature_extraction.text import CountVectorizer

# Ticket Data

corpus = TicketData[‘body’].values

# Creating the vectorizer

vectorizer = CountVectorizer(stop_words=‘english’)

# Converting the text to numeric data

X = vectorizer.fit_transform(corpus)

#print(vectorizer.get_feature_names())

# Preparing Data frame For machine learning

# Priority column acts as a target variable and other columns as predictors

CountVectorizedData=pd.DataFrame(X.toarray(), columns=vectorizer.get_feature_names())

CountVectorizedData[‘Priority’]=TicketData[‘urgency’]

print(CountVectorizedData.shape)

CountVectorizedData.head()

#Installing the gensim library required for word2Vec and Doc2Vec

!pip install gensim

import gensim

#Loading the word vectors from Google trained word2Vec model

GoogleModel = gensim.models.KeyedVectors.load_word2vec_format(‘/Users/farukh/Downloads/GoogleNews-vectors-negative300.bin’, binary=True,)

# Each word is a vector of 300 numbers

GoogleModel[‘hello’].shape

# Looking at a sample vector for a word

GoogleModel[‘hello’]

# Finding similar words

# The most_similar() function finds the cosine similarity of the given word with

# other words using the word2Vec representations of each word

GoogleModel.most_similar(‘king’, topn=5)

# Checking if a word is present in the Model Vocabulary

‘Hello’ in GoogleModel.key_to_index.keys()

# Creating the list of words which are present in the Document term matrix

WordsVocab=CountVectorizedData.columns[:—1]

# Printing sample words

WordsVocab[0:10]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

# Defining a function which takes text input and returns one vector for each sentence

def FunctionText2Vec(inpTextData):

    # Converting the text to numeric data

    X = vectorizer.transform(inpTextData)

    CountVecData=pd.DataFrame(X.toarray(), columns=vectorizer.get_feature_names())

    # Creating empty dataframe to hold sentences

    W2Vec_Data=pd.DataFrame()

    # Looping through each row for the data

    for i in range(CountVecData.shape[0]):

        # initiating a sentence with all zeros

        Sentence = np.zeros(300)

        # Looping thru each word in the sentence and if its present in

        # the Word2Vec model then storing its vector

        for word in WordsVocab[CountVecData.iloc[i , :]>=1]:

            #print(word)

            if word in GoogleModel.key_to_index.keys():    

                Sentence=Sentence+GoogleModel[word]

        # Appending the sentence to the dataframe

        W2Vec_Data=W2Vec_Data.append(pd.DataFrame([Sentence]))

    return(W2Vec_Data)

# Since there are so many words… This will take some time

# Calling the function to convert all the text data to Word2Vec Vectors

W2Vec_Data=FunctionText2Vec(TicketData[‘body’])

# Checking the new representation for sentences

W2Vec_Data.shape

# Comparing the above with the document term matrix

CountVectorizedData.shape

# Adding the target variable

W2Vec_Data.reset_index(inplace=True, drop=True)

W2Vec_Data[‘Priority’]=CountVectorizedData[‘Priority’]

# Assigning to DataForML variable

DataForML=W2Vec_Data

DataForML.head()

# Separate Target Variable and Predictor Variables

TargetVariable=DataForML.columns[—1]

Predictors=DataForML.columns[:—1]

X=DataForML[Predictors].values

y=DataForML[TargetVariable].values

# Split the data into training and testing set

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=428)

# Sanity check for the sampled data

print(X_train.shape)

print(y_train.shape)

print(X_test.shape)

print(y_test.shape)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

from sklearn.preprocessing import StandardScaler, MinMaxScaler

# Choose either standardization or Normalization

# On this data Min Max Normalization is used because we need to fit Naive Bayes

# Choose between standardization and MinMAx normalization

#PredictorScaler=StandardScaler()

PredictorScaler=MinMaxScaler()

# Storing the fit object for later reference

PredictorScalerFit=PredictorScaler.fit(X)

# Generating the standardized values of X

X=PredictorScalerFit.transform(X)

# Split the data into training and testing set

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=428)

# Sanity check for the sampled data

print(X_train.shape)

print(y_train.shape)

print(X_test.shape)

print(y_test.shape)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

# Naive Bayes

from sklearn.naive_bayes import GaussianNB, MultinomialNB

# GaussianNB is used in Binomial Classification

# MultinomialNB is used in multi-class classification

#clf = GaussianNB()

clf = MultinomialNB()

# Printing all the parameters of Naive Bayes

print(clf)

NB=clf.fit(X_train,y_train)

prediction=NB.predict(X_test)

# Measuring accuracy on Testing Data

from sklearn import metrics

print(metrics.classification_report(y_test, prediction))

print(metrics.confusion_matrix(y_test, prediction))

# Printing the Overall Accuracy of the model

F1_Score=metrics.f1_score(y_test, prediction, average=‘weighted’)

print(‘Accuracy of the model on Testing Sample Data:’, round(F1_Score,2))

# Importing cross validation function from sklearn

from sklearn.model_selection import cross_val_score

# Running 10-Fold Cross validation on a given algorithm

# Passing full data X and y because the K-fold will split the data and automatically choose train/test

Accuracy_Values=cross_val_score(NB, X , y, cv=5, scoring=‘f1_weighted’)

print(‘nAccuracy values for 5-fold Cross Validation:n’,Accuracy_Values)

print(‘nFinal Average Accuracy of the model:’, round(Accuracy_Values.mean(),2))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

# K-Nearest Neighbor(KNN)

from sklearn.neighbors import KNeighborsClassifier

clf = KNeighborsClassifier(n_neighbors=15)

# Printing all the parameters of KNN

print(clf)

# Creating the model on Training Data

KNN=clf.fit(X_train,y_train)

prediction=KNN.predict(X_test)

# Measuring accuracy on Testing Data

from sklearn import metrics

print(metrics.classification_report(y_test, prediction))

print(metrics.confusion_matrix(y_test, prediction))

# Printing the Overall Accuracy of the model

F1_Score=metrics.f1_score(y_test, prediction, average=‘weighted’)

print(‘Accuracy of the model on Testing Sample Data:’, round(F1_Score,2))

# Importing cross validation function from sklearn

from sklearn.model_selection import cross_val_score

# Running 10-Fold Cross validation on a given algorithm

# Passing full data X and y because the K-fold will split the data and automatically choose train/test

#Accuracy_Values=cross_val_score(KNN, X , y, cv=10, scoring=’f1_weighted’)

#print(‘nAccuracy values for 10-fold Cross Validation:n’,Accuracy_Values)

#print(‘nFinal Average Accuracy of the model:’, round(Accuracy_Values.mean(),2))

# Plotting the feature importance for Top 10 most important columns

# There is no built-in method to get feature importance in KNN

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

# Logistic Regression

from sklearn.linear_model import LogisticRegression

# choose parameter Penalty=’l1′ or C=1

# choose different values for solver ‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’, ‘saga’

clf = LogisticRegression(C=10,penalty=‘l2’, solver=‘newton-cg’)

# Printing all the parameters of logistic regression

# print(clf)

# Creating the model on Training Data

LOG=clf.fit(X_train,y_train)

# Generating predictions on testing data

prediction=LOG.predict(X_test)

# Printing sample values of prediction in Testing data

TestingData=pd.DataFrame(data=X_test, columns=Predictors)

TestingData[‘Survived’]=y_test

TestingData[‘Predicted_Survived’]=prediction

print(TestingData.head())

# Measuring accuracy on Testing Data

from sklearn import metrics

print(metrics.classification_report(y_test, prediction))

print(metrics.confusion_matrix(prediction, y_test))

## Printing the Overall Accuracy of the model

F1_Score=metrics.f1_score(y_test, prediction, average=‘weighted’)

print(‘Accuracy of the model on Testing Sample Data:’, round(F1_Score,2))

## Importing cross validation function from sklearn

#from sklearn.model_selection import cross_val_score

## Running 10-Fold Cross validation on a given algorithm

## Passing full data X and y because the K-fold will split the data and automatically choose train/test

#Accuracy_Values=cross_val_score(LOG, X , y, cv=10, scoring=’f1_weighted’)

#print(‘nAccuracy values for 10-fold Cross Validation:n’,Accuracy_Values)

#print(‘nFinal Average Accuracy of the model:’, round(Accuracy_Values.mean(),2))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

# Decision Trees

from sklearn import tree

#choose from different tunable hyper parameters

clf = tree.DecisionTreeClassifier(max_depth=20,criterion=‘gini’)

# Printing all the parameters of Decision Trees

print(clf)

# Creating the model on Training Data

DTree=clf.fit(X_train,y_train)

prediction=DTree.predict(X_test)

# Measuring accuracy on Testing Data

from sklearn import metrics

print(metrics.classification_report(y_test, prediction))

print(metrics.confusion_matrix(y_test, prediction))

# Printing the Overall Accuracy of the model

F1_Score=metrics.f1_score(y_test, prediction, average=‘weighted’)

print(‘Accuracy of the model on Testing Sample Data:’, round(F1_Score,2))

# Plotting the feature importance for Top 10 most important columns

%matplotlib inline

feature_importances = pd.Series(DTree.feature_importances_, index=Predictors)

feature_importances.nlargest(10).plot(kind=‘barh’)

# Importing cross validation function from sklearn

#from sklearn.model_selection import cross_val_score

# Running 10-Fold Cross validation on a given algorithm

# Passing full data X and y because the K-fold will split the data and automatically choose train/test

#Accuracy_Values=cross_val_score(DTree, X , y, cv=10, scoring=’f1_weighted’)

#print(‘nAccuracy values for 10-fold Cross Validation:n’,Accuracy_Values)

#print(‘nFinal Average Accuracy of the model:’, round(Accuracy_Values.mean(),2))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

# Adaboost

from sklearn.ensemble import AdaBoostClassifier

from sklearn.tree import DecisionTreeClassifier

# Choosing Decision Tree with 1 level as the weak learner

DTC=DecisionTreeClassifier(max_depth=2)

clf = AdaBoostClassifier(n_estimators=20, base_estimator=DTC ,learning_rate=0.01)

# Printing all the parameters of Adaboost

print(clf)

# Creating the model on Training Data

AB=clf.fit(X_train,y_train)

prediction=AB.predict(X_test)

# Measuring accuracy on Testing Data

from sklearn import metrics

print(metrics.classification_report(y_test, prediction))

print(metrics.confusion_matrix(y_test, prediction))

# Printing the Overall Accuracy of the model

F1_Score=metrics.f1_score(y_test, prediction, average=‘weighted’)

print(‘Accuracy of the model on Testing Sample Data:’, round(F1_Score,2))

# Importing cross validation function from sklearn

#from sklearn.model_selection import cross_val_score

# Running 10-Fold Cross validation on a given algorithm

# Passing full data X and y because the K-fold will split the data and automatically choose train/test

#Accuracy_Values=cross_val_score(AB, X , y, cv=10, scoring=’f1_weighted’)

#print(‘nAccuracy values for 10-fold Cross Validation:n’,Accuracy_Values)

#print(‘nFinal Average Accuracy of the model:’, round(Accuracy_Values.mean(),2))

# Plotting the feature importance for Top 10 most important columns

#%matplotlib inline

#feature_importances = pd.Series(AB.feature_importances_, index=Predictors)

#feature_importances.nlargest(10).plot(kind=’barh’)

# Generating the Logistic model on full data

# This is the best performing model

clf = LogisticRegression(C=10,penalty=‘l2’, solver=‘newton-cg’)

FinalModel=clf.fit(X,y)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

# Defining a function which converts words into numeric vectors for prediction

def FunctionPredictUrgency(inpText):

    # Generating the Glove word vector embeddings

    X=FunctionText2Vec(inpText)

    #print(X)

    # If standardization/normalization was done on training

    # then the above X must also be converted to same platform

    # Generating the normalized values of X

    X=PredictorScalerFit.transform(X)

    # Generating the prediction using Naive Bayes model and returning

    Prediction=FinalModel.predict(X)

    Result=pd.DataFrame(data=inpText, columns=[‘Text’])

    Result[‘Prediction’]=Prediction

    return(Result)

# Calling the function

NewTicket=[«help to review the issue», «Please help to resolve system issue»]

FunctionPredictUrgency(inpText=NewTicket)