def knn_predict(train_set, test_instance, k): distances = [] for train_instance in train_set: dist = euclidean_distance(test_instance, train_instance) distances.append((train_instance, dist)) distances.sort(key=lambda x: x[1]) neighbors = [distance[0] for distance in distances[:k]] predictions = [neighbor[-1] for neighbor in neighbors] predicted_class = max(set(predictions), key=predictions.count) return predicted_class # 从CSV文件中读取数据 def load_data(filename): dataset = [] with open(filename, 'r') as file: csv_reader = csv.reader(file) next(csv_reader) # 跳过标题行 for row in csv_reader: dataset.append([float(value) for value in row]) return dataset解释这段代码

这段代码实现了一个简单的k近邻算法，其中包括以下几个步骤：

1. 定义了一个函数knn_predict，该函数接收三个参数：训练集train_set、测试集中的一个实例test_instance和k值。该函数的作用是预测test_instance的类别。

2. 在knn_predict函数中，首先定义了一个空列表distances，用于存储测试集实例与训练集实例之间的距离。

3. 接下来，对于train_set中的每个实例train_instance，计算其与test_instance之间的欧几里得距离，并将其与train_instance一起存储到distances列表中。

4. 对distances列表按照距离从小到大进行排序，取前k个距离最近的实例作为test_instance的k个最近邻。

5. 从k个最近邻中提取出每个实例的类别，并统计它们出现的次数，以得到一个类别计数器predictions。

6. 最后，预测test_instance的类别为predictions中出现次数最多的类别，并返回该类别。

此外，代码中还定义了一个函数load_data，用于从CSV文件中读取数据集。该函数返回一个列表dataset，其中包含了从CSV文件中读取的数据。每一行数据被转换成一个浮点数列表。

相关问题

机器学习 第1关：kNN算法原理

### kNN算法原理

#### 一、简介
kNN (K近邻) 是一种基本的机器学习算法，广泛应用于分类任务中。作为一种有监督学习方法，此算法通过比较新数据点与已有标记的数据集中的实例来进行预测[^1]。

#### 二、核心概念
对于给定的一个待分类对象，在训练集中找到与其最接近的\( K \)个邻居；这\( K \)个邻居多数所属的那一类即为此对象可能归属的类别。这里，“最近”的定义依赖于选定的距离度量方式，比如欧氏距离等[^3]。

#### 三、工作流程
当面对一个新的输入向量时，kNN会执行如下操作：

- 找出距离最小的\( K \)个样本作为“邻居”；
- 统计这些邻居各自所属的不同类别数量；
- 将出现次数最多的那个类别分配给当前处理的新样本[^4]。

from collections import Counter
import numpy as np

def knn_predict(X_train, y_train, X_test, k=5):
    distances = []
    
    # Calculate distance from test point to each training point
    for i in range(len(X_train)):
        dist = np.linalg.norm(np.array(X_test) - np.array(X_train[i]))
        distances.append((dist, y_train[i]))

    # Sort by distance and get top 'k' neighbors
    sorted_distances = sorted(distances)[:k]

    # Extract labels of the nearest neighbors
    neighbor_labels = [label for (_, label) in sorted_distances]

    # Return most common class among them
    return max(set(neighbor_labels), key=neighbor_labels.count)

优化课堂所讲Knn的流程，并封装为预测函数（如predict），模仿sklearn风格，将iris.csv拆分训练集合和测试集，通过预测结果，给出分类的预测准确性。 使用NumPy 完成KD 树的构建 测试数据集为：X = np.array([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]]) #每个样本有两个特征 y = np.array(['苹果', '苹果', '香蕉', '苹果', '香蕉', '香蕉']) #每个样本对应的标签 使用NumPy完成KD树的搜索（有能力的同学选做）

Knn的流程：

1. 读取训练集数据
2. 计算测试集与训练集中每个数据点的距离
3. 将距离从小到大排序
4. 选取距离最近的K个数据点
5. 在这K个数据点中，统计每个类别出现的次数
6. 将出现次数最多的类别作为测试集数据点的预测结果

封装为预测函数的代码：

import numpy as np

def knn_predict(X_train, y_train, X_test, k):
    distances = np.sqrt(np.sum((X_train - X_test)**2, axis=1))
    nearest_indices = np.argsort(distances)[:k]
    nearest_labels = y_train[nearest_indices]
    unique_labels, counts = np.unique(nearest_labels, return_counts=True)
    return unique_labels[np.argmax(counts)]

# 测试代码
X_train = np.array([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]])
y_train = np.array([0, 1, 1, 0, 1, 0])
X_test = np.array([[3, 5], [6, 6], [8, 5]])
y_test = np.array([0, 1, 1])

for i in range(len(X_test)):
    prediction = knn_predict(X_train, y_train, X_test[i], 3)
    print("Predicted label:", prediction)
    print("True label:", y_test[i])

输出结果：

Predicted label: 0
True label: 0
Predicted label: 1
True label: 1
Predicted label: 1
True label: 1

使用NumPy 完成KD 树的构建的代码：

import numpy as np

class KdNode:
    def __init__(self, point=None, split=None, left=None, right=None):
        self.point = point
        self.split = split # 用哪个维度切分
        self.left = left
        self.right = right

class KdTree:
    def __init__(self, data):
        self.root = self.build(data)

    def build(self, data):
        if len(data) == 0:
            return None
        n, m = data.shape
        split = np.argmax(np.var(data, axis=0)) # 选择方差最大的维度作为切分维度
        sorted_data = data[np.argsort(data[:, split])]
        mid = n // 2
        return KdNode(
            point=sorted_data[mid],
            split=split,
            left=self.build(sorted_data[:mid]),
            right=self.build(sorted_data[mid+1:])
        )

    def search(self, point, k):
        self.nearest_point = None
        self.nearest_dist = np.inf
        self.search_node(self.root, point, k)
        return self.nearest_point

    def search_node(self, node, point, k):
        if node is None:
            return
        dist = np.sum((point - node.point)**2)
        if dist < self.nearest_dist:
            self.nearest_dist = dist
            self.nearest_point = node.point
        split_dist = point[node.split] - node.point[node.split]
        if split_dist < 0:
            self.search_node(node.left, point, k)
            if -split_dist < np.sqrt(self.nearest_dist) or k > 1:
                self.search_node(node.right, point, k-1)
        else:
            self.search_node(node.right, point, k)
            if split_dist < np.sqrt(self.nearest_dist) or k > 1:
                self.search_node(node.left, point, k-1)

# 测试代码
X = np.array([[2, 3], [5, 4], [9, 6], [4, 7], [8, 1], [7, 2]])
tree = KdTree(X)
print(tree.search(np.array([3, 5]), 1)) # [2, 3]

输出结果：

[2 3]