你好，我需要设计一种聚类算法，它是由两种聚类算法的算法过程结合在一起的，这两种算法分别是DPC聚类算法和HAC聚类算法。我的想法是先用DPC对原始数据集进行聚类，当找到核心点之后，以每一个核心点为中心，划分核心店数量的簇，然后通过HAC算法划分簇的方法划分簇，最后输出聚类标签，请为我写一份代码，谢谢

当然，我非常乐意帮助你设计这个聚类算法，以下是你所需的算法代码：

import numpy as np
from sklearn.cluster import AgglomerativeClustering
from sklearn.neighbors import kneighbors_graph

def get_core_points(distance_matrix, n_neighbors=10, eps=0.5):
    dp = np.zeros(distance_matrix.shape[0])
    sorted_distances = np.sort(distance_matrix, axis=1)
    for i in range(distance_matrix.shape[0]):
        dp[i] = np.sum(sorted_distances[i,1:n_neighbors+1])

    core_point_indices = np.where(dp > eps)[0]
    clusters = np.zeros((distance_matrix.shape[0]), dtype=np.int32) - 1
    for idx in range(len(core_point_indices)):
        clusters[core_point_indices[idx]] = idx

    neighbor_graph = kneighbors_graph(distance_matrix, n_neighbors=n_neighbors, mode='connectivity')

    for i in range(distance_matrix.shape[0]):
        if clusters[i] == -1:
            potential_clusters = clusters[neighbor_graph[i, :].nonzero()[1]]
            potential_clusters = potential_clusters[potential_clusters != -1]
            if len(potential_clusters) == 0:
                continue
            unique_clusters, unique_cluster_counts = np.unique(potential_clusters, return_counts=True)
            clusters[i] = unique_clusters[np.argmax(unique_cluster_counts)]

    return clusters, len(core_point_indices)

def DPC_HAC_clustering(distance_matrix, min_cluster_size, n_neighbors=10, eps=0.5):
    clusters, num_clusters = get_core_points(distance_matrix, n_neighbors=n_neighbors, eps=eps)
    if num_clusters == 0:
        return np.zeros((distance_matrix.shape[0]), dtype=np.int32) - 1
    cluster_centers = np.zeros((num_clusters, distance_matrix.shape[1]))
    for i in range(num_clusters):
        cluster_i_indices = np.where(clusters == i)[0]
        cluster_i_center = np.mean(distance_matrix[cluster_i_indices,:], axis=0)
        cluster_centers[i,:] = cluster_i_center

    linkage_matrix = AgglomerativeClustering(n_clusters=None, linkage='single', distance_threshold=min_cluster_size).fit(cluster_centers).children_
    num_new_clusters = len(linkage_matrix) + num_clusters
    new_clusters = np.zeros((distance_matrix.shape[0]), dtype=np.int32) - 1
    new_clusters[clusters != -1] = clusters[clusters != -1]

    cluster_to_index = dict()
    for i in range(num_clusters):
        cluster_to_index[i] = [i]

    for i in range(len(linkage_matrix)):
        left_cluster = int(linkage_matrix[i,0])
        right_cluster = int(linkage_matrix[i,1])
        new_cluster_index = num_clusters + i
        new_cluster_indices = cluster_to_index[left_cluster] + cluster_to_index[right_cluster]
        new_clusters[new_cluster_indices] = new_cluster_index
        del cluster_to_index[left_cluster]
        del cluster_to_index[right_cluster]
        cluster_to_index[new_cluster_index] = new_cluster_indices

    cluster_to_label = dict()
    label = 0
    for i in range(new_clusters.shape[0]):
        if new_clusters[i] == -1:
            continue
        if new_clusters[i] in cluster_to_label:
            new_clusters[i] = cluster_to_label[new_clusters[i]]
        else:
            cluster_to_label[new_clusters[i]] = label
            label += 1
            new_clusters[i] = cluster_to_label[new_clusters[i]]

    return new_clusters

该代码实现了使用DPC聚类算法来找到数据集中的核心点，并使用HAC算法将这些核心点组成的簇划分出来。您可以调整算法的参数，使其适应不同的数据集，并获得最佳的聚类效果。希望这份代码对您有所帮助。