def knn_train_test(k, xTrain, yTrain, xTest, yTest):
"""
Given a specified k, train the knn model and predict
the labels of the test data. Returns the accuracy of
the resulting model.
Parameters
----------
k : int
The number of neighbors
xTrain : nd-array with shape n x d
Training data
yTrain : 1d array with shape n
Array of labels associated with training data.
xTest : nd-array with shape m x d
Test data
yTest : 1d array with shape m
Array of labels associated with test data.
Returns
-------
acc : float
The accuracy of the trained knn model on the test data
"""
model = Knn(k)
model.train(xTrain, yTrain['label'])
# predict the test dataset
yHatTest = model.predict(xTest)
return accuracy(yHatTest, yTest['label'])
class PublicApi():
def __init__(self):
self.app = flask.Flask(__name__)
CORS(self.app)
self.app.config["DEBUG"] = True
self.knn = Knn(3)
def start(self):
@self.app.route('/api/predict', methods=['POST'])
def api_id():
logging.info(request.args)
if 'radiant_score' in request.args and 'dire_score' in request.args and 'duration' in request.args:
radiant_score = int(request.args['radiant_score'])
dire_score = int(request.args['dire_score'])
duration = int(request.args['duration'])
self.knn.set_k(int(request.args['k']))
result = self.knn.predict([[radiant_score,dire_score,duration]])
logging.info(result[0])
text_result = ''
logging.error(self.knn.k)
if result[0] == 1:
text_result = 'Radiant wins!'
else:
text_result = 'Dire wins!'
self.knn.plot2D(radiant_score-dire_score,duration,text_result)
return str('{"result": \"'+text_result+'\"}')
else:
return "Missed a field"
self.app.run(host='0.0.0.0', port=8080)
def main():
col_names = [
'sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species'
]
iris = pd.read_csv('./iris.data', header=None, names=col_names)
iris_class = {'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2}
iris['species_num'] = [iris_class[i] for i in iris.species]
X = iris.drop(['species', 'species_num'], axis=1).to_numpy()
y = iris.species_num.to_numpy()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
kr = Knn(3)
# knn = KNeighborsClassifier(3)
# model = knn.fit(X_train, y_train)
kr.fit(X_train, y_train)
# p = model.predict(X_test)
p2 = kr.predict(X_test)
correct = 0
total = 0
for pred in zip(p2, y_test):
if pred[0] == pred[1]:
correct += 1
total += 1
print("acc :", correct / total)
def main():
# getting data
# returning set of features and set of labels
# for each 4-elements set of features there is one label assigned
# label is assgined based on characteristic resulting from features
iris = datasets.load_iris()
iris_df = pd.DataFrame(iris['data'], columns=iris['feature_names'])
X = iris_df.to_numpy()
y = iris['target']
iris_df['species'] = iris['target']
# print(X) # [[5.9 3. 4.2 1.5],...,[6. 2.2 4. 1. ],...,[6.1 2.9 4.7 1.4]]
# print(y) # [0,0,0,....,1,1,1,....,2,2,2,...]
plot_chart(iris_df)
# splitting data into training and testing subsets
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.2,
random_state=1234)
clf = Knn(k=3)
clf.fit(X_train,
y_train) # fitting model with features and corresponding labels
predictions = clf.predict(X_test)
print('Test samples shape: ' + str(X_test.shape)) # 120 features
print(X_test)
print('')
print('Predictions shape: ' + str(predictions.shape)) # 30 lables
print(predictions)
print('')
calculate_accuracy(predictions,
y_test) # comparing predicitons outcome with y_test
new_features = np.asarray([[6.2, 2.8, 5.7, 1.8]])
predicted_label = clf.predict(np.asarray(new_features))
print('')
print('New Features: ' + str(new_features))
print('Predicted label: ' + str(predicted_label))
print('Predicted speices: ' + str(species[int(predicted_label[0])]))
def test_k_5(self):
"""Test to compare our knn with Sklearn knn when k=5 and distance is euclidean"""
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
prediction = knn.predict(X_test)
knn2 = Knn(n_neighbors=5)
knn2.fit(X_train, y_train)
prediction2 = knn2.predict(X_test)
assert np.alltrue(
prediction == prediction2), "Error testing knn with k=5"
def test_distance_weight_2(self):
"""Test to compare our knn with Sklearn when k=5 and weights are the inverse of distance"""
knn = KNeighborsClassifier(n_neighbors=5, weights='distance')
knn.fit(X_train, y_train)
prediction = knn.predict(X_test)
knn2 = Knn(n_neighbors=5, weights='distance')
knn2.fit(X_train, y_train)
prediction2 = knn2.predict(X_test)
assert np.alltrue(prediction == prediction2
), "Error testing knn with k=5 and weights=distance"
def test_k_5_distance_minkowski(self):
"""Test to compare our knn with Sklearn knn when k=5 and distance is minkowski with p=3"""
knn = KNeighborsClassifier(n_neighbors=5, metric="minkowski", p=3)
knn.fit(X_train, y_train)
prediction = knn.predict(X_test)
knn2 = Knn(n_neighbors=5, metric="minkowski", p=3)
knn2.fit(X_train, y_train)
prediction2 = knn2.predict(X_test)
assert np.alltrue(prediction == prediction2
), "Error testing knn (minkowski) with k=5 and p=3"
def main():
X_train, y_train, X_test, y_test = load_mnist()
# data binarization
# for i in tqdm(range(len(x_train))):
# for j in range(28):
# for k in range(28):
# x_train[i][j][k] = 1 if x_train[i][j][k] > 177 else 0
# for i in tqdm(range(len(x_test))):
# for j in range(28):
# x_test[i][j].squeeze()
# for k in range(28):
# x_test[i][j][k] = 1 if x_test[i][j][k] > 177 else 0
# plot data samples
# plot = plt.subplots(nrows=4, ncols=5, sharex='all', sharey='all')[1].flatten()
# for i in range(20):
# img = x_train[i]
# plot[i].set_title(y_train[i])
# plot[i].imshow(img, cmap='Greys', interpolation='nearest')
# plot[0].set_xticks([])
# plot[0].set_yticks([])
# plt.tight_layout()
# plt.show()
knn = Knn()
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
correct = sum((y_test - y_pred) == 0)
print('==> correct:', correct)
print('==> total:', len(X_test))
print('==> acc:', correct / len(X_test))
# plot pred samples
fig = plt.subplots(nrows=4, ncols=5, sharex='all',
sharey='all')[1].flatten()
for i in range(20):
img = X_test[i]
fig[i].set_title(y_pred[i])
fig[i].imshow(img, cmap='Greys', interpolation='nearest')
fig[0].set_xticks([])
fig[0].set_yticks([])
plt.tight_layout()
plt.show()
def main():
X_train, y_train, X_test, y_test = load_mnist()
knn = Knn()
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
correct = sum((y_test - y_pred) == 0)
print('==> correct:', correct)
print('==> total:', len(X_test))
print('==> acc:', correct / len(X_test))
# plot pred samples
fig = plt.subplots(nrows=4, ncols=5, sharex='all',
sharey='all')[1].flatten()
for i in range(20):
img = X_test[i]
fig[i].set_title(y_pred[i])
fig[i].imshow(img, cmap='Greys', interpolation='nearest')
fig[0].set_xticks([])
fig[0].set_yticks([])
plt.tight_layout()
plt.show()
im = cv2.imread('6.png')
gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
# (2) threshold-inv and morph-open
th, threshed = cv2.threshold(gray, 100, 255, cv2.THRESH_OTSU|cv2.THRESH_BINARY_INV)
morphed = cv2.morphologyEx(threshed, cv2.MORPH_OPEN, np.ones((2,2)))
# (3) find and filter contours, then draw on src
cnts = cv2.findContours(morphed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]
for cnt in cnts:
x,y,w,h = bbox = cv2.boundingRect(cnt)
if h>28:
cv2.rectangle(cnt, (x,y), (x+w, y+h), (255, 0, 255), 1, cv2.LINE_AA)
roi = threshed[y:y+h,x:x+w]
cv2.imshow( "Display window", roi )
cv2.waitKey(0)
cv2.waitKey(0)
roi = center_image(roi)
cv2.imshow( "Display window", roi )
cv2.waitKey(0)
cv2.waitKey(0)
roismall = cv2.resize(roi,(28,28))
cv2.imshow( "Display window", roismall )
cv2.waitKey(0)
cv2.waitKey(0)
roismall = roismall.flatten()
print(knn.predict(roismall))
def get_accuracy(k, trainx, trainy, testx, testy):
knn = Knn(k)
knn.fit(trainx, trainy)
hyp = knn.predict(testx)
return accuracy_score(hyp, testy)
from knn import Knn
from vector import Vector
model = Knn()
with open('data/train.csv') as f:
for line in f:
data = line.strip().split(',')
vector = Vector(*map(float, data[:4]))
species = data[-1]
model.train(vector, species)
experiments = []
with open('data/test.csv') as f:
for line in f:
data = line.strip().split(',')
vector = Vector(*map(float, data[:4]))
species = data[-1]
prediction = model.predict(vector, 3)
experiments.append(species == prediction)
accuracy = sum(experiments) / len(experiments)
print('accuracy:', accuracy)
x_train_folds = []
y_train_folds = []
indices = np.array_split(np.arange(num_training),
indices_or_sections=num_folds)
for i in indices:
x_train_folds.append(x_train[i])
y_train_folds.append(y_train[i])
k_to_accuracies = {}
for k in k_choices:
acc = []
for i in range(num_folds):
x = x_train_folds[0:i] + x_train_folds[i + 1:]
x = np.concatenate(x, axis=0)
y = y_train_folds[0:i] + y_train_folds[i + 1:]
y = np.concatenate(y, axis=0)
test_x = np.array(x_train_folds[i])
test_y = np.array(y_train_folds[i])
classifier = Knn()
print(x)
classifier.fit(np.array(x), np.array(y))
y_pred = classifier.predict(k, 'M', test_x)
accuracy = np.mean(y_pred == test_y)
acc.append(accuracy)
k_to_accuracies[k] = acc
for k in sorted(k_to_accuracies):
for accuracy in k_to_accuracies[k]:
print('k=%d,accuracy=%f' % (k, accuracy))
class KnnDemoApp():
SIZE = 3
MARKS = ['X', 'O']
MODES = ['DATASET', 'PREDICCION']
def __init__(self):
self.points = []
self.labels = []
self.lines = []
self.knn = Knn()
self.root = Tk()
self.root.title("KNN Demo")
self.root.geometry('800x520')
self.root.resizable(False, False)
self.axis = Canvas(self.root, width=720, height=370)
self.axis.grid(column=0, row=0, columnspan=5)
self.axis.configure(bg='white')
self.axis.bind('<Button 1>', self.clickCallback)
self.axis_points = []
self.axis_predictions = []
self.debug_lbl = Label(self.root, text='Mensaje ==>')
self.debug_lbl.grid(column=0, row=1)
self.debug_msg = Label(self.root, text='-')
self.debug_msg.grid(column=0, row=1, columnspan=5)
self.init_btn = Button(self.root,
text='Reiniciar',
command=self.cleanHandler)
self.init_btn.grid(column=5, row=2)
self.class_lbl = Label(self.root, text='Clase ==>')
self.class_lbl.grid(column=0, row=2)
self.current_mark = self.MARKS[0]
self.class_btn = Button(self.root,
text=self.current_mark,
command=self.classButtonHandler)
self.class_btn.grid(column=1, row=2)
self.mode_lbl = Label(self.root, text='MODO ==>')
self.mode_lbl.grid(column=2, row=2)
self.current_mode = self.MODES[0]
self.mode_btn = Button(self.root,
text=self.current_mode,
command=self.modeButtonHandler)
self.mode_btn.grid(column=3, row=2)
self.k_lbl = Label(self.root, text='K ==>')
self.k_lbl.grid(column=2, row=3)
self.k_txt = Entry(self.root, width=2, text='3')
self.k_txt.grid(column=3, row=3)
self.root.mainloop()
def modeButtonHandler(self):
if self.mode_btn['text'] == self.MODES[0]:
self.mode_btn.config(text=self.MODES[1])
self.class_btn['state'] = DISABLED
self.current_mode = self.MODES[1]
else:
self.mode_btn.config(text=self.MODES[0])
self.class_btn['state'] = NORMAL
self.current_mode = self.MODES[0]
def classButtonHandler(self):
if self.class_btn['text'][-1] == self.MARKS[0]:
self.class_btn.config(text=self.MARKS[1])
self.current_mark = self.MARKS[1]
else:
self.class_btn.config(text=self.MARKS[0])
self.current_mark = self.MARKS[0]
def cleanHandler(self):
for p in self.axis_points:
self.axis.delete(p)
del self.axis_points[:]
for pr in self.axis_predictions:
self.axis.delete(pr)
del self.axis_predictions[:]
for l in self.lines:
self.axis.delete(l)
del self.lines[:]
self.points = []
self.labels = []
def clickCallback(self, event):
x = event.x
y = event.y
if self.current_mode == 'DATASET':
self.points.append((x, y))
self.labels.append(1 if self.current_mark == 'X' else 0)
self.axis_points.append(
self.axis.create_text(
x,
y,
text=self.current_mark,
fill='red' if self.current_mark == 'X' else 'dark green'))
else:
# predict knn
self.predictKnn(x, y)
print(event.x, event.y)
def predictKnn(self, x_ex, y_ex):
# clean previous lines
for l in self.lines:
self.axis.delete(l)
self.lines = []
# set up dataset
X = np.array(self.points)
y = np.array(self.labels)
example = np.array([x_ex, y_ex])
k = int(self.k_txt.get())
print(f'k: {k}')
# call Knn class
pred_label, neighbors, labels = self.knn.predict(X, y, example, k)
prediction = 'X' if pred_label == 1 else 'O'
# draw knn lines
for n, label in zip(neighbors, labels):
print(n, label)
line = self.axis.create_line(
n[0],
n[1],
x_ex,
y_ex,
fill='coral' if label == 1 else 'lime green')
self.lines.append(line)
# draw prediction
self.axis_predictions.append(
self.axis.create_text(
x_ex,
y_ex,
text=prediction,
fill='indian red' if pred_label == 1 else 'OliveDrab4',
font=('freemono', 14, 'bold')))
