寫KD樹的時候沒把類別考慮進去。。。所以先用KD算出最近的k個點，然后找到對應分類最后輸出占比最大的

KD樹是一種二叉樹，用來分割空間上得點

一個樹節點的結構如下：

class TreeNode:

index = -1 # 對應維度序號

point = None # 對應的點

left = None # 左子樹

right = None # 右子樹

data = None

def __init__(self, index=-1, point=None, left=None, right=None):

self.index = index

self.point = point

self.left = left

self.right = right

def set_data(self, data):

self.data = data

def get_data(self):

return self.data

建樹過程是：

先選出方差最大的維度

將現有數據按該維度排序

取數據中位點

中位點即該樹結點的數據

點坐標左邊的的傳入左子樹構造方法，右邊的同理

下一層樹結點使用下一個維度

代碼：

def build_tree(self, dataset, split):

# 如果為空返回None

if dataset is None or len(dataset) is 0:

return None

# 順序維度超出維度范圍取余

if split >= len(dataset[0]) - 1:

split %= len(dataset[0]) - 1

# 如果僅只有一個點那么必定是葉子

if len(dataset) is 1:

return TreeNode(split, dataset[0], None, None)

data_sum = len(dataset)

dataset.sort(key=lambda x: x[split])

node = TreeNode()

node.index = split

point_index = int(data_sum / 2)

node.point = dataset[point_index]

node.left = self.build_tree(dataset[0:point_index], split + 1)

node.right = self.build_tree(dataset[point_index + 1:], split + 1)

return node

def create(self, dataset):

starlin = self.get_var(dataset)

root = self.build_tree(dataset, starlin)

self.root = root

return root

有時候check后的數據需要插入到樹中：

插入的過程較簡單，從root開始 按該層維度，大于該層維度的值的繼續搜索左子樹，反之右子樹

直到搜索的節點為None 則在這里插入新的結點

def insert(self, point):

if self.root is None:

print('Build a tree first !')

return

if len(point) is not len(self.root.point):

print('This point have {l} splits but tree have {m}'.format(l=len(point), m=len(self.root.point)))

return

flag = False

root = self.root

while not flag:

if point[root.index] < root.point[root.index]:

if root.left is not None:

root = root.left

else:

split = (root.index + 1) % len(point)

root.left = TreeNode(split, point, None, None)

flag = True

else:

if root.right is not None:

root = root.right

else:

split = (root.index + 1) % len(point)

root.right = TreeNode(split, point, None, None)

flag = True

尋找過程，首先先按照插入的方法找到最接近的最底層子節點

然后依次向上回溯查找，如果該結點的另半個子樹也可能成為最近點則將其Push進棧

查找至棧為空，則找到最近點。點間距離同理可應用不同的距離（相似度）算法

def sim_distance(self, p1, p2):

sum_of_squares = sum([pow(p1[i] - p2[i], 2) for i in range(len(p1))])

return sqrt(sum_of_squares)

def find_nearest(self, point):

root = self.root

s = Stack(99999)

while root is not None:

index = root.index

s.push(root)

if point[index] <= root.point[index]:

root = root.left

else:

root = root.right

nearest = s.pop()

min_dist = self.sim_distance(nearest.point, point)

while not s.isempty():

back_point = s.pop()

if back_point is None:

continue

index = back_point.index

if self.sim_distance([point[index]], [back_point.point[index]]) < min_dist:

if point[index] <= back_point.point[index]:

root = back_point.right

else:

root = back_point.left

s.push(root)

if min_dist > self.sim_distance(back_point.point, point):

nearest = back_point

min_dist = self.sim_distance(back_point.point, point)

return nearest.point, min_dist

KNN 算法的核心在于找到最近的k的點，然后根據這些點的類別缺點待查點的類別

我維護了一個長度始終為k的list來保存前k小得距離

每次跟 list尾部的進行比較，如果比其小則加入list，并排序 取前k項

def find_near_kth(self, point, k):

root = self.root

result = []

s = Stack(99999)

while root is not None:

index = root.index

s.push(root)

if point[index] <= root.point[index]:

root = root.left

else:

root = root.right

t_point = s.pop()

result.append((t_point, self.sim_distance(t_point.point, point)))

while not s.isempty():

back_point = s.pop()

if back_point is None:

continue

index = back_point.index

if self.sim_distance([point[index]], [back_point.point[index]]) <= result[len(result) - 1][1] or len(

result) < k:

if point[index] <= back_point.point[index]:

root = back_point.right

else:

root = back_point.left

s.push(root)

if result[len(result) - 1][1] > self.sim_distance(back_point.point, point) or len(result) < k:

result.append((back_point, self.sim_distance(back_point.point, point)))

result.sort(key=lambda x: x[1])

result = result[0:k]

return result

最后用了很蠢得方法來找對應點的分類：

def decide_type(kd_result, t_point, t_type):

ans = {i: 0 for i in t_type}

for node in kd_result:

for i in range(len(t_point)):

if node[0].point == t_point[i]:

ans[t_type[i]] += 1

break

max_v = 0

max_type = None

for i in ans:

if ans[i] > max_v:

max_v = ans[i]

max_type = i;

return max_type

測試如下：

kd = KdTree()

kd.create(train_point)

print(kd.find_near_kth((1, 1), 2))

# print(decide_type(kd.find_near_kth((6.5, 6), 3),train_point,train_type))

總結

以上是生活随笔為你收集整理的kd树 python实现_Python KD树实现+简单的KNN实现的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。