K láng giềng gần nhất

GV: Đặng Hữu Nghị

 KNN
KNN là gì?
• KNN (K-Nearest Neighbors) là một trong những
thuật toán học có giám sát đơn giản nhất được sử
dụng nhiều trong khai phá dữ liệu và học máy. Ý
tưởng của thuật toán này là nó không học một
điều gì từ tập dữ liệu học (nên KNN được xếp vào
loại lazy learning), mọi tính toán được thực hiện
khi nó cần dự đoán nhãn của dữ liệu mới.
• Lớp (nhãn) của một đối tượng dữ liệu mới có thể
dự đoán từ các lớp (nhãn) của k hàng xóm gần nó
nhất.
KNN
 KNN
Ví dụ:
• Giả sử ta có D là tập các dữ liệu đã được phân loại
thành 2 nhãn (+) và (-) được biểu diễn trên trục tọa độ
như hình vẽ và một điểm dữ liệu mới A chưa biết
nhãn. Vậy làm cách nào để chúng ta có thể xác định
được nhãn của A là (+) hay (-)?
• Có thể thấy cách đơn giản nhất là so sánh tất cả các
đặc điểm của dữ liệu A với tất cả tập dữ liệu học đã
được gắn nhãn và xem nó giống cái nào nhất, nếu dữ
liệu (đặc điểm) của A giống với dữ liệu của điểm mang
nhãn (+) thì điểm A mang nhãn (+), nếu dữ liệu A
giống với dữ liệu nhãn (-) hơn thì nó mang nhãn (-)
 KNN
• Trong trường hợp của KNN, thực tế nó
không so sánh dữ liệu mới (không được
phân lớp) với tất cả các dữ liệu khác, thực tế
nó thực hiện một phép tính toán học để đo
khoảng cách giữa dữ liệu mới với tất cả các
điểm trong tập dữ liệu học D để thực hiện
phân lớp.
• Phép tính khoảng cách giữa 2 điểm có thể là
Euclidian, Manhattan, trọng số, Minkowski, …
KNN
KNN
KNN
 KNN
• Các bước trong KNN
1. Ta có D là tập các điểm dữ liệu đã được gắn nhãn
và A là dữ liệu chưa được phân loại.
2. Đo khoảng cách (Euclidian, Manhattan, Minkowski,
Minkowski hoặc Trọng số) từ dữ liệu mới A đến tất
cả các dữ liệu khác đã được phân loại trong D.
3. Chọn K (K là tham số mà bạn định nghĩa) khoảng
cách nhỏ nhất.
4. Kiểm tra danh sách các lớp có khoảng cách ngắn
nhất và đếm số lượng của mỗi lớp xuất hiện.
5. Lấy đúng lớp (lớp xuất hiện nhiều lần nhất).
6. Lớp của dữ liệu mới là lớp mà bạn đã nhận được ở
bước 5.
Ví dụ
 KNN
Giả sử ta có tập dữ liệu D có gắn nhãn
gồm 15 điểm như trên ảnh.
• Điểm cần dự đoán nhãn A(3,9)
• Ta tính khoảng cách từ điểm A đến các
điểm dữ liệu trong D bằng công thức
Euclidian.
• Ta chọn K= 5, và tìm ra 5 điểm có
khoảng cách gần với điểm A nhất.
• Trong 5 điểm ta thấy có 4 điểm mang
nhãn (+) và 1 điểm mang nhãn (-).
• Vậy ta có thể đưa ra kết luận là điểm A
cần dự đoán mang nhãn (+).
 THỰC HÀNH KNN TRÊN PYTHON
• Hàm tính khoảng cách 2 điểm
import math
import operator

def euclideanDistance(instance1, instance2, length):

distance = 0
for x in range(length):
distance += pow((instance1[x] - instance2[x]), 2)
return math.sqrt(distance)
 THỰC HÀNH KNN TRÊN PYTHON
• Hàm lấy ra K láng giêng gần nhất

def getKNeighbors(trainingSet, testInstance, k):

distances = []
length = len(testInstance)
for x in range(len(trainingSet)):
dist = euclideanDistance(testInstance, trainingSet[x], length)
distances.append((trainingSet[x], dist))
distances.sort(key=operator.itemgetter(1),reverse=False)
# print(distances)
neighbors = []
for x in range(k):
neighbors.append(distances[x][0])
return neighbors
 THỰC HÀNH KNN TRÊN PYTHON
• Xây dựng tập training (huấn luyện) và testing
(kiểm tra)

trainSet = [[2,17,'+'], [3,11,'-'], [4,23,'+'], [1,12,'+'], [2, 6,'-'],

[6,2,'+'],[11,4,'-'],
[2,24,'-'],[14,2,'-'],[9,4,'+'],[24,23,'+'],[7,6,'+'],[23,4,'-'],[14,16,'-
'],[12,3,'+']]
testInstance = [3, 9]
k=5
neighbors = getKNeighbors(trainSet, testInstance, k)
print(neighbors)
 Ví dụ: Phân loại hoa Iris
Bộ cơ sở dữ liệu Iris (Iris flower dataset).
• Iris flower dataset là một bộ dữ liệu nhỏ (nhỏ hơn
rất nhiều so với MNIST. Bộ dữ liệu này bao gồm
thông tin của ba loại hoa Iris (một loài hoa lan)
khác nhau: Iris setosa, Iris virginica và Iris
versicolor.
• Mỗi loại có 50 bông hoa được đo với dữ liệu là 4
thông tin: chiều dài, chiều rộng đài hoa (sepal), và
chiều dài, chiều rộng cánh hoa (petal).
• Dưới đây là ví dụ về hình ảnh của ba loại hoa.
Ba loại hoa Ailen

Độ dài và độ rộng của lá đài (sepal)

và cánh hoa (petal)

16
 Ví dụ: Phân loại hoa Iris
Bảng mô tả thông tin của tập dữ liệu hoa Ailen.
• Bốn cột là một đặc tính (features).
• Cột cuối cùng là nhãn (label) chỉ tên loại hoa (một trong
ba loại: Iris-setosa, Iris-versicolour, và Iris-virginica)
Sepal length Sepal width Petal length Petal width Class

độ dài lá đài độ rộng lá đài độ dài cánh hoa độ rộng cánh hoa setosa||versicolour|| virginica

5.1 3.5 1.4 0.2 setosa

17
 Ví dụ: Phân loại hoa Iris
Hình sau biểu diễn 10 hàng đầu, mỗi hàng có 5 cột
thông tin về hoa Ailen .

18
 Ví dụ: Phân loại hoa Iris
• Đọc dữ liệu
import numpy as np
from sklearn import datasets
iris = datasets.load_iris()
iris_data = iris.data
iris_labels = iris.target
print(iris_data[0], iris_data[79], iris_data[100])
print(iris_labels[0], iris_labels[79], iris_labels[100])
 Ví dụ: Phân loại hoa Iris
• Tạo tập dữ liệu kiểm tra (testing) từ tập trên. Sử dụng phép hoán vị
ngẫu nhiên để tách ra tập tập kiểm tra (dùng np.random)

np.random.seed(42)
indices = np.random.permutation(len(iris_data))
n_training_samples = 12
learnset_data = iris_data[indices[:-n_training_samples]]
learnset_labels = iris_labels[indices[:-n_training_samples]]
testset_data = iris_data[indices[-n_training_samples:]]
testset_labels = iris_labels[indices[-n_training_samples:]]
print(learnset_data[:4], learnset_labels[:4])
print(testset_data[:4], testset_labels[:4])
 Ví dụ: Phân loại hoa Iris
• Biểu diễn dữ liệu của tập kiểm tra (testing)
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
colours = ("r", "b")
X = []
for iclass in range(3):
X.append([[], [], []])
for i in range(len(learnset_data)):
if learnset_labels[i] == iclass:
X[iclass][0].append(learnset_data[i][0])
X[iclass][1].append(learnset_data[i][1])
X[iclass][2].append(sum(learnset_data[i][2:]))
colours = ("r", "g", "y")
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for iclass in range(3):
ax.scatter(X[iclass][0], X[iclass][1], X[iclass][2], c=colours[iclass])
plt.show()
 Ví dụ: Phân loại hoa Iris
• Tính khoảng cách 2 mẫu

def distance(instance1, instance2):

# just in case, if the instances are lists or tuples:
instance1 = np.array(instance1)
instance2 = np.array(instance2)

return np.linalg.norm(instance1 - instance2)

print(distance([3, 5], [1, 1]))
print(distance(learnset_data[3], learnset_data[44]))
 Ví dụ: Phân loại hoa Iris
• Hàm trả về K láng giềng gần nhất của mẫu test_instance

def get_neighbors(training_set, labels, test_instance, k, distance=distance):

distances = []
for index in range(len(training_set)):
dist = distance(test_instance, training_set[index])
distances.append((training_set[index], dist, labels[index]))
distances.sort(key=lambda x: x[1])
neighbors = distances[:k]
return neighbors
 Ví dụ: Phân loại hoa Iris
• Kiểm tra hàm với các mẫu của tập kiểm tra

for i in range(5):
neighbors = get_neighbors(learnset_data, learnset_labels,
testset_data[i], 3, distance=distance)
print(i, testset_data[i], testset_labels[i], neighbors)
 Ví dụ: Phân loại hoa Iris
• Hàm kiểm tra xem lớp nào có nhiều mẫu hơn

from collections import Counter

def vote(neighbors):
class_counter = Counter()
for neighbor in neighbors:
class_counter[neighbor[2]] += 1
return class_counter.most_common(1)[0][0]
 Ví dụ: Phân loại hoa Iris
• Thử nghiệm trên tập testing

for i in range(n_training_samples):
neighbors = get_neighbors(learnset_data,
learnset_labels,
testset_data[i],
3,
distance=distance)
print("index: ", i,
", result of vote: ", vote(neighbors),
", label: ", testset_labels[i],
", data: ", testset_data[i])
 Phân loại hoa Iris sử dụng sklearn
• Trước tiên, chúng ta cần khai báo vài thư viện
Iris flower dataset có sẵn trong thư viện scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn import neighbors, datasets
• Tiếp theo, chúng ta load dữ liệu và hiện thị vài dữ liệu
mẫu. Các class được gán nhãn là 0, 1, và 2

iris = datasets.load_iris()
iris_X = iris.data
iris_y = iris.target
print ("Number of classes: %d:" %len(np.unique(iris_y)))
print ("Number of data points: %d" %len(iris_y))
X0 = iris_X[iris_y == 0,:]
print ('\nSamples from class 0:\n', X0[:5,:])
X1 = iris_X[iris_y == 1,:]
print ('\nSamples from class 1:\n', X1[:5,:])
X2 = iris_X[iris_y == 2,:]
print ('\nSamples from class 2:\n', X2[:5,:])
• Tách training và test sets
– Giả sử chúng ta muốn dùng 50 điểm dữ liệu cho test set, 100 điểm còn
lại cho training set. Scikit-learn có một hàm số cho phép chúng ta ngẫu
nhiên lựa chọn các điểm này, như sau:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
iris_X, iris_y, test_size=50)

print ("Training size: %d" %len(y_train))

print ("Test size : %d" %len(y_test))
• xét trường hợp đơn giản K = 1, tức là với mỗi điểm test data,
ta chỉ xét 1 điểm training data gần nhất và lấy label của điểm
đó để dự đoán cho điểm test này.

clf = neighbors.KNeighborsClassifier(n_neighbors = 1, p = 2)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

print ("Print results for 20 test data points:")

print ("Predicted labels: ", y_pred[20:40])
print ("Ground truth : ", y_test[20:40])
 Phương pháp đánh giá (evaluation
method)
• Để đánh giá độ chính xác của thuật toán KNN classifier này,
chúng ta xem xem có bao nhiêu điểm trong test data được dự
đoán đúng. Lấy số lượng này chia cho tổng số lượng trong tập
test data sẽ ra độ chính xác. Scikit-learn cung cấp hàm số
accuracy_score để thực hiện công việc này.

from sklearn.metrics import accuracy_score

print("Accuracy of 1NN: %.2f %%“
%(100*accuracy_score(y_test, y_pred)))
 Bài tập
• Phân loại (dự báo) bệnh tiểu đường sử dụng
phương pháp KNN
• Yêu cầu:
– Tạo tập dữ liệu kiểm tra (testing) từ tập trên. Sử dụng
phép hoán vị ngẫu nhiên để tách ra tập tập kiểm tra
(dùng np.random). Tập dữ liệu kiểm tra chiếm 30%
– Sử dụng tập dữ liệu kiểm tra để kiểm tra và đánh giá
sai số (sai số là tỉ lệ giữa số mẫu đúng / tổng số mẫu
kiểm tra)
– Chú ý: Không sử dụng các hàm phân loại có sẵn của
sklearn, tensorflow, v.v…
 Bài tập
• Hướng dẫn
Đọc dữ liệu từ tập tieuduong.csv
import numpy as np
dataset = np.loadtxt("D:\Tieu_duong.csv", delimiter=",")
 Bài tập
Tạo tập dữ liệu kiểm tra (testing) từ tập trên. Sử dụng phép
hoán vị ngẫu nhiên để tách ra tập tập kiểm tra (dùng
np.random)

np.random.seed(42)
indices = np.random.permutation(len(dataset))
n_training_samples = int(len(dataset)*0.3)
train_data = X[indices[:-n_training_samples]]
train_labels = Y[indices[:-n_training_samples]]
testset_data = X[indices[-n_training_samples:]]
testset_labels = Y[indices[-n_training_samples:]]
 Hồi quy (Regression)
• Phân tích hồi quy (regression analysis) là
kỹ thuật thống kê dùng để ước lượng
phương trình phù hợp nhất với các tập
hợp kết quả quan sát của biến phụ thuộc
và biến độc lập.
Regression examples
Polynomial Curve Fitting
0th Order Polynomial

n=10
1st Order Polynomial
3rd Order Polynomial
9th Order Polynomial
kNN Regression
kNN Regression
• Xét ví dụ: dự báo chỉ số giá nhà (House Price Index – HPI) dựa
vào tuổi (Age) và thu nhập (Loan)
 kNN Regression
• Với K = 1 thì láng giềng gần nhất là Age=33 và
Loan=$150,000 với HPI=264
D = Sqrt[(48-33)^2 + (142000-150000)^2]
= 8000.01 >> HPI = 264
Với K=3 xét 3 láng giềng gần nhất ta có:
HPI = (264+139+139)/3 = 180.7