def test__predict_with_tans_fun(self):
X = array([[2, 4], [6, 8]])
Y = array(['a', 'b'])
knn = KNN(trans_fun=KNN.STD_TRANS)
knn.fit(X, Y)
self.assertEqual(knn.predict(array([4, 5]), 1), 'a')
self.assertEqual(knn.predict(array([5, 6]), 1), 'b')
def test__predict_with_tans_fun(self):
X = array([[2, 4], [6, 8]])
Y = array(['a','b'])
knn = KNN(trans_fun = KNN.STD_TRANS)
knn.fit(X,Y)
self.assertEqual(knn.predict(array([4,5]), 1), 'a')
self.assertEqual(knn.predict(array([5,6]), 1), 'b')
def test_basic_predict(self):
'''全部默认状态使用KNN'''
X = array([[1,2],[1.5,3],[1.3,2.5],[4,7],[6,6],[5,8]])
Y = array(['a','c','a','b','b','a'])
knn = KNN().fit(X,Y)
self.assertEqual(knn.predict(array([2,2]), 3),'a')
self.assertEqual(knn.predict(array([5,5]), 3),'b')
self.assertEqual(knn.predict(array([5,5]), 6),'a')
self.assertEqual(knn.predict(array([1,5]), 10),'a')
def test_basic_predict(self):
'''全部默认状态使用KNN'''
X = array([[1, 2], [1.5, 3], [1.3, 2.5], [4, 7], [6, 6], [5, 8]])
Y = array(['a', 'c', 'a', 'b', 'b', 'a'])
knn = KNN().fit(X, Y)
self.assertEqual(knn.predict(array([2, 2]), 3), 'a')
self.assertEqual(knn.predict(array([5, 5]), 3), 'b')
self.assertEqual(knn.predict(array([5, 5]), 6), 'a')
self.assertEqual(knn.predict(array([1, 5]), 10), 'a')
def process(self, event):
"""
event.event_type
'modified' | 'created' | 'moved' | 'deleted'
event.is_directory
True | False
event.src_path
path/to/observed/file
"""
# the file will be processed there
print(event.src_path, event.event_type) # print now only for degug
if (event.event_type == "modified"):
picture_path = "./knn/test/Unknown.jpeg"
# full_file_path = os.path.join("knn/test", picture_path)
# print(full_file_path)
print("Looking for faces in {}".format(picture_path))
# Find all people in the image using a trained classifier model
# Note: You can pass in either a classifier file name or a classifier model instance
predictions = knn.predict(picture_path, model_path="trained_knn_model.clf")
if len(predictions) > 0:
# Print results on the console
for name, (top, right, bottom, left) in predictions:
print("- Found {} at ({}, {})".format(name, left, top))
r = requests.post('http://192.168.1.101:1880/find-face', data = {'_id':name})
print("call done")
else:
r = requests.post('http://192.168.1.101:1880/no-face')
def train_plot(features, labels):
y0, y1 = features[:, 2].min() * .9, features[:, 2].max() * 1.1
x0, x1 = features[:, 0].min() * .9, features[:, 0].max() * 1.1
X = np.linspace(x0, x1, 100)
Y = np.linspace(y0, y1, 100)
X, Y = np.meshgrid(X, Y)
model = fit_model(1, features[:, (0, 2)], np.array(labels))
C = predict(
np.vstack([X.ravel(), Y.ravel()]).T, model).reshape(X.shape)
if COLOUR_FIGURE:
cmap = ListedColormap([(1., .6, .6), (.6, 1., .6), (.6, .6, 1.)])
else:
cmap = ListedColormap([(1., 1., 1.), (.2, .2, .2), (.6, .6, .6)])
plt.xlim(x0, x1)
plt.ylim(y0, y1)
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[2])
plt.pcolormesh(X, Y, C, cmap=cmap)
if COLOUR_FIGURE:
cmap = ListedColormap([(1., .0, .0), (.0, 1., .0), (.0, .0, 1.)])
plt.scatter(features[:, 0], features[:, 2], c=labels, cmap=cmap)
else:
for lab, ma in zip(range(3), "Do^"):
plt.plot(features[labels == lab, 0], features[
labels == lab, 2], ma, c=(1., 1., 1.))
def main():
# load and normalize the data
data, labels = load_data(
'veh-prime.arff',
filterFn=lambda line: len(line.strip()) > 0 and line[0] != '@',
labelFn=lambda label: {
'car': 1.0,
'noncar': 0.0
}[label])
data = zscore(data)
n = data.shape[DATA_AXIS]
d = data.shape[FEATURE_AXIS]
# score each feature in the data
scores = np.zeros(d)
for j in range(d):
scores[j] = abs(pcc(data[:, j], labels))
feature_indices = np.flipud(scores.argsort())
for index in feature_indices:
print "f=%d,|r|=%f" % (index + 1, scores[index])
print
# try adding features in order of score
data_indices = [x for x in range(data.shape[DATA_AXIS])]
for m in range(1, d + 1):
correct = 0.0
subdata = data[:, feature_indices[:m]]
for i in range(n):
indices = data_indices[:i] + data_indices[i + 1:]
predicted = predict(subdata[None, i], subdata[indices],
labels[indices], k)
if predicted[0] == labels[i]:
correct += 1
print "m=%d,accuracy=%f" % (m, correct / n)
print
def k_fold_cross_val(input_data, K, k):
"""Splits the input data set into a k number of sections/folds where each fold is used as a testing set
and the rest of input data are used as training set.
Returns a mean accuracy of predicting model used.
Prameters:
k (int): Number of folds \n
K (int): Number of nearest neighbors
"""
k_fold_sets = k_fold_data_split(input_data, k)
all_accuracy = []
for k_set in k_fold_sets:
test_set = k_set[0]
train_set = k_set[1]
all_predictions = []
for x in range(len(test_set)):
neighbors = k_neighbors(test_set[x][:-1], train_set, K)
prediction = predict(neighbors)
all_predictions.append(prediction)
accuracy = accuracy_score(test_set, all_predictions)
all_accuracy.append(accuracy)
mean_accuracy = sum(all_accuracy) / len(all_accuracy)
return mean_accuracy
def kNN_test(X_train, X_test, y_train, y_test, distance = "euclidean",k=3):
output_classes = []
for i in range(0, X_test.shape[0]):
output = knn.train(X_train, X_test[i],distance,k)
predictedClass = knn.predict(output, y_train)
output_classes.append(predictedClass)
return output_classes
def plot_decision(features, labels):
'''KNN에 대한 결정선 그리기
Parameters
----------
features : ndarray
labels : sequence
Returns
-------
fig : Matplotlib Figure
ax : Matplotlib Axes
'''
y0, y1 = features[:, 2].min() * .9, features[:, 2].max() * 1.1
x0, x1 = features[:, 0].min() * .9, features[:, 0].max() * 1.1
X = np.linspace(x0, x1, 100)
Y = np.linspace(y0, y1, 100)
X, Y = np.meshgrid(X, Y)
model = fit_model(1, features[:, (0, 2)], np.array(labels))
## 원본 소스 오류
# C = predict(
# np.vstack([X.ravel(), Y.ravel()]).T, model).reshape(X.shape)
C = predict(
model, np.vstack([X.ravel(), Y.ravel()]).T).reshape(X.shape)
def run_with_sample() -> None:
total_point = 0.0
number_test = 100
for i in range(0, number_test):
data = get_train_data()
samples: List[FrameOrSeries] = []
data[0], sample = get_sample_data(data[0], 25) # type: FrameOrSeries
samples.append(sample)
data[1], sample = get_sample_data(data[1], 25) # type: FrameOrSeries
samples.append(sample)
knn.clear()
knn.fit(data[0].values.tolist(), data[1].values.tolist())
point = 0
total = 0
for k in range(0, len(samples)):
for s in samples[k].values:
if knn.predict(s.tolist(), k=3) == k:
point += 1
total += 1
print('point: ' + str(point))
print('total: ' + str(total))
total_point += float(point / total * 100)
print(point / total * 100)
print('total_point: ' + str(total_point / number_test))
def train_plot(features, labels):
y0, y1 = features[:, 2].min() * .9, features[:, 2].max() * 1.1
x0, x1 = features[:, 0].min() * .9, features[:, 0].max() * 1.1
X = np.linspace(x0, x1, 100)
Y = np.linspace(y0, y1, 100)
X, Y = np.meshgrid(X, Y)
model = fit_model(1, features[:, (0, 2)], np.array(labels))
C = predict(np.vstack([X.ravel(), Y.ravel()]).T, model).reshape(X.shape)
if COLOUR_FIGURE:
cmap = ListedColormap([(1., .6, .6), (.6, 1., .6), (.6, .6, 1.)])
else:
cmap = ListedColormap([(1., 1., 1.), (.2, .2, .2), (.6, .6, .6)])
plt.xlim(x0, x1)
plt.ylim(y0, y1)
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[2])
plt.pcolormesh(X, Y, C, cmap=cmap)
if COLOUR_FIGURE:
cmap = ListedColormap([(1., .0, .0), (.0, 1., .0), (.0, .0, 1.)])
plt.scatter(features[:, 0], features[:, 2], c=labels, cmap=cmap)
else:
for lab, ma in zip(range(3), "Do^"):
plt.plot(features[labels == lab, 0],
features[labels == lab, 2],
ma,
c=(1., 1., 1.))
def draw_box_on_image(num_hands_detect, score_thresh, scores, boxes, im_width,
im_height, image_np):
# print(num_hands_detect)
hands = ['None', 'None']
for i in range(num_hands_detect):
if (scores[i] > score_thresh):
(left, right, top, bottom) = (boxes[i][1] * im_width,
boxes[i][3] * im_width,
boxes[i][0] * im_height,
boxes[i][2] * im_height)
p1 = (int(left), int(top))
p2 = (int(right), int(bottom))
cv2.rectangle(image_np, p1, p2, (77, 255, 9), 2, 2)
test = image_np[int(top): int(bottom), int(left):int(right)]
test = cv2.resize(test, (128, 128))
test = cv2.cvtColor(test, cv2.COLOR_RGB2GRAY)
label = predict(test,lda)
# font = cv2.FONT_HERSHEY_SIMPLEX
if i == 0:
# cv2.putText(image_np, str(label), (100, 100), font, 1,
# (255, 0, 0), 2, cv2.LINE_AA)
hands[0] = str(label[0])
if i == 1:
# cv2.putText(image_np, str(label), (150, 100), font, 1,
# (255, 0, 0), 2, cv2.LINE_AA)
hands[1] = str(label[0])
return hands
def predict_thread(face_algorithm, model_name, image_file):
# https://discuss.streamlit.io/t/attributeerror-thread-local-object-has-no-attribute-value/574/3
import keras.backend.tensorflow_backend as tb
tb._SYMBOLIC_SCOPE.value = True
return knn.predict(image_file,
model_path=model_name,
distance_threshold=ALGORITHM[face_algorithm]['distance_threshold'],
face_algorithm=face_algorithm)
def run() -> None:
test_data = get_test_data()
data = get_train_data()
knn.clear()
knn.fit(data[0].values.tolist(), data[1].values.tolist())
test_list: list = test_data.values.tolist()
results = []
for i in test_list: # type: list
id = i[:1][0]
del i[0]
results.append([int(id), knn.predict(i)])
write_to_csv(results)
def main():
# load and normalize the data
data, labels = load_data(
'veh-prime.arff',
filterFn = lambda line: len(line.strip()) > 0 and line[0] != '@',
labelFn = lambda label: {'car': 1.0, 'noncar': 0.0}[label]
)
data = zscore(data)
n = data.shape[DATA_AXIS]
d = data.shape[FEATURE_AXIS]
# initialize set of unused features
data_indices = [x for x in range(data.shape[DATA_AXIS])]
candidates = set([j for j in range(d)])
features = []
best_accr = 0.0
# search for the best feature to add next
while len(candidates) > 0:
best_candidate = None
for candidate in candidates:
test_features = features + [candidate]
subdata = data[:,test_features]
# run LOOCV and find average accuracy
correct = 0.0
for i in range(n):
indices = data_indices[:i] + data_indices[i+1:]
predicted = predict(
subdata[None,i],
subdata[indices],
labels[indices], k
)
if predicted[0] == labels[i]:
correct += 1
accr = correct / n
# update best accuracy if better
if (accr > best_accr):
best_accr = accr
best_candidate = candidate
# update set of features or break if none found
if best_candidate is None:
break
else:
candidates.remove(best_candidate)
features.append(best_candidate)
pretty_features = [index + 1 for index in features]
msg = "features=%s,accuracy=%f"
print msg % (pretty_features, best_accr)
print
def gridsearchKNN2(parametros, xTrain, yTrain, Xval, yVal):
f1Metric = []
par = []
for params in ParameterGrid(parametros):
knn = KNeighborsClassifier(n_neighbors=params['n_neighbors'],
metric=params['metric'])
knn.fit(xTrain, yTrain)
pred = knn.predict(Xval)
f1 = metrics.f1_score(yVal, pred, average='weighted')
print(f1)
f1Metric.append(f1)
par.append(params)
return par[f1Metric.index(max(f1Metric))]
def bruteForceBestHyperParams(diagnosis):
hyperParams = []
for sizes in [s * 0.1 for s in range(4, 9)]:
for k in [k for k in range(1, 15)]:
trainingData, testingData = crossValidate(dataset, trainSize=sizes)
correct = 0
total = len(testingData[diagnosis])
for i in range(total):
example = testingData[diagnosis][i]
if knn.predict(trainingData, example, k=k) == diagnosis:
correct += 1
hyperParams.append((100 * correct / total, sizes, k))
hyperParams.sort(key=lambda t: t[0])
return hyperParams
def plot_decision(features, labels):
'''Plots decision boundary for KNN
Parameters
----------
features : ndarray
labels : sequence
Returns
-------
fig : Matplotlib Figure
ax : Matplotlib Axes
'''
y0, y1 = features[:, 2].min() * .9, features[:, 2].max() * 1.1
x0, x1 = features[:, 0].min() * .9, features[:, 0].max() * 1.1
X = np.linspace(x0, x1, 100)
Y = np.linspace(y0, y1, 100)
X, Y = np.meshgrid(X, Y)
model = fit_model(1, features[:, (0, 2)], np.array(labels))
C = predict(model, np.vstack([X.ravel(), Y.ravel()]).T).reshape(X.shape)
if COLOUR_FIGURE:
cmap = ListedColormap([(1., .6, .6), (.6, 1., .6), (.6, .6, 1.)])
else:
cmap = ListedColormap([(1., 1., 1.), (.2, .2, .2), (.6, .6, .6)])
fig, ax = plt.subplots()
ax.set_xlim(x0, x1)
ax.set_ylim(y0, y1)
ax.set_xlabel(feature_names[0])
ax.set_ylabel(feature_names[2])
ax.pcolormesh(X, Y, C, cmap=cmap)
if COLOUR_FIGURE:
cmap = ListedColormap([(1., .0, .0), (.0, 1., .0), (.0, .0, 1.)])
ax.scatter(features[:, 0], features[:, 2], c=labels, cmap=cmap)
else:
for lab, ma in zip(range(3), "Do^"):
ax.plot(features[labels == lab, 0],
features[labels == lab, 2],
ma,
c=(1., 1., 1.))
return fig, ax
def evaluate(evaluateDir, modelPath):
right = 0
wrong = 0
# Loop through each person in the training set
for classDir in os.listdir(evaluateDir):
if not os.path.isdir(os.path.join(evaluateDir, classDir)):
continue
# Loop through each training image for the current person
for imgPath in image_files_in_folder(
os.path.join(evaluateDir, classDir)
):
faces = predict(imgPath, model_path=modelPath)
if faces:
# There is only 1 face
face = faces[0]
face_name = face[0]
if face_name == classDir:
right = right + 1
else:
wrong = wrong + 1
return right / (right + wrong) * 100
def plot_decision(features, labels):
'''Plots decision boundary for KNN
Parameters
----------
features : ndarray
labels : sequence
Returns
-------
fig : Matplotlib Figure
ax : Matplotlib Axes
'''
y0, y1 = features[:, 2].min() * .9, features[:, 2].max() * 1.1
x0, x1 = features[:, 0].min() * .9, features[:, 0].max() * 1.1
X = np.linspace(x0, x1, 100)
Y = np.linspace(y0, y1, 100)
X, Y = np.meshgrid(X, Y)
model = fit_model(1, features[:, (0, 2)], np.array(labels))
C = predict(
model, np.vstack([X.ravel(), Y.ravel()]).T).reshape(X.shape)
if COLOUR_FIGURE:
cmap = ListedColormap([(1., .6, .6), (.6, 1., .6), (.6, .6, 1.)])
else:
cmap = ListedColormap([(1., 1., 1.), (.2, .2, .2), (.6, .6, .6)])
fig,ax = plt.subplots()
ax.set_xlim(x0, x1)
ax.set_ylim(y0, y1)
ax.set_xlabel(feature_names[0])
ax.set_ylabel(feature_names[2])
ax.pcolormesh(X, Y, C, cmap=cmap)
if COLOUR_FIGURE:
cmap = ListedColormap([(1., .0, .0), (.0, 1., .0), (.0, .0, 1.)])
ax.scatter(features[:, 0], features[:, 2], c=labels, cmap=cmap)
else:
for lab, ma in zip(range(3), "Do^"):
ax.plot(features[labels == lab, 0], features[
labels == lab, 2], ma, c=(1., 1., 1.))
return fig,ax
def result(id):
print("id:", id)
predict_value = knn.predict(db_func.read_one_data(id))
db_func.update_predict_value(id, predict_value)
return Response(str(predict_value))
test_data_set = []
train_data_set = []
n = int((len(titanik_train_set) - 1) * 0.3)
idx_test = random.sample(range(1, len(titanik_train_set)-1), n)
for idx in range(1, len(titanik_train_set)-1):
if idx in idx_test:
test_data_set.append(titanik_train_set[idx])
else:
train_data_set.append(titanik_train_set[idx])
for K in range(1, 31):
all_predictions = []
k_accuracy = []
for x in range(len(test_data_set)):
neighbors = k_neighbors(test_data_set[x][:-1], train_data_set, K)
prediction = predict(neighbors)
all_predictions.append(prediction)
accuracy = accuracy_score(test_data_set, all_predictions)
k_accuracy.append(accuracy)
print(f"K = {K:<8} accuracy: {accuracy} % ")
print(sum(k_accuracy)/len(k_accuracy))
print()
k_accuracy = []
for K in range(1, 31):
accuracy = round(k_fold_cross_val(titanik_train_set, K, 10), 2)
k_accuracy.append(accuracy)
print(f"K = {K:<8} Mean accuracy: {accuracy} % ")
print(sum(k_accuracy)/len(k_accuracy))
print()
print(feat_vec.shape)
feat_vec = np.concatenate((feat_vec[:, :1], add / np.mean(add)), axis=1)
accuracy = 0
for i in range(0, 100):
np.random.shuffle(feat_vec)
sli = 0.8 * len(feat_vec)
X = np.split(feat_vec, [int(sli)], axis=0)
y_train = np.transpose(X[0][:, :1])[0]
X_train = X[0][:, 1:]
y_test = np.transpose(X[1][:, :1])[0]
X_test = X[1][:, 1:]
knn = neighbors.KNeighborsClassifier(n_neighbors=4,
weights='distance',
metric='manhattan')
knn.fit(X_train, y_train)
test = knn.predict(X_test)
acc = test == y_test
accuracy += acc.sum() / len(acc)
print(accuracy / 100)
print("Enter the movieids:")
for j in range(0, no_movies):
movieid=int(raw_input())
movie_label[movieid]=label
'''
f = open('input_task5.txt', 'rb')
labels = []
for line in f:
mov = int(line.split(" ")[0])
lab = line.split(" ")[1].rstrip('\n')
labels.append(lab)
movie_label[mov] = lab
print "Training set read from file: "
print movie_label
no_labels = len(set(labels))
tot_movies = len(movie_label)
if mode == 1:
print "Enter r for R-Nearest Neighbours: "
k = int(raw_input())
knn.predict(movie_label, k)
if mode == 2:
print "Running SVM:"
svm.multiclassSVM(movie_label, no_labels, tot_movies)
if mode == 3:
print "Running Decision trees:"
dtree.multiclassTree(movie_label, no_labels, tot_movies)
model_name += ALGORITHM[face_algorithm]['ext']
if os.path.isdir(test_thing):
images = os.listdir(test_thing)
images = [os.path.join(test_thing, i) for i in images]
else:
images = [ test_thing ]
# Using the trained classifier, make predictions for unknown images
for image_file in images:
print("Looking for faces in {}".format(image_file))
# Find all people in the image using a trained classifier model
# Note: You can pass in either a classifier file name or a classifier model instance
start_time = datetime.now()
predictions = knn.predict(image_file,
model_path=model_name,
distance_threshold=ALGORITHM[face_algorithm]['distance_threshold'],
face_algorithm=face_algorithm)
print('[Time taken: {!s}]'.format(datetime.now() - start_time))
# Print results on the console
for name, (top, right, bottom, left), distance, count in predictions:
print("- Found {} at ({}, {}), distance={}, count={}".format(name, left, top, distance, count))
if len(predictions)==0:
print('Face not found!')
# Display results overlaid on an image
#knn.show_prediction_labels_on_image(image_file, predictions)
actual_value_2 = 2
new_id_2 = db_func.insert_data(test_data_2)
assert (new_id_2 == 2)
assert (db_func.update_actual_value(new_id_2, actual_value_2))
data_set = knn.construct_data_set()
assert (len(data_set) == 2)
v = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0])
M = knn.generate_M(data_set)
assert (np.array_equal(
M, np.array([[1, 1, 0, 0, 1, 0, 1, 1, 1], [1, 1, 1, 0, 1, 0, 1, 1,
1]])))
real_mse = np.array([2 / 3, 7 / 9])
assert (np.array_equal(knn.calculate_mse(v, M), real_mse))
print("generate_M and calculate_mse test PASS")
# Insert again test_data and test_data_2 to check robustness of predict
new_id_3 = db_func.insert_data(test_data)
db_func.update_actual_value(new_id_3, actual_value)
new_id_4 = db_func.insert_data(test_data_2)
db_func.update_actual_value(new_id_4, actual_value_2)
predict_1 = knn.predict(test_data, test=True)
assert (predict_1 == (1, 2))
predict_2 = knn.predict(test_data_2, test=True)
assert (predict_2 == (2, 2))
print("predict test PASS")
import EEG_load
# main - train&test
#dataset = EEG_load.load_data("s16",20)
dataset = EEG_feature_extraction.generate_feature_data("s16", 20)
X = dataset['X_train']
y = dataset['Y_train']
Xtest = dataset['X_test']
ytest = dataset['Y_test']
k = [1, 3, 10]
for i in range(3):
model = knn.fit(X, y, k[i])
y_pred = knn.predict(model, X)
train_error = np.mean(y_pred.flatten() != y)
print("The current training error is: %r" % train_error)
y_pred = knn.predict(model, Xtest)
test_error = np.mean(y_pred.flatten() != ytest)
print("The current test error is: %r" % test_error)
# part 3: plot classification boundaries for k=1 (use utils.plot_2dclassifier)
model1 = knn.fit(X, y, k[2])
utils.plot_2dclassifier(model1, X, y)
#plt.show()
# save figure
fname = "../s16-c20-mean.png"
plt.savefig(fname)
])
io_args = parser.parse_args()
question = io_args.question
if question == '1.1':
dataset = utils.load_dataset('citiesSmall')
X = dataset['X']
y = dataset['y']
Xtest = dataset['Xtest']
ytest = dataset['ytest']
#model = knn.fit(X,y,3)
#model = knn.fit(X,y,1)
model = knn.fit(X, y, 10)
y_pred_tr = knn.predict(model, X)
y_pred_te = knn.predict(model, Xtest)
trerror = utils.classification_error(y_pred_tr, y)
teerror = utils.classification_error(y_pred_te, ytest)
print(trerror)
print(teerror)
utils.plot_2dclassifier(model, Xtest, ytest)
# part 1: implement knn.predict
# part 2: print training and test errors for k=1,3,10 (use utils.classification_error)
# part 3: plot classification boundaries for k=1 (use utils.plot_2dclassifier)
if question == '1.2':
dataset = utils.load_dataset('citiesBig1')
axis=0,
ignore_index=True)
y_1 = pd.concat([y_train[:start], y_train[end:]],
axis=0,
ignore_index=True)
X_2 = X_train[start:end]
#y_2 = y_train[start:end]
t1 = xgb.predict(X_1, y_1, X_2)
t2 = gradientBoosting.predict(X_1, y_1, X_2)
t3 = lightgbm2.predict(X_1, y_1, X_2)
t4 = randomForest.predict(X_1, y_1, X_2)
t5 = ridge.predict(X_1, y_1, X_2)
t6 = lasso.predict(X_1, y_1, X_2)
t7 = elastic.predict(X_1, y_1, X_2)
t8 = knn.predict(X_1, y_1, X_2)
t9 = MLPRegressor.predict(X_1, y_1, X_2)
#t10 = kernelridge.predict(X_1, y_1, X_2)
#t11 = kernelridge2.predict(X_1, y_1, X_2)
if i == 0:
X_transfer = np.concatenate((t1, t2, t3, t4, t5, t6, t7, t8, t9),
axis=1)
else:
X_temp = np.concatenate((t1, t2, t3, t4, t5, t6, t7, t8, t9), axis=1)
X_transfer = np.concatenate((X_transfer, X_temp), axis=0)
i += 1
t1 = xgb.predict(X_train, y_train, X_test)
t2 = gradientBoosting.predict(X_train, y_train, X_test)
t3 = lightgbm2.predict(X_train, y_train, X_test)
# 201420907_homework1 main.py
import knn
import numpy as np
train_data = np.loadtxt(fname='./digits_data/digits_train.csv', delimiter=',', dtype='float64') # Training Set load
X_train, Y_train = knn.train(train_data) # KNN don't need training step. So, knn.train(data) just load train_data.
test_data = np.loadtxt(fname='./digits_data/digits_test.csv', delimiter=',', dtype='float64') # Test Set load
X_test = np.array(test_data[:, 1:], dtype='float64') # Features of Test set data
Y_test = np.array(test_data[:, 0], dtype='int64') # Labels of Test set data
# knn.predict(train_x, train_y, test_x, k)
knn_Y_pred = knn.predict(X_train, Y_train, X_test, 1) # k means n of neighbors
# Calculation of TP, TN, FP, FN
TP = np.zeros(10) # True Positive (Correct Predicted target class)
TN = np.zeros(10) # True Negative (Correct Predicted not-target class)
FP = np.zeros(10) # False Positive (Incorrect Predicted target class)
FN = np.zeros(10) # False Negative (Incorrect Predicted non-target class)
Confusion_matrix = np.zeros((10, 10), dtype='int64')
for idx in range(200):
Confusion_matrix[Y_test[idx]][knn_Y_pred[idx]] += 1
for i in range(10):
TP[i] = Confusion_matrix[i][i]
for j in range(10):
if i != j:
