Как ускорить разработанный алгоритм kNN

Question

Я только начинаю изучать python, я написал алгоритм kNN с использованием кластеризации и неравенства треугольников, но он медленнее, чем грубый. Я вижу, что код плохой, но я не могу переписать его. Может быть, вы можете рассказать, как ускорить программу?

def distance(x, y):
    if method == 'euclidean':
    return np.sqrt(np.sum((x-y)**2))  

k-means используется для тренировочного набора. Точки сортируются по расстоянию до центров.

def k_means(X, c):

    kmeans = KMeans(n_clusters=c).fit(X)
    centroids = kmeans.cluster_centers_

    distr = np.zeros((len(X), 3))
    distr[:, 0] = X[:, 0]
    distr[:, 1] = kmeans.predict(X)

    for i in range(len(X)):
        distr[i, 2] = distance(distr[i, 0], centroids[int(distr[i, 1])]) 

    distr = distr[distr[:, 2].argsort()[::-1]]

    return distr, centroids

kNN используется для тестового набора, поиск k соседей из обучающего набора.

def kNN(X, distr, cent, k=2):
    result = []

    for i in range(len(X)):
        c_d = np.zeros((len(cent), 2))
        c_d[:, 0] = np.arange(len(cent))
        knn = []

        for j in range(len(cent)):
            c_d[j, 1] = distance(X[i], cent[j])
        c_d = c_d[c_d[:, 1].argsort()]

        for temp_cl in range(len(cent)):
            P = distr[distr[:, 1] == c_d[temp_cl, 0]]

            for j in range(len(P)):
                if len(knn) < k:
                    d = distance(X[i], P[j, 0])
                    knn.append([P[j, 0], d])

                else:
                    d_max = max(knn[:][1])
                    if d_max <= abs(c_d[temp_cl, 1] - P[j, 2]):
                        break
                    else:
                        d = distance(X[i], P[j, 0])
                        if d_max > d:
                            m = np.where(d_max)[0]
                            knn[m[0]][0] = P[j, 0]
                            knn[m[0]][1] = d

        result.append(knn)
    result = np.array(result)
    indexes = result[:, :, 0]
    distances = result[:, :, 1]

    return indexes, distances