import numpy as np
import pandas as pd
cd C:\Users\mobasher\Documents\Data
vstable = pd.read_csv("http://facweb.cs.depaul.edu/mobasher/classes/csc478/data/Video_Store_2.csv", index_col=0)
vstable.shape
vstable.head()
vs = vstable.reindex(np.random.permutation(vstable.index))
vs.head(10)
len(vs)
vs_names = vs.columns.values
vs_names
vs_target = vs.Incidentals
vs = pd.get_dummies(vs[['Gender','Income','Age','Rentals','Avg Per Visit','Genre']])
vs.head(10)
tpercent = 0.8
tsize = int(np.floor(tpercent * len(vs)))
vs_train = vs[:tsize]
vs_test = vs[tsize:]
print vs_train.shape
print vs_test.shape
np.set_printoptions(suppress=True, linewidth=120)
vs_train.head(10)
vs_test
vs_target_train = vs_target[0:int(tsize)]
vs_target_test = vs_target[int(tsize):len(vs)]
vs_target_train.head()
vs_target_test
from sklearn import preprocessing
min_max_scaler = preprocessing.MinMaxScaler()
min_max_scaler.fit(vs_train)
vs_train_norm = min_max_scaler.fit_transform(vs_train)
vs_test_norm = min_max_scaler.fit_transform(vs_test)
np.set_printoptions(precision=2, linewidth=100)
vs_train_norm[:10]
vs_target_train = np.array(vs_target_train)
vs_target_test = np.array(vs_target_test)
print vs_target_train
print "\n"
print vs_target_test
def knn_search(x, D, K, measure):
""" find K nearest neighbors of an instance x among the instances in D """
if measure == 0:
# euclidean distances from the other points
dists = np.sqrt(((D - x)**2).sum(axis=1))
elif measure == 1:
# first find the vector norm for each instance in D as wel as the norm for vector x
D_norm = np.array([np.linalg.norm(D[i]) for i in range(len(D))])
x_norm = np.linalg.norm(x)
# Compute Cosine: divide the dot product o x and each instance in D by the product of the two norms
sims = np.dot(D,x)/(D_norm * x_norm)
# The distance measure will be the inverse of Cosine similarity
dists = 1 - sims
idx = np.argsort(dists) # sorting
# return the indexes of K nearest neighbors
return idx[:K], dists
# Let's use vs_test_norm[0] as a test instance x and find its K nearest neighbors
neigh_idx, distances = knn_search(vs_test_norm[0], vs_train_norm, 5, 0)
vs_test.head(1)
print neigh_idx
print "\n"
vs_train.iloc[neigh_idx]
print distances[neigh_idx]
neigh_labels = vs_target_train[neigh_idx]
print neigh_labels
from collections import Counter
print Counter(neigh_labels)
Counter(neigh_labels).most_common(1)
dataSetSize = vs_train_norm.shape[0]
print dataSetSize
inX = vs_test_norm[0] # We'll use the first instance in the test data for this example
diffMat = np.tile(inX, (dataSetSize,1)) - vs_train_norm # Create dataSetSize copies of inX, as rows of a 2D matrix
# Compute a matrix of differences
print diffMat[:5,:]
sqDiffMat = diffMat**2 # The matrix of squared differences
sqDistances = sqDiffMat.sum(axis=1) # 1D array of the sum of squared differences (one element for each training instance)
distances = sqDistances**0.5 # and finally the matrix of Euclidean distances to inX
print distances
sortedDistIndicies = distances.argsort() # the indices of the training instances in increasing order of distance to inX
print sortedDistIndicies
classCount={}
k = 5 # We'll use the top 10 neighbors
for i in range(k):
voteIlabel = vs_target_train[sortedDistIndicies[i]]
classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1 # add to the count of the label or retun 1 for first occurrence
print sortedDistIndicies[i], voteIlabel, classCount[voteIlabel]
import operator
# Create a dictionary for the class labels with cumulative occurrences across the neighbors as values
# Dictionary will be ordered in decreasing order of the lable values (so the majority class label will
# be the first dictonary element)
sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
print sortedClassCount
print sortedClassCount[0][0]
from collections import Counter
k = 5 # We'll use the top 5 neighbors
vote = vs_target_train[sortedDistIndicies[0:k]]
maj_class = Counter(vote).most_common(1)
print vote
print maj_class
print "Class label for the classified istance: ", maj_class[0][0]
import kNN
numTestVecs = len(vs_target_test)
print numTestVecs
errorCount = 0.0
for i in range(numTestVecs):
# classify0 function uses Euclidean distance to find k nearest neighbors
classifierResult = kNN.classify0(vs_test_norm[i,:], vs_train_norm, vs_target_train, 3)
print "the classifier came back with: %s, the real answer is: %s" % (classifierResult, vs_target_test[i])
if (classifierResult != vs_target_test[i]): errorCount += 1.0
print "the total error rate is: %f" % (errorCount/float(numTestVecs))
reload(kNN)
errorCount = 0.0
for i in range(numTestVecs):
# classify1 function uses inverse of Cosine similarity to find k nearest neighbors
classifierResult2 = kNN.classify1(vs_test_norm[i,:], vs_train_norm, vs_target_train, 3)
print "the classifier came back with: %s, the real answer is: %s" % (classifierResult2, vs_target_test[i])
if (classifierResult2 != vs_target_test[i]): errorCount += 1.0
print "the total error rate is: %f" % (errorCount/float(numTestVecs))