如何在Weka中为数据集每个点获取N个最近邻（KNN实现）

Got it, let's walk through exactly how to grab N nearest neighbors for each of your 1000 data points in Weka—whether you prefer clicking around the GUI or writing code to loop through and build your custom model afterward.

If you're more comfortable with a visual interface, here's how to pull up those neighbors:

• Fire up Weka Explorer and load your dataset (make sure it's in .arff format—Weka's go-to structure).
• Switch over to the Classify tab, click the Choose button, and pick lazy.IBk (this is Weka's standard k-NN implementation, even if you're not doing classification).
• Hit the Configure button next to IBk to tweak settings:
  • Set the KNN value to your desired N (e.g., 5 for 5 nearest neighbors).
  • Check the Output nearest neighbors box—this tells Weka to spit out each point's neighbors in the results.
  • No need to worry about excluding the point itself: IBk automatically skips the current instance when finding neighbors.
• Under Test options, select Use training set (since you want neighbors for every single one of your 1000 points).
• Click Start, and once it runs, scroll through the results—you'll see each instance's N nearest neighbors, including their indices and distance values.

If you need to loop through each point and build a custom model using their neighborhoods, coding with Weka's API is the way to go. Here's a step-by-step breakdown:

First, import the necessary classes (make sure Weka's JAR is in your project build path):

import weka.core.Instances;
import weka.core.neighboursearch.LinearNNSearch;
import weka.core.Instance;
import java.io.BufferedReader;
import java.io.FileReader;

Next, load your dataset:

// Replace with your dataset's file path
Instances data = new Instances(new BufferedReader(new FileReader("your_dataset.arff")));
// If working with a classification dataset, set the class index (skip if you don't need it)
data.setClassIndex(data.numAttributes() - 1);

Initialize the nearest neighbor searcher—for 1000 points, linear search is totally efficient. If you ever scale up to way more data, swap in KDTree instead:

LinearNNSearch nnSearch = new LinearNNSearch(data);
// Explicitly ensure we skip the current instance (default is true, but it's good to be clear)
nnSearch.setExcludeFirst(true);

Now loop through every instance to grab its N neighbors and do whatever you need for your model:

int N = 5; // Swap this with your desired number of neighbors
for (int i = 0; i < data.numInstances(); i++) {
    Instance currentPoint = data.instance(i);
    // Fetch the N nearest neighbors as an Instances object
    Instances neighbors = nnSearch.kNearestNeighbours(currentPoint, N);
    
    // This is where you'd build your model using the neighbors—example below just prints info
    System.out.printf("Instance %d's %d nearest neighbors:\n", i, N);
    for (Instance neighbor : neighbors) {
        double distance = nnSearch.getDistanceFunction().distance(currentPoint, neighbor);
        System.out.printf("- Index: %d, Distance: %.4f\n", data.indexOf(neighbor), distance);
    }
}

A quick tip: You can customize the distance function (e.g., switch from Euclidean to Manhattan) by setting it on the searcher:

import weka.core.EuclideanDistance;
nnSearch.setDistanceFunction(new EuclideanDistance());

内容的提问来源于stack exchange，提问作者geek2000