一个点，如何找到
它所属的簇？

    def _validate(self, X):
        X = np.asarray(X, dtype=float)
        if X.ndim != 2 or X.shape[0] < 2 or X.shape[1] < 1:
            raise ValueError("X must be a 2D matrix with at least two samples and one feature")
        if not np.isfinite(X).all():
            raise ValueError("X must contain only finite values")
        if isinstance(self.K, (bool, np.bool_)) or not isinstance(self.K, (int, np.integer)):
            raise ValueError("K must be an integer")
        if not 1 <= self.K < len(X):
            raise ValueError("K must satisfy 1 <= K < n_samples")
        if not np.isfinite(self.lam) or self.lam <= 0:
            raise ValueError("lam must be finite and positive (paper range: [0.25, 0.5])")
        if self.prune_mean not in ("all", "incident"):
            raise ValueError("prune_mean must be 'all' or 'incident'")
        if self.vote_rule not in ("strict", "plurality"):
            raise ValueError("vote_rule must be 'strict' or 'plurality'")
        if self.core_fallback not in ("error", "kmnn"):
            raise ValueError("core_fallback must be error or kmnn")
        return X

    def fit_predict(self, X):
        return self.fit(X).labels_

    def fit(self, X):
        X = self._validate(X)
        # Clear prior fitted results even if the new fit fails during core discovery.
        self.labels_ = self.centers_ = self.skeletons_ = self.n_clusters_ = None
        self.X_normalized_ = self._minmax_normalize(X)
        self.D_ = cdist(self.X_normalized_, self.X_normalized_)
        self._build_neighborhoods(self.D_)
        self._find_kfmnn()
        self._pruned_mst_density(self.D_)
        self._compute_delta_gamma(self.D_)
        self._build_skeletons()
        labels = np.full(len(X), -1, dtype=int)
        for c, skeleton in enumerate(self.skeletons_):
            labels[skeleton] = c
        self.skeleton_labels_ = labels.copy()
        self.labels_before_refinement_ = self._attractiveness_assignment(self.D_, labels)
        self.labels_ = (self._label_refinement(self.labels_before_refinement_) if self.refine
                        else self.labels_before_refinement_.copy())
        self.n_output_clusters_ = len(np.unique(self.labels_))
        return self

    @staticmethod
    def _minmax_normalize(X):
        span = np.ptp(X, axis=0)
        return (X - X.min(axis=0)) / np.where(span == 0, 1, span)

    def _build_neighborhoods(self, D):
        n, k = len(D), self.K
        self.K_eff_ = k
        knn = np.empty((n, k), dtype=int)
        for i in range(n):
            row = D[i].copy()
            row[i] = np.inf  # Exclude identity, not zero-distance duplicates.
            cutoff = np.partition(row, k - 1)[k - 1]
            closer = np.flatnonzero(row < cutoff)
            tied = np.flatnonzero(row == cutoff)[:k - len(closer)]
            chosen = np.concatenate((closer, tied))
            knn[i] = chosen[np.lexsort((chosen, row[chosen]))]
        self.knn_ = knn
        adjacency = csr_matrix((np.ones(n*k, dtype=np.int64),
                                (np.repeat(np.arange(n), k), knn.ravel())),
                               shape=(n, n))
        mutual = adjacency.multiply(adjacency.T).tocsr()
        self.mnn_ = [mutual.indices[mutual.indptr[i]:mutual.indptr[i+1]].copy()
                     for i in range(n)]
        self.knn2_ = [set(knn[knn[i]].ravel().tolist()) - {i} for i in range(n)]
        # Sparse product avoids the original dense O(n^3) integer product.
        self.snn_ = (adjacency @ adjacency.T).toarray()

    def _find_kfmnn(self):
        full = np.array([len(v) == self.K for v in self.mnn_])
        self.S_ = np.flatnonzero(full)
        self.SF_ = np.array([i for i in self.S_ if full[self.mnn_[i]].all()], dtype=int)
        self.strict_SF_ = self.SF_.copy()
        self.used_fallback_ = False
        if not len(self.SF_) and self.core_fallback == "kmnn" and len(self.S_):
            self.SF_ = self.S_.copy()
            self.used_fallback_ = True
        if not len(self.SF_):
            raise ValueError("No K-FMNN core points for this K; paper skeleton initialization "
                             "is undefined. Choose another K; no K-MNN fallback is applied.")

    @staticmethod
    def _mst(sub):
        """Dense Prim; returns local endpoint pairs and weights, including zero edges."""
        n = len(sub)
        used = np.zeros(n, dtype=bool)
        key = np.full(n, np.inf)
        parent = np.full(n, -1, dtype=int)
        key[0] = 0
        edges, weights = [], []
        for _ in range(n):
            u = int(np.argmin(np.where(used, np.inf, key)))
            used[u] = True
            if parent[u] >= 0:
                edges.append((parent[u], u))
                weights.append(key[u])
            improve = (~used) & (sub[u] < key)
            key[improve] = sub[u, improve]
            parent[improve] = u
        return np.asarray(edges, dtype=int).reshape(-1, 2), np.asarray(weights)

    def _pruned_mst_density(self, D):
        rho = np.zeros(len(D))
        for i in range(len(D)):
            nodes = np.r_[i, self.knn_[i]]
            edges, weights = self._mst(D[np.ix_(nodes, nodes)])
            reference = weights if self.prune_mean == "all" else weights[(edges == 0).any(axis=1)]
            mean = reference.mean()
            # Eq. 6 is undefined at mean=0: retain zero edges, reject positive ones.
            keep = (np.abs(weights - mean) < self.lam * mean) if mean > 0 else (weights == 0)
            rho[i] = np.exp(-weights[keep]).sum() / self.K
        self.rho_ = rho

    def _compute_delta_gamma(self, D):
        n = len(D)
        self.delta_ = np.zeros(n)
        self.nneigh_ = np.full(n, -1, dtype=int)
        for i in range(n):
            higher = np.flatnonzero(self.rho_ > self.rho_[i])
            if len(higher):
                j = higher[np.argmin(D[i, higher])]
                self.delta_[i], self.nneigh_[i] = D[i, j], j
            else:
                self.delta_[i] = D[i].max()
        self.gamma_ = self.rho_ * self.delta_

    def _build_skeletons(self):
        remaining = set(self.SF_.tolist())
        skeletons, centers = [], []
        while remaining:
            cen = min(remaining, key=lambda i: (-self.rho_[i], i))
            centers.append(cen)
            queue, group = deque([cen]), []
            remaining.remove(cen)
            while queue:
                p = queue.popleft()
                group.append(p)
                reachable = (set(self.knn_[p]) | self.knn2_[p]) & remaining
                for q in sorted(reachable):
                    remaining.remove(q)
                    queue.append(q)
            skeletons.append(np.asarray(group, dtype=int))
        self.skeletons_ = skeletons
        self.centers_ = np.asarray(centers, dtype=int)
        self.n_clusters_ = len(skeletons)

    def _attractiveness_assignment(self, D, labels):
        labels = labels.copy()
        contribution = self.snn_ * np.exp(-np.abs(self.rho_[:, None] - self.rho_[None, :]) - D)
        np.fill_diagonal(contribution, 0)
        scores = np.column_stack([contribution[:, s].sum(axis=1) for s in self.skeletons_])
        pending = labels < 0
        self.zero_attraction_assignments_ = 0
        while pending.any():
            ids = np.flatnonzero(pending)
            sub = scores[ids]
            pos, cluster = np.unravel_index(np.argmax(sub), sub.shape)
            point = ids[pos]
            if sub[pos, cluster] == 0:
                self.zero_attraction_assignments_ += 1
            labels[point] = cluster
            pending[point] = False
            scores[:, cluster] += contribution[:, point]
        return labels

    def _label_refinement(self, labels):
        result = labels.copy()
        for i, neighbors in enumerate(self.knn_):
            counts = np.bincount(labels[neighbors], minlength=self.n_clusters_)
            winners = np.flatnonzero(counts == counts.max())
            if len(winners) == 1:
                winner = winners[0]
                if self.vote_rule == "plurality" or counts[winner] > self.K / 2:
                    result[i] = winner
        return result

• Prim endpoints and weights match _mst exactly
• Retained-edge contributions equal rho[target]
• BFS order and centers match _build_skeletons
• Propagation replay equals labels_before_refinement_
• Contributor sums equal target attractiveness at assignment
• Refinement replay equals labels_

数据 SHA-256：c61fbbf821d5b20d6a9ab211a1fba1fb2a60feca3ff682903f998f6de73ba8f1

算法源文件 SHA-256：e48c6e0b6bb910ec8f3a817a30d9879215ce3f3470b2ddc209e24cebbe1e2d2a