In this example, we will explore the use of various classifiers from the scikit-learn package. Again, we'll use the modified Video Store data.¶
In [53]:
import numpy as np
import pandas as pd
In [2]:
vstable = pd.read_csv("http://facweb.cs.depaul.edu/mobasher/classes/csc478/data/Video_Store_2.csv", index_col=0)
vstable.shape
Out[2]:
In [49]:
vstable.head()
Out[49]:
Let's separate the target attribute and the attributes used for model training¶
In [4]:
vs_records = vstable[['Gender','Income','Age','Rentals','Avg Per Visit','Genre']]
vs_records.head()
Out[4]:
In [5]:
vs_target = vstable.Incidentals
vs_target.head()
Out[5]:
Next, we use Pandas "get_dummies" function to create dummy variables.¶
In [6]:
vs_matrix = pd.get_dummies(vs_records[['Gender','Income','Age','Rentals','Avg Per Visit','Genre']])
vs_matrix.head(10)
Out[6]:
Next, we divide the data into randomized training and test partitions (note that the same split should also be perfromed on the target attribute). The easiest way to do this is to use the "train_test_split" module of "sklearn.cross_validation".¶
In [7]:
from sklearn.model_selection import train_test_split
vs_train, vs_test, vs_target_train, vs_target_test = train_test_split(vs_matrix, vs_target, test_size=0.2, random_state=33)
print(vs_test.shape)
vs_test[0:5]
Out[7]:
In [8]:
print(vs_train.shape)
vs_train[0:5]
Out[8]:
Performing min-max normalization to rescale numeric attributes.¶
In [9]:
from sklearn import preprocessing
In [10]:
min_max_scaler = preprocessing.MinMaxScaler().fit(vs_train)
vs_train_norm = min_max_scaler.transform(vs_train)
vs_train_norm = pd.DataFrame(vs_train_norm, columns=vs_train.columns, index=vs_train.index)
vs_test_norm = min_max_scaler.transform(vs_test)
vs_test_norm = pd.DataFrame(vs_test_norm, columns=vs_test.columns, index=vs_test.index)
In [11]:
# np.set_printoptions(precision=2, linewidth=80, suppress=True)
vs_train_norm.head()
Out[11]:
In [12]:
vs_test_norm.head()
Out[12]:
We will use the KNN, decision tree, and naive Bayes classifiers from sklearn.¶
In [13]:
from sklearn import neighbors, tree, naive_bayes
First, we'll use KNN classifer. You can vary K and monitor the accuracy metrics (see below) to find the best value.¶
In [14]:
n_neighbors = 5
knnclf = neighbors.KNeighborsClassifier(n_neighbors, weights='distance')
knnclf.fit(vs_train_norm, vs_target_train)
Out[14]:
Next, we call the predict function on the test intances to produce the predicted classes.¶
In [15]:
knnpreds_test = knnclf.predict(vs_test_norm)
In [16]:
print(knnpreds_test)
scikit-learn has various modules that can be used to evaluate classifier accuracy¶
In [17]:
from sklearn.metrics import classification_report
In [18]:
print(classification_report(vs_target_test, knnpreds_test))
In [19]:
from sklearn.metrics import confusion_matrix
In [20]:
knncm = confusion_matrix(vs_target_test, knnpreds_test)
print(knncm)
We can also compute the average accuracy score across the test instances¶
In [21]:
print(knnclf.score(vs_test_norm, vs_target_test))
This can be compared to the performance on the training data itself (to check for over- or under-fitting)¶
In [22]:
print(knnclf.score(vs_train_norm, vs_target_train))
Next, let's use a decision tree classifier:¶
In [23]:
treeclf = tree.DecisionTreeClassifier(criterion='entropy', min_samples_split=3)
In [24]:
treeclf = treeclf.fit(vs_train, vs_target_train)
In [25]:
treepreds_test = treeclf.predict(vs_test)
print(treepreds_test)
In [26]:
print(treeclf.score(vs_test, vs_target_test))
In [27]:
print(treeclf.score(vs_train, vs_target_train))
In [28]:
print(classification_report(vs_target_test, treepreds_test))
In [29]:
treecm = confusion_matrix(vs_target_test, treepreds_test)
print(treecm)
We can actually plot the confusion matrix for better visualization:¶
In [30]:
import pylab as plt
%matplotlib inline
plt.matshow(treecm)
plt.title('Confusion matrix')
plt.colorbar()
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()
Now, let's try the (Gaussian) naive Bayes classifier:¶
In [38]:
nbclf = naive_bayes.GaussianNB()
nbclf = nbclf.fit(vs_train, vs_target_train)
nbpreds_test = nbclf.predict(vs_test)
print(nbpreds_test)
In [39]:
print(nbclf.score(vs_train, vs_target_train))
In [40]:
print(nbclf.score(vs_test, vs_target_test))
Finally, let's try linear discriminant analysis:¶
In [42]:
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
ldclf = LinearDiscriminantAnalysis()
ldclf = ldclf.fit(vs_train, vs_target_train)
ldpreds_test = ldclf.predict(vs_test)
print(ldpreds_test)
In [43]:
print(ldclf.score(vs_train, vs_target_train))
In [44]:
print(ldclf.score(vs_test, vs_target_test))
Next, let's see how we can use the cross-validation module from scikit-learn. This allows for n-fold cross validation without the necessity to split the data set manually.¶
In [46]:
from sklearn.model_selection import cross_val_score
In [47]:
cv_scores = cross_val_score(treeclf, vs_matrix, vs_target, cv=5)
print(cv_scores)
In [48]:
print("Overall Accuracy: %0.2f (+/- %0.2f)" % (cv_scores.mean(), cv_scores.std() * 2))
Visualizing the decision tree¶
In [44]:
from sklearn.tree import export_graphviz
from IPython.display import SVG
from graphviz import Source
from IPython.display import display
tree = export_graphviz(treeclf, out_file=None, feature_names=vs_train.columns, class_names=['No','Yes'])
graph = Source(tree)
In [45]:
display(SVG(graph.pipe(format='svg')))
In [50]:
tree = export_graphviz(treeclf,out_file='tree.dot', feature_names=vs_train.columns, class_names=['No','Yes'])
import graphviz
with open("tree.dot") as f:
dot_graph = f.read()
graphviz.Source(dot_graph, format="png")
Out[50]:
Alternatively, you can use GraphViz or some other tool outside Jupyter environment to convert the dot file into an image file (e.g., a .png file) and save it to a local directory. Then, the image can be displayed in Jupyter as follows.¶
-and-save-it-to-a-local-directory.-Then,-the-image-can-be-displayed-in-Jupyter-as-follows.){kind=link}
In [51]:
system(dot -Tpng tree.dot -o dtree.png)
Out[51]:
In [52]:
from IPython.display import Image
Image(filename='dtree.png', width=900)
Out[52]:
In [ ]: