和我一起学机器学习-K近邻法

比眉伴天荒 2023-09-30 23:51 5阅读 0赞

> K近邻（`K-Nearest Neighbors`，`KNN`）是一种基于实例的学习算法，它的原理是通过计算样本之间的距离来确定最近的`K`个邻居，然后根据邻居的标签来预测当前样本的标签。

`KNN`算法的优点是简单、易于理解和实现，但是在处理大规模数据集时会比较慢，同时需要选取合适的`K`值和距离度量方式。

在`PyTorch`中，可以使用`torch.nn`模块来实现`KNN`模型。以下是一个简单的例子，其中使用`KNN`模型来对`iris`数据集进行分类：

import torch
    import torch.nn as nn
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    
    # 加载iris数据集
    iris = load_iris()
    X, y = iris.data, iris.target
    
    # 对数据进行标准化处理
    scaler = StandardScaler()
    X = scaler.fit_transform(X)
    
    # 将数据集分为训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
    
    # 定义KNN模型
    class KNN(nn.Module):
        def __init__(self, k=3):
            super(KNN, self).__init__()
            self.k = k
            
        def forward(self, x, X_train, y_train):
            dist = torch.cdist(x, X_train)
            _, indices = torch.sort(dist)
            y_pred = torch.mode(y_train[indices[:,:self.k]], dim=1).values
            return y_pred
    
    # 定义模型和优化器
    model = KNN(k=3)
    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
    
    # 训练模型
    for epoch in range(100):
        running_loss = 0.0
        for i, data in enumerate(zip(X_train, y_train)):
            x, y = data
            x = torch.tensor(x, dtype=torch.float32).unsqueeze(0)
            y = torch.tensor(y, dtype=torch.long)
            
            optimizer.zero_grad()
            
            y_pred = model(x, torch.tensor(X_train, dtype=torch.float32), torch.tensor(y_train, dtype=torch.long))
            loss = nn.functional.cross_entropy(y_pred.unsqueeze(0), y.unsqueeze(0))
            loss.backward()
            optimizer.step()
            
            running_loss += loss.item()
        print(f"Epoch {
          epoch+1} loss: {
          running_loss/len(X_train)}")
    
    # 测试模型
    correct = 0
    total = 0
    with torch.no_grad():
        for i, data in enumerate(zip(X_test, y_test)):
            x, y = data
            x = torch.tensor(x, dtype=torch.float32).unsqueeze(0)
            y = torch.tensor(y, dtype=torch.long)
            
            output = model(x, torch.tensor(X_train, dtype=torch.float32), torch.tensor(y_train, dtype=torch.long))
            
            total += 1
            if output == y.item():
                correct += 1
                
    print(f"Accuracy: {
          correct/total}")

在这个例子中，我们定义了一个`KNN`模型，它的`forward`函数中实现了`KNN`算法的原理，其中使用了`torch.cdist`函数来计算样本之间的距离，使用`torch.sort`函数对距离进行排序，并根据`K`值选择最近的`K`个邻居，最后使用`torch.mode`函数对邻居的标签进行投票，得到当前样本的预测标签。在训练过程中，我们使用交叉熵损失函数来计算模型的损失，并使用随机梯度下降优化器来更新模型参数。在测试过程中，我们使用测试集来评估模型的性能，计算分类准确率。

在`KNN`模型中，`K`值的选取对模型的性能影响较大，一般需要通过交叉验证等方法来选择最优的`K`值。此外，`KNN`模型对特征之间的距离度量方式比较敏感，需要根据实际情况选择合适的度量方式。在实际应用中，还需要对数据进行预处理、特征选择等操作，以获得更好的性能。