如何找到一个点的最近邻居和另一个不是最近邻居的点？

Question

我的任务是找到一些点的最近邻居，并删除其他不是最近邻居的点。这个任务就像下采样问题。

到目前为止的代码：

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from scipy import spatial

data = pd.read_csv('data.csv')
majority = data.loc[data['class']==0]
minority = data.loc[data['class']==1]

majority_points=majority.drop('class', axis=1)
minority_points=minority.drop('class', axis=1)

all_data = pd.concat([majority,minority])

data_points = all_data.drop('class', axis=1)
# print(data_points)

majority_points=np.array(majority_points)
print (majority_points)
minority_points =np.array(minority_points)
print (minority_points)
    #result
    [[1 1]
 [1 2]
 [1 3]
 [1 4]
 [1 5]
 [2 1]
 [2 2]
 [2 4]
 [2 5]
 [3 1]
 [3 2]
 [3 5]
 [4 1]
 [4 4]
 [4 5]
 [5 1]
 [5 2]
 [5 3]
 [5 4]
 [5 5]] (20, 2)
[[2 3]
 [3 3]
 [3 4]
 [4 2]
 [4 3]]

`

#to find nearest neighbor
from scipy.spatial import distance
Y = distance.cdist(minority_points, majority_points, 'euclidean')

K = np.argsort(Y)
print (Y)
print ("Ordered data: \n", K)
Y.sort()
print ("After short: \n", Y)
#result
[[2.23606798 1.41421356 1.         1.41421356 2.23606798 2.
  1.         1.         2.         2.23606798 1.41421356 2.23606798
  2.82842712 2.23606798 2.82842712 3.60555128 3.16227766 3.
  3.16227766 3.60555128]
 [2.82842712 2.23606798 2.         2.23606798 2.82842712 2.23606798
  1.41421356 1.41421356 2.23606798 2.         1.         2.
  2.23606798 1.41421356 2.23606798 2.82842712 2.23606798 2.
  2.23606798 2.82842712]
 [3.60555128 2.82842712 2.23606798 2.         2.23606798 3.16227766
  2.23606798 1.         1.41421356 3.         2.         1.
  3.16227766 1.         1.41421356 3.60555128 2.82842712 2.23606798
  2.         2.23606798]
 [3.16227766 3.         3.16227766 3.60555128 4.24264069 2.23606798
  2.         2.82842712 3.60555128 1.41421356 1.         3.16227766
  1.         2.         3.         1.41421356 1.         1.41421356
  2.23606798 3.16227766]
 [3.60555128 3.16227766 3.         3.16227766 3.60555128 2.82842712
  2.23606798 2.23606798 2.82842712 2.23606798 1.41421356 2.23606798
  2.         1.         2.         2.23606798 1.41421356 1.
  1.41421356 2.23606798]]
Ordered data: 
 [[ 2  6  7  1  3 10  5  8  0 13 11  9  4 12 14 17 16 18 15 19]
 [10  6  7 13  9  2 17 11  1  3  5  8 18 12 14 16  0  4 15 19]
 [ 7 11 13  8 14  3 18 10 19  2  4 17  6  1 16  9 12  5 15  0]
 [16 10 12  9 17 15  6 13  5 18  7  1 14  0  2 11 19  8  3  4]
 [17 13 16 10 18 14 12  9 15 11 19  7  6  5  8  2  3  1  4  0]]
After short: 
 [[1.         1.         1.         1.41421356 1.41421356 1.41421356
  2.         2.         2.23606798 2.23606798 2.23606798 2.23606798
  2.23606798 2.82842712 2.82842712 3.         3.16227766 3.16227766
  3.60555128 3.60555128]
 [1.         1.41421356 1.41421356 1.41421356 2.         2.
  2.         2.         2.23606798 2.23606798 2.23606798 2.23606798
  2.23606798 2.23606798 2.23606798 2.23606798 2.82842712 2.82842712
  2.82842712 2.82842712]
 [1.         1.         1.         1.41421356 1.41421356 2.
  2.         2.         2.23606798 2.23606798 2.23606798 2.23606798
  2.23606798 2.82842712 2.82842712 3.         3.16227766 3.16227766
  3.60555128 3.60555128]
 [1.         1.         1.         1.41421356 1.41421356 1.41421356
  2.         2.         2.23606798 2.23606798 2.82842712 3.
  3.         3.16227766 3.16227766 3.16227766 3.16227766 3.60555128
  3.60555128 4.24264069]
 [1.         1.         1.41421356 1.41421356 1.41421356 2.
  2.         2.23606798 2.23606798 2.23606798 2.23606798 2.23606798
  2.23606798 2.82842712 2.82842712 3.         3.16227766 3.16227766
  3.60555128 3.60555128]]

我想将少数点中每个点的 3 个最近邻变为多数点，并保留其数组的值，其余的被删除。

这是插图：

1. before resampling/original dataset
2. after resampling

红点是少数示例，蓝点是多数示例。因此，每个少数类计算它的，例如，与多数最近的 3 个邻居。然后算法去除了一些不是最近邻的点。

Answer 1

看来您已经走得很远了，您需要一些帮助才能继续前进。您对距离进行排序的方式存在一个问题。您首先创建一个距离数组，然后对它们进行排序，但这样做会丢失每个距离的上下文信息。你有所有的距离，你对它们进行了排序，但你不知道它们适用于哪些点。这一步对我来说似乎没有必要，您可以停止使用K，它是现有项目的索引（不会丢失上下文信息），同时拥有有关其排序位置的信息。如果您查看K，您可能会注意到它是一个 5x20 矩阵，并且给定您的 majority_points 和 minoirty_points 的形状（分别为 20x2 和 5x2）这表明 K 是一个 2D 矩阵每行是给定nminority_point所有mmajority_points之间的排序距离的索引。

让我们看一个例子。 K 的第一行是

[ 2  6  7  1  3 10  5  8  0 13 11  9  4 12 14 17 16 18 15 19]

这意味着对于第一个minority_point[2, 3]，最接近的多数点位于索引 2、6、7、1、3 等处，其顺序为[1, 3][2, 2]@987654336 @[1, 2] 等等。如果你看一下，前 3 个是最短的距离，与有问题的 minority_point 仅相差 1 个单位。 （第一个是垂直的，第二个是水平的。）（请注意，排序算法将最接近的项以及 first 项都放置在输入数组中。因此索引 2 位于 6 之前或7，即使它们的距离都是一样的。）

因此，您需要做的就是创建一个新数组，为 K 中的每一行复制前 3 个索引处的项目。这与为每个 minority_points 说 3 个最接近的 majority_points 相同。

在 numpy 约定中，这意味着查看 majority_points 数组（而不是复制整个内容。）以下行应该可以工作（我测试过）：

majority_points[K[:,0:3]]

这意味着您从所有行（第一个维度，在逗号之前，都只是 :,）中获取来自 K (K[]) 的元素，并从第二个维度获取前 3 个元素。这些是您想从majority_points 获取的索引。

我的输出看起来像：

[[[1 3]
  [2 2]
  [2 4]]

 [[3 2]
  [2 2]
  [2 4]]

 [[2 4]
  [3 5]
  [4 4]]

 [[5 2]
  [3 2]
  [4 1]]

 [[5 3]
  [4 4]
  [5 2]]]